常用工具類

1.數據比對工具

package com.micecs.erp.util;

import com.baomidou.mybatisplus.core.enums.IEnum;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import java.math.BigDecimal;
import java.util.*;

/**
 * 數據比對工具
 * 大數據量的比對，可以考慮加入多線程進行優化
 *
 * @author liulei, [email protected]
 * @version 1.0
 */
public class CompareListUtil {

    public static void main(String[] args) {
        complexCompare();
        System.out.println("=============");
        simpleCompare();
    }

    /**
     * 大數據量比對.避免二次for循環比對,超過2000的數據就可以適當考慮
     */
    public static void complexCompare() {
        //1.準備源、目標端數據
        List<ContentValues> sourceDataList = DataGenerateUtil.getSourceDataList();
        List<ContentValues> targetDataList = DataGenerateUtil.getTargetDataList();
        List<ContentValues> compareSourceDataList;
        List<ContentValues> compareTargetDataList;
        //2.提前設置map最大值,避免map主動擴容
        Integer size = 0;
        Map<ContentValues, CompareModelEnum> map = new HashMap<>(size);
        if (sourceDataList.size() > targetDataList.size()) {
            size = sourceDataList.size();
            compareSourceDataList = new ArrayList<>(sourceDataList);
            compareTargetDataList = new ArrayList<>(targetDataList);
        } else {
            size = targetDataList.size();
            compareSourceDataList = new ArrayList<>(targetDataList);
            compareTargetDataList = new ArrayList<>(targetDataList);
        }
        //3.設置默認數據屬性:待刪除
        compareSourceDataList.stream().forEach(vo -> map.put(vo, CompareModelEnum.DELETE));
        //4.比對數據
        for (ContentValues value : compareTargetDataList) {
            if (map.containsKey(value)) {
                map.put(value, CompareModelEnum.UPDATE);
            } else {
                map.put(value, CompareModelEnum.INSERT);
            }
        }
        //5.整理比對結果集
        CompareResult insert = new CompareResult(CompareModelEnum.INSERT, Lists.newArrayList());
        CompareResult update = new CompareResult(CompareModelEnum.UPDATE, Lists.newArrayList());
        CompareResult delete = new CompareResult(CompareModelEnum.DELETE, Lists.newArrayList());
        map.forEach((key, value) -> {
            switch (value) {
                case INSERT:
                    insert.getValues().add(key);
                    break;
                case UPDATE:
                    update.getValues().add(key);
                    break;
                default:
                    delete.getValues().add(key);
            }
        });
        System.out.println("待添加：" + insert.toString());
        System.out.println("待刪除：" + delete.toString());
        System.out.println("待修改：" + update.toString());
    }

    /**
     * 小數據量的比較
     */
    public static void simpleCompare() {
        //1.準備源、目標端數據
        List<ContentValues> sourceDataList = DataGenerateUtil.getSourceDataList();
        List<ContentValues> targetDataList = DataGenerateUtil.getTargetDataList();
        //2.比較兩者的大小.將大的集合put進map中
        getSimpleCompareResult(sourceDataList, targetDataList);
    }

    /**
     * 獲取兩個集合不同：簡單比較[對於交集是否修改/不修改，取決於源、目標相同對象的其他字段是否存在變化]
     *
     * @param sourceList 源
     * @param targetList 目標
     * @return 0-交集 1-差集 2-源存在而目標不存在
     */
    public static Map<CompareModelEnum, List<ContentValues>> getSimpleCompareResult(List<ContentValues> sourceList, List<ContentValues> targetList) {
        Map<CompareModelEnum, List<ContentValues>> mapList = Maps.newHashMap();
        List<List<ContentValues>> result = Lists.newArrayList();
        List<ContentValues> erpIdCopy = Lists.newArrayList(sourceList);
        sourceList.retainAll(targetList);
        result.add(new ArrayList<>(sourceList));
        mapList.put(CompareModelEnum.UPDATE, sourceList);
        System.out.println("比對交集：待修改的 :" + sourceList.toString());
        targetList.removeAll(sourceList);
        result.add(new ArrayList<>(targetList));
        mapList.put(CompareModelEnum.INSERT, sourceList);
        System.out.println(("比對差集：待添加的 " + targetList.toString()));
        erpIdCopy.removeAll(targetList);
        sourceList.addAll(targetList);
        erpIdCopy.removeAll(sourceList);
        result.add(new ArrayList<>(erpIdCopy));
        mapList.put(CompareModelEnum.DELETE, sourceList);
        System.out.println(("比對後待刪除的 " + erpIdCopy.toString()));
        return mapList;
    }
}

/**
 * 比對結果實體類
 */
@Data
class CompareResult {

    private CompareModelEnum key;

    private List<ContentValues> values;

    public CompareResult(CompareModelEnum key, List<ContentValues> values) {
        this.key = key;
        this.values = values;
    }

    @Override
    public String toString() {
        return "CompareResult{" +
                "key=" + key +
                ", values=" + values +
                '}';
    }
}

/**
 * 比對結果枚舉
 */
enum CompareModelEnum implements IEnum<Integer> {

    /**
     * 列舉比對結果類型
     */
    UPDATE(1, "待更新"),
    INSERT(2, "待插入"),
    DELETE(3, "待刪除");

    private Integer value;
    private String desc;

    CompareModelEnum(Integer value, String desc) {
        this.value = value;
        this.desc = desc;
    }


    @Override
    public Integer getValue() {
        return value;
    }

    public static CompareModelEnum valueOf(Integer code) {
        for (CompareModelEnum value : CompareModelEnum.values()) {
            if (Objects.equals(value.getValue(), code)) {
                return value;

            }
        }
        throw new RuntimeException("無匹配的");
    }
}

/**
 * 數據比對實體對象
 */
@Data
class ContentValues {
    /**
     * 詢單號
     */
    private String rfpNo;
    /**
     * 供應商類型
     */
    private Integer supplierType;
    /**
     * 供應商ID
     */
    private Long supplierId;
    /**
     * 比對報價
     */
    private BigDecimal price;
    /**
     * 供應商返佣金額
     */
    private BigDecimal commissionMoney;

    @Override
    public String toString() {
        return "\nContentValues{" +
                "rfpNo='" + rfpNo + '\'' +
                ", supplierId=" + supplierId +
                ", price=" + price +
                ", commissionMoney=" + commissionMoney +
                ", supplierType=" + supplierType +
                '}';
    }

    /**
     * 重寫equals方法
     * 因爲object中的equals()方法比較的是對象的引用地址是否相等，如何你需要判斷對象裏的內容是否相等，則需要重寫equals()方法。
     * equals 相等，hashCode 必然要相等
     * hashCode 相同，equals 不一定相同
     */
    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof ContentValues)) {
            return false;
        }
        ContentValues content = (ContentValues) obj;
        return supplierId.equals(content.getSupplierId()) &&
                rfpNo.equals(content.getRfpNo()) &&
                price.compareTo(content.getPrice()) == 0 &&
                commissionMoney.compareTo(content.getCommissionMoney()) == 0;
    }

    /**
     * 重寫hashCode方法
     * Java中的hashCode方法就是根據一定的規則將與對象相關的信息（比如對象的存儲地址，對象的字段等）映射成一個數值，這個數值稱作爲散列值。
     * 主要是針對HashSet和Map集合類型，比如我們在向HashSet集合裏邊添加新元素的時候，
     * 由於set集合裏邊不允許元素重複，所以我們在插入新元素之前需要先判斷插入元素是否存在，首先根據hashCode()方法得到該對象的hashCode值，
     * 如果集合裏邊不存在該值，可以直接插入進去。如果已經存在，則需要再次通過equals()來比較，這樣的話可以提升效率。
     * <p>
     * 重寫equals()方法同時重寫hashcode()方法?
     * 就是爲了保證當兩個對象通過equals()方法比較相等時，那麼他們的hashCode值也一定要保證相等。
     */
    @Override
    public int hashCode() {
        return Objects.hash(supplierId, rfpNo, price, commissionMoney);
    }
}

/**
 * 數據構建工具類
 */
class DataGenerateUtil {
    /**
     * 構建源端數據
     */
    public static List<ContentValues> getSourceDataList() {
        List<ContentValues> list = Lists.newArrayList();
        ContentValues value1 = new ContentValues();
        value1.setRfpNo("rfp_01");
        value1.setSupplierId(100L);
        value1.setCommissionMoney(new BigDecimal(100));
        value1.setPrice(new BigDecimal(1000));
        value1.setSupplierType(1);
        ContentValues value2 = new ContentValues();
        value2.setRfpNo("rfp_01");
        value2.setSupplierId(200L);
        value2.setCommissionMoney(new BigDecimal(200));
        value2.setPrice(new BigDecimal(2000));
        value2.setSupplierType(1);
        ContentValues value3 = new ContentValues();
        value3.setRfpNo("rfp_02");
        value3.setSupplierId(300L);
        value3.setCommissionMoney(new BigDecimal(300));
        value3.setPrice(new BigDecimal(3000));
        value3.setSupplierType(1);
        ContentValues value4 = new ContentValues();
        value4.setRfpNo("rfp_03");
        value4.setSupplierId(400L);
        value4.setCommissionMoney(new BigDecimal(400));
        value4.setPrice(new BigDecimal(4000));
        value4.setSupplierType(2);
        ContentValues value5 = new ContentValues();
        value5.setRfpNo("rfp_03");
        value5.setSupplierId(500L);
        value5.setCommissionMoney(new BigDecimal(500));
        value5.setPrice(new BigDecimal(5000));
        value5.setSupplierType(2);
        list.add(value1);
        list.add(value2);
        list.add(value3);
        list.add(value4);
        list.add(value5);
        return list;
    }

    /**
     * 構建目標端數據
     */
    public static List<ContentValues> getTargetDataList() {
        List<ContentValues> list = Lists.newArrayList();
        ContentValues value1 = new ContentValues();
        value1.setRfpNo("rfp_01");
        value1.setSupplierId(100L);
        value1.setCommissionMoney(new BigDecimal(100));
        value1.setPrice(new BigDecimal(1000));
        value1.setSupplierType(1);
        ContentValues value2 = new ContentValues();
        value2.setRfpNo("rfp_01");
        value2.setSupplierId(200L);
        value2.setCommissionMoney(new BigDecimal(2100));
        value2.setPrice(new BigDecimal(21000));
        value2.setSupplierType(1);
        ContentValues value4 = new ContentValues();
        value4.setRfpNo("rfp_04");
        value4.setSupplierId(700L);
        value4.setCommissionMoney(new BigDecimal(700));
        value4.setPrice(new BigDecimal(7000));
        value4.setSupplierType(2);
        ContentValues value5 = new ContentValues();
        value5.setRfpNo("rfp_03");
        value5.setSupplierId(500L);
        value5.setCommissionMoney(new BigDecimal(1000));
        value5.setPrice(new BigDecimal(10000));
        value5.setSupplierType(2);
        list.add(value1);
        list.add(value2);
        list.add(value4);
        list.add(value5);
        return list;
    }
}

2.漢字轉拼音

package com.micecs.erp.util.thirdpart;

import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 漢字轉拼音插件
 *
 * @author liulei [email protected]
 * @version 1.0
 */
public class CharacterUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(CharacterUtil.class);
    /***
     * 將漢字轉成拼音(取首字母或全拼)
     * @param chinese
     * @param full 是否全拼
     * @return
     */
    public static String ConvertChinese2Pinyin(String chinese, boolean full) {
        /***
         * ^[\u2E80-\u9FFF]+$ 匹配所有東亞區的語言
         * ^[\u4E00-\u9FFF]+$ 匹配簡體和繁體
         * ^[\u4E00-\u9FA5]+$ 匹配簡體
         */
        String regExp = "^[\u4E00-\u9FFF]+$";
        StringBuffer sb = new StringBuffer();
        if (chinese == null || "".equals(chinese.trim())) {
            return "";
        }
        String pinyin;
        for (int i = 0; i < chinese.length(); i++) {
            char unit = chinese.charAt(i);
            //是漢字，則轉拼音
            if (match(String.valueOf(unit), regExp)) {
                pinyin = convertSingleChinese2Pinyin(unit);
                if (full) {
                    sb.append(pinyin);
                } else {
                    sb.append(pinyin.charAt(0));
                }
            } else {
                sb.append(unit);
            }
        }
        return sb.toString();
    }

    /***
     * 將單個漢字轉成拼音
     * @param chinese
     * @return
     */
    private static String convertSingleChinese2Pinyin(char chinese) {
        HanyuPinyinOutputFormat outputFormat = new HanyuPinyinOutputFormat();
        outputFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        String[] res;
        StringBuffer sb = new StringBuffer();
        try {
            res = PinyinHelper.toHanyuPinyinStringArray(chinese, outputFormat);
            //對於多音字，只用第一個拼音
            sb.append(res[0]);
        } catch (Exception e) {
            LOGGER.error("CONVERT SINGLE CHINESE TO PINYIN ERROR", e);
            return "";
        }
        return sb.toString();
    }

    /***
     * @param str 源字符串
     * @param regex 正則表達式
     * @return 是否匹配
     */
    public static boolean match(String str, String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        return matcher.find();
    }

    /**
     * 生成length長度的隨機數字和字母
     *
     * @param length
     * @return
     */
    public static String GetStringRandom(int length) {
        String val = "";
        Random random = new Random(1);
        //參數length，表示生成幾位隨機數
        int num = 0;
        while(num < length){
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
            //輸出字母還是數字
            if ("char".equalsIgnoreCase(charOrNum)) {
                //輸出是大寫字母還是小寫字母
                int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;
                val += (char) (random.nextInt(26) + temp);
                num++;
            }
        }
        return val;
    }

    /**
     * 判斷是否含有漢字
     */
    public static boolean isChinese(String chinese) {
        char[] arr = chinese.toCharArray();
        for (char anArr : arr) {
            boolean matches = String.valueOf(anArr).matches("[\u4e00-\u9fa5]");
            if (matches) {
                return true;
            }
        }
        return false;
    }
}

3.日期工具類

package com.example.lottery.module.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalUnit;
import java.util.Calendar;
import java.util.Date;

/**
 * 日期工具類
 *
 * @author liulei, [email protected]
 * @version 1.0
 */
public class DateUtils {
    public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DATE_FORMAT = "yyyy-MM-dd";

    public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HHmmss");
    public static final DateTimeFormatter YEAR_MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");
    public static final DateTimeFormatter SHORT_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyMMdd");
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DATE_FORMAT);
    public static final DateTimeFormatter SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
    public static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern(DATE_TIME_FORMAT);
    public static final DateTimeFormatter LONG_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss SSS");

    /**
     * Date類型轉時間字符串
     */
    public static String dateConvertToString(Date date, String format) {
        LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
        return dateTimeFormatter.format(localDateTime);
    }

    /**
     * 時間字符串轉Date
     */
    public static Date stringConvertToDate(String date, String format) throws ParseException {
        return new SimpleDateFormat(format).parse(date);
    }

    /**
     * 獲得當前日期
     *
     * @return
     */
    public static Date getNow() {
        Calendar cal = Calendar.getInstance();
        return cal.getTime();
    }

    /**
     * 獲取一天的開始時間，2017,7,22 00:00
     *
     * @param time
     * @return
     */
    public static LocalDateTime getDayStart(LocalDateTime time) {
        return time.withHour(0).withMinute(0).withSecond(0).withNano(0);
    }

    /**
     * 獲取一天的結束時間，2017,7,22 23:59:59.999999999
     *
     * @param time
     * @return
     */
    public static LocalDateTime getDayEnd(LocalDateTime time) {
        return time.withHour(23).withMinute(59).withSecond(59).withNano(999999999);
    }

    /**
     * 日期加上一個數,根據field不同加不同值,field爲ChronoUnit.*
     *
     * @param time
     * @param number
     * @param field
     * @return
     */
    public static LocalDateTime plus(LocalDateTime time, long number, TemporalUnit field) {
        return time.plus(number, field);
    }

    /**
     * 日期減去一個數,根據field不同減不同值,field參數爲ChronoUnit.*
     *
     * @param time
     * @param number
     * @param field
     * @return
     */
    public static LocalDateTime minu(LocalDateTime time, long number, TemporalUnit field) {
        return time.minus(number, field);
    }

    /**
     * 獲取兩個日期的差 field參數爲ChronoUnit.*
     *
     * @param startTime
     * @param endTime
     * @param field     單位(年月日時分秒)
     * @return
     */
    public static long betweenTwoTime(LocalDateTime startTime, LocalDateTime endTime, ChronoUnit field) {
        Period period = Period.between(LocalDate.from(startTime), LocalDate.from(endTime));
        if (field == ChronoUnit.YEARS) {
            return period.getYears();
        }
        if (field == ChronoUnit.MONTHS) {
            return period.getYears() * 12 + period.getMonths();
        }
        return field.between(startTime, endTime);
    }

    /**
     * 返回當前的日期
     */
    public static LocalDate getCurrentLocalDate() {
        return LocalDate.now(ZoneOffset.of("+8"));
    }

    /**
     * 返回當前時間
     */
    public static LocalTime getCurrentLocalTime() {
        return LocalTime.now(ZoneOffset.of("+8"));
    }

    /**
     * 返回當前日期時間
     */
    public static LocalDateTime getCurrentLocalDateTime() {
        return LocalDateTime.now(ZoneOffset.of("+8"));
    }

    /**
     * yyyy-MM-dd
     */
    public static String getCurrentDateStr() {
        return LocalDate.now(ZoneOffset.of("+8")).format(DATE_FORMATTER);
    }

    /**
     * yyMMdd
     */
    public static String getCurrentShortDateStr() {
        return LocalDate.now(ZoneOffset.of("+8")).format(SHORT_DATE_FORMATTER);
    }

    public static String getCurrentMonthStr() {
        return LocalDate.now(ZoneOffset.of("+8")).format(YEAR_MONTH_FORMATTER);
    }

    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentDateTimeStr() {
        return LocalDateTime.now(ZoneOffset.of("+8")).format(DATETIME_FORMATTER);
    }

    public static String getCurrentLongDateTimeStr() {
        return LocalDateTime.now(ZoneOffset.of("+8")).format(LONG_DATETIME_FORMATTER);
    }

    /**
     * yyMMddHHmmss
     */
    public static String getCurrentShortDateTimeStr() {
        return LocalDateTime.now(ZoneOffset.of("+8")).format(SHORT_DATETIME_FORMATTER);
    }

    /**
     * HHmmss
     */
    public static String getCurrentTimeStr() {
        return LocalTime.now(ZoneOffset.of("+8")).format(TIME_FORMATTER);
    }

    public static String getCurrentDateStr(String pattern) {
        return LocalDate.now(ZoneOffset.of("+8")).format(DateTimeFormatter.ofPattern(pattern));
    }

    public static String getCurrentDateTimeStr(String pattern) {
        return LocalDateTime.now(ZoneOffset.of("+8")).format(DateTimeFormatter.ofPattern(pattern));
    }

    public static String getCurrentTimeStr(String pattern) {
        return LocalTime.now(ZoneOffset.of("+8")).format(DateTimeFormatter.ofPattern(pattern));
    }

    public static LocalDate parseLocalDate(String dateStr, String pattern) {
        return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(pattern));
    }

    public static LocalDateTime parseLocalDateTime(String dateTimeStr, String pattern) {
        return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ofPattern(pattern));
    }

    public static LocalTime parseLocalTime(String timeStr, String pattern) {
        return LocalTime.parse(timeStr, DateTimeFormatter.ofPattern(pattern));
    }

    public static String formatLocalDate(LocalDate date, String pattern) {
        return date.format(DateTimeFormatter.ofPattern(pattern));
    }

    public static String formatLocalDateTime(LocalDateTime datetime, String pattern) {
        return datetime.format(DateTimeFormatter.ofPattern(pattern));
    }

    public static String formatLocalTime(LocalTime time, String pattern) {
        return time.format(DateTimeFormatter.ofPattern(pattern));
    }

    public static LocalDate parseLocalDate(String dateStr) {
        return LocalDate.parse(dateStr, DATE_FORMATTER);
    }

    public static LocalDateTime parseLocalDateTime(String dateTimeStr) {
        return LocalDateTime.parse(dateTimeStr, DATETIME_FORMATTER);
    }

    public static LocalDateTime parseLongLocalDateTime(String longDateTimeStr) {
        return LocalDateTime.parse(longDateTimeStr, LONG_DATETIME_FORMATTER);
    }

    public static LocalTime parseLocalTime(String timeStr) {
        return LocalTime.parse(timeStr, TIME_FORMATTER);
    }

    public static String formatLocalDate(LocalDate date) {
        return date.format(DATE_FORMATTER);
    }

    public static String formatLocalDateTime(LocalDateTime datetime) {
        return datetime.format(DATETIME_FORMATTER);
    }

    public static String formatLocalTime(LocalTime time) {
        return time.format(TIME_FORMATTER);
    }

    /**
     * 日期相隔秒
     */
    public static long periodHours(LocalDateTime startDateTime, LocalDateTime endDateTime) {
        return Duration.between(startDateTime, endDateTime).get(ChronoUnit.SECONDS);
    }

    /**
     * 日期相隔天數
     */
    public static long periodDays(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.DAYS);
    }

    /**
     * 日期相隔週數
     */
    public static long periodWeeks(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.WEEKS);
    }

    /**
     * 日期相隔月數
     */
    public static long periodMonths(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.MONTHS);
    }

    /**
     * 日期相隔年數
     */
    public static long periodYears(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.YEARS);
    }

    /**
     * 是否當天
     */
    public static boolean isToday(LocalDate date) {
        return getCurrentLocalDate().equals(date);
    }

    /**
     * 獲取當前毫秒數
     */
    public static Long toEpochMilli(LocalDateTime dateTime) {
        return dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }

    /**
     * 判斷是否爲閏年
     */
    public static boolean isLeapYear(LocalDate localDate) {
        return localDate.isLeapYear();
    }

    /**
     * 將java.util.Date 轉換爲java8 的java.time.LocalDateTime,默認時區爲東8區
     *
     * @param date
     * @return
     */
    public static LocalDateTime dateConvertToLocalDateTime(Date date) {
        return date.toInstant().atOffset(ZoneOffset.of("+8")).toLocalDateTime();
    }

    /**
     * 將java8 的 java.time.LocalDateTime 轉換爲 java.util.Date，默認時區爲東8區
     *
     * @param localDateTime
     * @return
     */
    public static Date localDateTimeConvertToDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.toInstant(ZoneOffset.of("+8")));
    }

    /**
     * 毫秒轉LocalDateTime
     *
     * @param milliseconds
     * @return
     */
    public static LocalDateTime millisecToDatetime(long milliseconds) {
        Instant instant = Instant.ofEpochMilli(milliseconds);
        return LocalDateTime.ofInstant(instant, ZoneOffset.of("+8"));
    }

    /**
     * 將LocalDataTime轉爲毫秒數
     *
     * @param ldt
     * @return
     */
    public static long datatimeToTimestamp(LocalDateTime ldt) {
        return ldt.toInstant(ZoneOffset.of("+8")).toEpochMilli();
    }

    /**
     * 把long 轉換成 日期 再轉換成Date類型
     */
    public static Date transferLongToDate(Long millSec) {
        return new Date(millSec);
    }

    public static Date getDateBefore(int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, -day);
        return calendar.getTime();
    }

    public static String getDateBeforeByLocalDateTime(int day) {
        return dateConvertToLocalDateTime(getDateBefore(day)).format(DATETIME_FORMATTER);
    }

    public static String getDateBeforeBySimpleDateFormat(int day, String format) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        calendar.add(Calendar.DATE, -day);
        return sdf.format(calendar.getTime());
    }

    public static String getDateAfterBySimpleDateFormat(int day, String format) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        calendar.add(Calendar.DATE, day);
        return sdf.format(calendar.getTime());
    }

    public static void main(String[] args) throws ParseException {
        System.out.println(dateConvertToString(new Date(), DATE_FORMAT));
        System.out.println(stringConvertToDate("2018-06-01 10:12:05", DATE_FORMAT));
        System.out.println(getDateBeforeByLocalDateTime(23));
        System.out.println(millisecToDatetime(1563867467000L).format(DATETIME_FORMATTER));
        System.out.println(datatimeToTimestamp(getCurrentLocalDateTime()));
        System.out.println(getCurrentDateTimeStr("yyyy年MM月dd日 HH:mm:ss"));
        System.out.println(getCurrentDateTimeStr());

        Date date = getNow();
        LocalDateTime localDateTime = dateConvertToLocalDateTime(date);
        Long localDateTimeSecond = localDateTime.toEpochSecond(ZoneOffset.of("+8"));
        Long dateSecond = date.toInstant().atOffset(ZoneOffset.of("+8")).toEpochSecond();
        System.out.println("dateSecond:" + dateSecond);
        System.out.println("localDateTimeSecond:" + localDateTimeSecond);

        // 增加二十分鐘
        System.out.println(formatLocalDateTime(plus(LocalDateTime.now(), 20, ChronoUnit.MINUTES), "yyyy年MM月dd日 HH:mm"));
        // 增加兩年
        System.out.println(formatLocalDateTime(plus(LocalDateTime.now(), 2, ChronoUnit.YEARS), "yyyy年MM月dd日 HH:mm"));

        LocalDateTime start = LocalDateTime.of(1993, 10, 13, 11, 11);
        LocalDateTime end = LocalDateTime.of(1994, 11, 13, 13, 13);
        System.out.println("年:" + betweenTwoTime(start, end, ChronoUnit.YEARS));
        System.out.println("月:" + betweenTwoTime(start, end, ChronoUnit.MONTHS));
        System.out.println("日:" + betweenTwoTime(start, end, ChronoUnit.DAYS));
        System.out.println("半日:" + betweenTwoTime(start, end, ChronoUnit.HALF_DAYS));
        System.out.println("小時:" + betweenTwoTime(start, end, ChronoUnit.HOURS));
        System.out.println("分鐘:" + betweenTwoTime(start, end, ChronoUnit.MINUTES));
        System.out.println("秒:" + betweenTwoTime(start, end, ChronoUnit.SECONDS));
        System.out.println("毫秒:" + betweenTwoTime(start, end, ChronoUnit.MILLIS));
    }
}