这个明天一定要完成这个，已经要将Date中的所有的功能都汇总起来
    1.直接根据年月日生成对应的时间
    2.能够解析时间
    3.反向解析时间
    4.时间向前移动一定的时间，和向后移动一定的时间
    5.借鉴apache中的所有的功能
    6.借鉴Heimdair中的DateUtil中的所有的功能

    1. import java.sql.Time;
    2. import java.sql.Timestamp;
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.time.*;
    6. import java.time.format.DateTimeFormatter;
    7. import java.util.Date;
    8. import java.util.Map;
    9. import java.util.concurrent.ConcurrentHashMap;
    10. import java.util.regex.Pattern;
    12. /**
    13.  * 时间格式的各种转换
    14.  *
    15.  * <ul>
    16.  *     <li>1.1.LocalDateTime {@code ---->} LocalDate</li>
    17.  *     <li>1.2.LocalDateTime {@code ---->} Long</li>
    18.  *     <li>1.3.LocalDateTime {@code ---->} Date</li>
    19.  *     <li>1.4.LocalDateTime {@code ---->} String</li>
    20.  *     <li>2.1.LocalDate {@code ---->} LocalDateTime</li>
    21.  *     <li>2.2.LocalDate {@code ---->} Long</li>
    22.  *     <li>2.3.LocalDate {@code ---->} Date</li>
    23.  *     <li>2.4.LocalDate {@code ---->} String</li>
    24.  *     <li>3.1.Date {@code ---->} LocalDateTime</li>
    25.  *     <li>3.2.Date {@code ---->} LocalDate</li>
    26.  *     <li>3.3.Date {@code ---->} Long</li>
    27.  *     <li>3.4.Date {@code ---->} String</li>
    28.  *     <li>4.1.Timestamp {@code ---->} LocalDateTime</li>
    29.  *     <li>4.2.Timestamp {@code ---->} Long</li>
    30.  *     <li>4.3.Timestamp {@code ---->} String</li>
    31.  *     <li>4.4.Timestamp {@code ---->} LocalDate</li>
    32.  *     <li>5.1.String {@code ---->} LocalDateTime</li>
    33.  *     <li>5.2.String {@code ---->} LocalDate</li>
    34.  *     <li>5.3.String {@code ---->} Date</li>
    35.  *     <li>5.4.String {@code ---->} Timestamp</li>
    36.  *     <li>5.5.String {@code ---->} LocalTime</li>
    37.  *     <li>5.6.String {@code ---->} Time</li>
    38.  *     <li>6.1.Long {@code ---->} Date</li>
    39.  *     <li>6.2.Long {@code ---->} LocalDateTime</li>
    40.  *     <li>6.3.Long {@code ---->} LocalDate</li>
    41.  *     <li>6.4.Long {@code ---->} String</li>
    42.  * </ul>
    43.  *
    44.  * @author shizi
    45.  * @since 2020/9/9 8:58 下午
    46.  */
    47. public class LocalDateTimeUtil {
    49.     public static final String yMdHmsSSS = "yyyy-MM-dd HH:mm:ss.SSS";
    50.     public static final String yMdHmsS = "yyyy-MM-dd HH:mm:ss.S";
    51.     public static final String yMdHms = "yyyy-MM-dd HH:mm:ss";
    52.     public static final String yMdHm = "yyyy-MM-dd HH:mm";
    53.     public static final String yMdH = "yyyy-MM-dd HH";
    54.     public static final String yMd = "yyyy-MM-dd";
    55.     public static final String yM = "yyyy-MM";
    56.     public static final String y = "yyyy";
    57.     public static final String yyyyMMdd = "yyyyMMdd";
    59.     public static final String HmsSSSMore = "HH:mm:ss.SSSSSSSSS";
    60.     public static final String HmsSSS = "HH:mm:ss.SSS";
    61.     public static final String Hms = "HH:mm:ss";
    62.     public static final String Hm = "HH:mm";
    63.     public static final String H = "HH";
    65.     private static final Pattern yMdHmsSSSPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}:(\\d){2}.(\\d){3}$");
    66.     private static final Pattern yMdHmsSPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}:(\\d){2}.(\\d){1}$");
    67.     private static final Pattern yMdHmsPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}:(\\d){2}$");
    68.     private static final Pattern yMdHmPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}$");
    69.     private static final Pattern yMdHPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}$");
    70.     private static final Pattern yMdPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2}$");
    71.     private static final Pattern yMPattern = Pattern.compile("^(\\d){4}-(\\d){2}$");
    72.     private static final Pattern yPattern = Pattern.compile("^(\\d){4}$");
    74.     private static final Map<String, SimpleDateFormat> simpleDateFormat = new ConcurrentHashMap<>(7);
    75.     private static final Map<String, DateTimeFormatter> localDateTimeFormat = new ConcurrentHashMap<>(7);
    77.     static {
    78.         simpleDateFormat.put(yMdHmsSSS, new SimpleDateFormat(yMdHmsSSS));
    79.         simpleDateFormat.put(yMdHms, new SimpleDateFormat(yMdHms));
    80.         simpleDateFormat.put(yMdHm, new SimpleDateFormat(yMdHm));
    81.         simpleDateFormat.put(yMdH, new SimpleDateFormat(yMdH));
    82.         simpleDateFormat.put(yMd, new SimpleDateFormat(yMd));
    83.         simpleDateFormat.put(yM, new SimpleDateFormat(yM));
    84.         simpleDateFormat.put(y, new SimpleDateFormat(y));
    85.         simpleDateFormat.put(yyyyMMdd, new SimpleDateFormat(yyyyMMdd));
    87.         localDateTimeFormat.put(yMdHmsSSS, DateTimeFormatter.ofPattern(yMdHmsSSS));
    88.         localDateTimeFormat.put(yMdHms, DateTimeFormatter.ofPattern(yMdHms));
    89.         localDateTimeFormat.put(yMdHm, DateTimeFormatter.ofPattern(yMdHm));
    90.         localDateTimeFormat.put(yMdH, DateTimeFormatter.ofPattern(yMdH));
    91.         localDateTimeFormat.put(yMd, DateTimeFormatter.ofPattern(yMd));
    92.         localDateTimeFormat.put(yM, DateTimeFormatter.ofPattern(yM));
    93.         localDateTimeFormat.put(y, DateTimeFormatter.ofPattern(y));
    94.     }
    97.     /**
    98.      * LocalDateTime 转 LocalDate
    99.      *
    100.      * @param localDateTime 待转换时间
    101.      * @return 转换后的时间
    102.      */
    103.     private static LocalDate localDateTimeToLocalDate(LocalDateTime localDateTime) {
    104.         if (null == localDateTime) {
    105.             return null;
    106.         }
    107.         return localDateTime.toLocalDate();
    108.     }
    110.     /**
    111.      * LocalDateTime 转 Long
    112.      *
    113.      * @param localDateTime 待转换时间
    114.      * @return 转换后的时间
    115.      */
    116.     public static Long localDateTimeToLong(LocalDateTime localDateTime) {
    117.         if (null == localDateTime) {
    118.             return null;
    119.         }
    120.         return localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    121.     }
    123.     /**
    124.      * LocalDateTime 转 Date
    125.      *
    126.      * @param localDateTime 待转换时间
    127.      * @return 转换后的时间
    128.      */
    129.     public static Date localDateTimeToDate(LocalDateTime localDateTime) {
    130.         if (null == localDateTime) {
    131.             return null;
    132.         }
    133.         return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    134.     }
    136.     /**
    137.      * LocalDateTime 转 String
    138.      *
    139.      * @param localDateTime 待转换时间
    140.      * @return 转换后的时间
    141.      */
    142.     public static String localDateTimeToString(LocalDateTime localDateTime) {
    143.         if (null == localDateTime) {
    144.             return null;
    145.         }
    146.         return localDateTime.format(localDateTimeFormat.get(yMdHms));
    147.     }
    150.     /**
    151.      * LocalDateTime 转 String
    152.      *
    153.      * @param localDateTime  待转换时间
    154.      * @param dateTimeFormat 时间转换格式，建议使用{@link LocalDateTimeUtil#yMdHmsSSS}或者{@link LocalDateTimeUtil#yMdHms}等字段
    155.      * @return 转换后的时间
    156.      */
    157.     public static String localDateTimeToString(LocalDateTime localDateTime, String dateTimeFormat) {
    158.         if (null == localDateTime || null == dateTimeFormat) {
    159.             return null;
    160.         }
    161.         return localDateTime.format(localDateTimeFormat.get(dateTimeFormat));
    162.     }
    164.     /**
    165.      * LocalDateTime 转 String
    166.      *
    167.      * @param localDateTime     待转换时间
    168.      * @param dateTimeFormatter 时间转换格式器
    169.      * @return 转换后的时间
    170.      */
    171.     public static String localDateTimeToString(LocalDateTime localDateTime, DateTimeFormatter dateTimeFormatter) {
    172.         if (null == localDateTime || null == dateTimeFormatter) {
    173.             return null;
    174.         }
    175.         return localDateTime.format(dateTimeFormatter);
    176.     }
    179.     /**
    180.      * LocalDate 转 LocalDateTime
    181.      *
    182.      * @param localDate 待转换时间
    183.      * @return 转换后的时间
    184.      */
    185.     public static LocalDateTime localDateToLocalDateTime(LocalDate localDate) {
    186.         if (null == localDate) {
    187.             return null;
    188.         }
    189.         return LocalDateTime.of(localDate, LocalTime.parse("00:00:00"));
    190.     }
    192.     /**
    193.      * LocalDate 转 Long
    194.      *
    195.      * @param localDate 待转换时间
    196.      * @return 转换后的时间
    197.      */
    198.     public static Long localDateToLong(LocalDate localDate) {
    199.         if (null == localDate) {
    200.             return null;
    201.         }
    202.         return localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli();
    203.     }
    205.     /**
    206.      * LocalDate 转 Date
    207.      *
    208.      * @param localDate 待转换时间
    209.      * @return 转换后的时间
    210.      */
    211.     public static Date localDateToDate(LocalDate localDate) {
    212.         if (null == localDate) {
    213.             return null;
    214.         }
    215.         return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
    216.     }
    218.     /**
    219.      * LocalDate 转 String
    220.      *
    221.      * @param localDate 待转换时间
    222.      * @return 转换后的时间
    223.      */
    224.     public static String localDateToString(LocalDate localDate) {
    225.         if (null == localDate) {
    226.             return null;
    227.         }
    228.         return localDate.format(localDateTimeFormat.get(yMd));
    229.     }
    231.     /**
    232.      * LocalDate 转 String
    233.      *
    234.      * @param localTime 待转换时间
    235.      * @return 转换后的时间
    236.      */
    237.     public static String localTimeToString(LocalTime localTime) {
    238.         if (null == localTime) {
    239.             return null;
    240.         }
    241.         return localTime.format(localDateTimeFormat.get(HmsSSS));
    242.     }
    244.     /**
    245.      * Date 转 LocalDateTime
    246.      *
    247.      * @param date 待转换时间
    248.      * @return 转换后的时间
    249.      */
    250.     public static LocalDateTime dateToLocalDateTime(Date date) {
    251.         if (null == date) {
    252.             return null;
    253.         }
    254.         return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    255.     }
    257.     /**
    258.      * Date 转 Long
    259.      *
    260.      * @param date 待转换时间
    261.      * @return 转换后的时间
    262.      */
    263.     public static Long dateToLong(Date date) {
    264.         if (null == date) {
    265.             return null;
    266.         }
    267.         return date.getTime();
    268.     }
    270.     /**
    271.      * Date 转 LocalDate
    272.      *
    273.      * @param date 待转换时间
    274.      * @return 转换后的时间
    275.      */
    276.     public static LocalDate dateToLocalDate(Date date) {
    277.         if (null == date) {
    278.             return null;
    279.         }
    280.         return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).toLocalDate();
    281.     }
    283.     /**
    284.      * Date 转 String
    285.      *
    286.      * @param date 待转换时间
    287.      * @return 转换后的时间
    288.      */
    289.     public static String dateToString(Date date) {
    290.         if (null == date) {
    291.             return null;
    292.         }
    293.         return simpleDateFormat.get(yMdHms).format(date);
    294.     }
    296.     /**
    297.      * Date 转 String
    298.      *
    299.      * @param date             待转换时间
    300.      * @param simpleDateFormat 基本的格式转换器
    301.      * @return 转换后的时间
    302.      */
    303.     public static String dateToString(Date date, SimpleDateFormat simpleDateFormat) {
    304.         if (null == date || null == simpleDateFormat) {
    305.             return null;
    306.         }
    307.         return simpleDateFormat.format(date);
    308.     }
    310.     /**
    311.      * Date 转 String
    312.      *
    313.      * @param date                待转换时间
    314.      * @param simpleDateFormatStr 时间转换格式，建议使用{@link LocalDateTimeUtil#yMdHmsSSS}或者{@link LocalDateTimeUtil#yMdHms}等字段
    315.      * @return 转换后的时间
    316.      */
    317.     public static String dateToString(Date date, String simpleDateFormatStr) {
    318.         if (null == date || null == simpleDateFormatStr) {
    319.             return null;
    320.         }
    321.         return simpleDateFormat.get(simpleDateFormatStr).format(date);
    322.     }
    325.     /**
    326.      * Timestamp 转 LocalDateTime
    327.      *
    328.      * @param timestamp 待转换时间
    329.      * @return 转换后的时间
    330.      */
    331.     public static LocalDateTime timestampToLocalDateTime(Timestamp timestamp) {
    332.         if (null == timestamp) {
    333.             return null;
    334.         }
    335.         return timestamp.toLocalDateTime();
    336.     }
    338.     /**
    339.      * Timestamp 转 Long
    340.      *
    341.      * @param timestamp 待转换时间
    342.      * @return 转换后的时间
    343.      */
    344.     public static Long timestampToLong(Timestamp timestamp) {
    345.         if (null == timestamp) {
    346.             return null;
    347.         }
    348.         return timestamp.getTime();
    349.     }
    351.     /**
    352.      * Timestamp 转 LocalDate
    353.      *
    354.      * @param timestamp 待转换时间
    355.      * @return 转换后的时间
    356.      */
    357.     public static LocalDate timestampToLocalDate(Timestamp timestamp) {
    358.         if (null == timestamp) {
    359.             return null;
    360.         }
    361.         return LocalDateTime.ofInstant(timestamp.toInstant(), ZoneId.systemDefault()).toLocalDate();
    362.     }
    364.     /**
    365.      * Timestamp 转 String
    366.      *
    367.      * @param timestamp 待转换时间
    368.      * @return 转换后的时间
    369.      */
    370.     public static String timestampToString(Timestamp timestamp) {
    371.         if (null == timestamp) {
    372.             return null;
    373.         }
    374.         return simpleDateFormat.get(yMdHmsSSS).format(timestamp);
    375.     }
    377.     /**
    378.      * Timestamp 转 String
    379.      *
    380.      * @param timestamp        待转换时间
    381.      * @param simpleDateFormat 简单的时间转换格式
    382.      * @return 转换后的时间
    383.      */
    384.     public static String timestampToString(Timestamp timestamp, SimpleDateFormat simpleDateFormat) {
    385.         if (null == timestamp || null == simpleDateFormat) {
    386.             return null;
    387.         }
    388.         return simpleDateFormat.format(timestamp);
    389.     }
    391.     /**
    392.      * Timestamp 转 String
    393.      *
    394.      * @param timestamp           待转换时间
    395.      * @param simpleDateFormatStr 时间转换格式，建议使用{@link LocalDateTimeUtil#yMdHmsSSS}或者{@link LocalDateTimeUtil#yMdHms}等字段
    396.      * @return 转换后的时间
    397.      */
    398.     public static String timestampToString(Timestamp timestamp, String simpleDateFormatStr) {
    399.         if (null == timestamp || null == simpleDateFormatStr) {
    400.             return null;
    401.         }
    402.         return simpleDateFormat.get(simpleDateFormatStr).format(timestamp);
    403.     }
    406.     /**
    407.      * String 转 LocalDateTime
    408.      *
    409.      * @param strDateTime 待转换时间
    410.      * @return 转换后的时间
    411.      */
    412.     public static LocalDateTime stringToLocalDateTime(String strDateTime) {
    413.         if (null == strDateTime) {
    414.             return null;
    415.         }
    416.         return LocalDateTime.parse(strDateTime, DateTimeFormatter.ofPattern(getTimeFormat(strDateTime)));
    417.     }
    419.     /**
    420.      * String 转 LocalDateTime
    421.      *
    422.      * @param strDateTime 待转换时间
    423.      * @param formatStr   时间格式
    424.      * @return 转换后的时间
    425.      */
    426.     public static LocalDateTime stringToLocalDateTime(String strDateTime, String formatStr) {
    427.         if (null == strDateTime || null == formatStr) {
    428.             return null;
    429.         }
    430.         return LocalDateTime.parse(strDateTime, DateTimeFormatter.ofPattern(formatStr));
    431.     }
    433.     /**
    434.      * String 转 LocalDate
    435.      *
    436.      * @param strDateTime 待转换时间
    437.      * @return 转换后的时间
    438.      */
    439.     public static LocalDate stringToLocalDate(String strDateTime) {
    440.         if (null == strDateTime) {
    441.             return null;
    442.         }
    443.         return LocalDate.parse(strDateTime, localDateTimeFormat.get(yMd));
    444.     }
    446.     /**
    447.      * String 转 Date
    448.      *
    449.      * @param strDateTime 待转换时间
    450.      * @return 转换后的时间
    451.      */
    452.     public static Date stringToDate(String strDateTime) {
    453.         if (null == strDateTime) {
    454.             return null;
    455.         }
    456.         try {
    457.             return simpleDateFormat.get(getTimeFormat(strDateTime)).parse(strDateTime);
    458.         } catch (ParseException e) {
    459.             throw new RuntimeException(e);
    460.         }
    461.     }
    463.     /**
    464.      * String 转 Timestamp
    465.      *
    466.      * @param strDateTime 待转换时间
    467.      * @return 转换后的时间
    468.      */
    469.     public static Timestamp stringToTimestamp(String strDateTime) {
    470.         if (null == strDateTime) {
    471.             return null;
    472.         }
    473.         return Timestamp.valueOf(strDateTime);
    474.     }
    476.     /**
    477.      * String 转 LocalTime
    478.      *
    479.      * @param strDateTime    待转换时间
    480.      * @param datetimeFormat 时间格式
    481.      * @return 转换后的时间
    482.      */
    483.     public static LocalTime stringToLocalTime(String strDateTime, String datetimeFormat) {
    484.         if (null == strDateTime || null == datetimeFormat) {
    485.             return null;
    486.         }
    487.         return LocalTime.parse(strDateTime, DateTimeFormatter.ofPattern(datetimeFormat));
    488.     }
    490.     /**
    491.      * String 转 LocalTime
    492.      *
    493.      * @param strDateTime 待转换时间
    494.      * @return 转换后的时间
    495.      */
    496.     public static LocalTime stringToLocalTime(String strDateTime) {
    497.         if (null == strDateTime) {
    498.             return null;
    499.         }
    500.         return LocalTime.parse(strDateTime, DateTimeFormatter.ofPattern(HmsSSS));
    501.     }
    503.     /**
    504.      * String 转 Time
    505.      *
    506.      * @param strDateTime 待转换时间
    507.      * @return 转换后的时间
    508.      */
    509.     public static Time stringToTime(String strDateTime) {
    510.         if (null == strDateTime) {
    511.             return null;
    512.         }
    513.         return Time.valueOf(strDateTime);
    514.     }
    516.     /**
    517.      * Long 转 Date
    518.      *
    519.      * @param time 待转换时间
    520.      * @return 转换后的时间
    521.      */
    522.     public static Date longToDate(Long time) {
    523.         if (null == time) {
    524.             return null;
    525.         }
    526.         return new Date(time);
    527.     }
    529.     /**
    530.      * Long 转 LocalDateTime
    531.      *
    532.      * @param time 待转换时间
    533.      * @return 转换后的时间
    534.      */
    535.     public static LocalDateTime longToLocalDateTime(Long time) {
    536.         if (null == time) {
    537.             return null;
    538.         }
    539.         return LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault());
    540.     }
    542.     /**
    543.      * Long 转 LocalDate
    544.      *
    545.      * @param time 待转换时间
    546.      * @return 转换后的时间
    547.      */
    548.     public static LocalDate longToLocalDate(Long time) {
    549.         if (null == time) {
    550.             return null;
    551.         }
    552.         return LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault()).toLocalDate();
    553.     }
    555.     /**
    556.      * Long 转 String
    557.      *
    558.      * @param time 待转换时间
    559.      * @return 转换后的时间
    560.      */
    561.     public static String longToString(Long time) {
    562.         if (null == time) {
    563.             return null;
    564.         }
    565.         return simpleDateFormat.get(yMdHms).format(new Date(time));
    566.     }
    568.     /**
    569.      * Long 转 String
    570.      *
    571.      * @param time      待转换时间
    572.      * @param formatKey 时间转换格式，建议使用{@link LocalDateTimeUtil#yMdHmsSSS}或者{@link LocalDateTimeUtil#yMdHms}等字段
    573.      * @return 转换后的时间
    574.      */
    575.     public static String longToString(Long time, String formatKey) {
    576.         if (null == time || null == formatKey) {
    577.             return null;
    578.         }
    579.         return simpleDateFormat.get(formatKey).format(new Date(time));
    580.     }
    582.     /**
    583.      * Long 转 java.sql.Date
    584.      *
    585.      * @param time long类型的时间
    586.      * @return 日期
    587.      */
    588.     public static java.sql.Date longToSqlDate(Long time) {
    589.         if (null == time) {
    590.             return null;
    591.         }
    592.         return new java.sql.Date(time);
    593.     }
    595.     /**
    596.      * Long 转 java.sql.Time
    597.      *
    598.      * @param time long类型的时间
    599.      * @return 日期
    600.      */
    601.     public static java.sql.Time longToTime(Long time) {
    602.         if (null == time) {
    603.             return null;
    604.         }
    605.         return new java.sql.Time(time);
    606.     }
    608.     /**
    609.      * Long 转 java.sql.Timestamp
    610.      *
    611.      * @param time long类型的时间
    612.      * @return 日期
    613.      */
    614.     public static Timestamp longToTimestamp(Long time) {
    615.         if (null == time) {
    616.             return null;
    617.         }
    618.         return new java.sql.Timestamp(time);
    619.     }
    621.     public static Date setTime(Date date, Integer year, Integer month, Integer day, Integer hour, Integer minute, Integer second) {
    622.         if (null == date) {
    623.             return null;
    624.         }
    626.         Integer yearCopy = year;
    627.         if (null == year) {
    628.             yearCopy = 0;
    629.         }
    631.         Integer monthCopy = month;
    632.         if (null == month) {
    633.             monthCopy = 0;
    634.         }
    636.         Integer dayCopy = day;
    637.         if (null == day) {
    638.             dayCopy = 0;
    639.         }
    641.         Integer hourCopy = hour;
    642.         if (null == hour) {
    643.             hourCopy = 0;
    644.         }
    646.         Integer minuteCopy = minute;
    647.         if (null == minute) {
    648.             minuteCopy = 0;
    649.         }
    651.         Integer secondCopy = second;
    652.         if (null == second) {
    653.             secondCopy = 0;
    654.         }
    655.         return localDateTimeToDate(
    656.             dateToLocalDateTime(date).withYear(yearCopy).withMonth(monthCopy).withDayOfMonth(dayCopy).withHour(hourCopy).withMinute(minuteCopy).withSecond(secondCopy));
    657.     }
    659.     public static Date setYear(Date date, Integer year) {
    660.         if (null == date) {
    661.             return null;
    662.         }
    664.         Integer yearCopy = year;
    665.         if (null == year) {
    666.             yearCopy = 0;
    667.         }
    668.         return localDateTimeToDate(dateToLocalDateTime(date).withYear(yearCopy));
    669.     }
    671.     public static Date setMonth(Date date, Integer month) {
    672.         if (null == date) {
    673.             return null;
    674.         }
    675.         Integer monthCopy = month;
    676.         if (null == month) {
    677.             monthCopy = 0;
    678.         }
    679.         return localDateTimeToDate(dateToLocalDateTime(date).withMonth(monthCopy));
    680.     }
    682.     public static Date setDay(Date date, Integer day) {
    683.         if (null == date) {
    684.             return null;
    685.         }
    686.         Integer dayCopy = day;
    687.         if (null == day) {
    688.             dayCopy = 0;
    689.         }
    690.         return localDateTimeToDate(dateToLocalDateTime(date).withDayOfMonth(dayCopy));
    691.     }
    693.     public static Date setHour(Date date, Integer hour) {
    694.         if (null == date) {
    695.             return null;
    696.         }
    698.         Integer hourCopy = hour;
    699.         if (null == hour) {
    700.             hourCopy = 0;
    701.         }
    702.         return localDateTimeToDate(dateToLocalDateTime(date).withHour(hourCopy));
    703.     }
    705.     public static Date setMinute(Date date, Integer minute) {
    706.         if (null == date) {
    707.             return null;
    708.         }
    710.         Integer minuteCopy = minute;
    711.         if (null == minute) {
    712.             minuteCopy = 0;
    713.         }
    715.         return localDateTimeToDate(dateToLocalDateTime(date).withMinute(minuteCopy));
    716.     }
    718.     public static Date setSecond(Date date, Integer second) {
    719.         if (null == date) {
    720.             return null;
    721.         }
    723.         Integer secondCopy = second;
    724.         if (null == second) {
    725.             secondCopy = 0;
    726.         }
    727.         return localDateTimeToDate(dateToLocalDateTime(date).withSecond(secondCopy));
    728.     }
    730.     public static Long setTime(Long time, Integer year, Integer month, Integer day, Integer hour, Integer minute, Integer second) {
    731.         if (null == time || null == year || null == month || null == day || null == hour || null == minute || null == second) {
    732.             return null;
    733.         }
    734.         return localDateTimeToLong(longToLocalDateTime(time).withYear(year).withMonth(month).withDayOfMonth(day).withHour(hour).withMinute(minute).withSecond(second));
    735.     }
    737.     public static Long setYear(Long time, Integer year) {
    738.         if (null == time || null == year) {
    739.             return null;
    740.         }
    741.         return localDateTimeToLong(longToLocalDateTime(time).withYear(year));
    742.     }
    744.     public static Long setMonth(Long time, Integer month) {
    745.         if (null == time || null == month) {
    746.             return null;
    747.         }
    748.         return localDateTimeToLong(longToLocalDateTime(time).withMonth(month));
    749.     }
    751.     public static Long setDay(Long time, Integer day) {
    752.         if (null == time || null == day) {
    753.             return null;
    754.         }
    755.         return localDateTimeToLong(longToLocalDateTime(time).withDayOfMonth(day));
    756.     }
    758.     public static Long setHour(Long time, Integer hour) {
    759.         if (null == time || null == hour) {
    760.             return null;
    761.         }
    762.         return localDateTimeToLong(longToLocalDateTime(time).withHour(hour));
    763.     }
    765.     public static Long setMinute(Long time, Integer minute) {
    766.         if (null == time || null == minute) {
    767.             return null;
    768.         }
    769.         return localDateTimeToLong(longToLocalDateTime(time).withMinute(minute));
    770.     }
    772.     public static Long setSecond(Long time, Integer second) {
    773.         if (null == time || null == second) {
    774.             return null;
    775.         }
    776.         return localDateTimeToLong(longToLocalDateTime(time).withSecond(second));
    777.     }
    779.     public static Date plusTime(Date date, Integer years, Integer months, Integer days, Integer hours, Integer minutes, Integer seconds) {
    780.         if (null == date) {
    781.             return null;
    782.         }
    784.         Integer yearsCopy = years;
    785.         if (null == years) {
    786.             yearsCopy = 0;
    787.         }
    789.         Integer monthsCopy = months;
    790.         if (null == months) {
    791.             monthsCopy = 0;
    792.         }
    794.         Integer daysCopy = days;
    795.         if (null == days) {
    796.             daysCopy = 0;
    797.         }
    799.         Integer hoursCopy = hours;
    800.         if (null == hours) {
    801.             hoursCopy = 0;
    802.         }
    804.         Integer minutesCopy = minutes;
    805.         if (null == minutes) {
    806.             minutesCopy = 0;
    807.         }
    809.         Integer secondsCopy = seconds;
    810.         if (null == seconds) {
    811.             secondsCopy = 0;
    812.         }
    813.         return localDateTimeToDate(
    814.             dateToLocalDateTime(date).plusYears(yearsCopy).plusMonths(monthsCopy).plusDays(daysCopy).plusHours(hoursCopy).plusMinutes(minutesCopy).plusSeconds(secondsCopy));
    815.     }
    817.     public static Date plusYears(Date date, Integer years) {
    818.         if (null == date) {
    819.             return null;
    820.         }
    822.         Integer yearsCopy = years;
    823.         if (null == years) {
    824.             yearsCopy = 0;
    825.         }
    826.         return localDateTimeToDate(dateToLocalDateTime(date).plusYears(yearsCopy));
    827.     }
    829.     public static Date plusMonths(Date date, Integer months) {
    830.         if (null == date) {
    831.             return null;
    832.         }
    834.         Integer monthsCopy = months;
    835.         if (null == months) {
    836.             monthsCopy = 0;
    837.         }
    838.         return localDateTimeToDate(dateToLocalDateTime(date).plusMonths(monthsCopy));
    839.     }
    841.     public static Date plusDays(Date date, Integer days) {
    842.         if (null == date) {
    843.             return null;
    844.         }
    846.         Integer daysCopy = days;
    847.         if (null == days) {
    848.             daysCopy = 0;
    849.         }
    850.         return localDateTimeToDate(dateToLocalDateTime(date).plusDays(daysCopy));
    851.     }
    853.     public static Date plusHours(Date date, Integer hours) {
    854.         if (null == date) {
    855.             return null;
    856.         }
    858.         Integer hoursCopy = hours;
    859.         if (null == hours) {
    860.             hoursCopy = 0;
    861.         }
    862.         return localDateTimeToDate(dateToLocalDateTime(date).plusHours(hoursCopy));
    863.     }
    865.     public static Date plusMinutes(Date date, Integer minutes) {
    866.         if (null == date) {
    867.             return null;
    868.         }
    870.         Integer minutesCopy = minutes;
    871.         if (null == minutes) {
    872.             minutesCopy = 0;
    873.         }
    874.         return localDateTimeToDate(dateToLocalDateTime(date).plusMinutes(minutesCopy));
    875.     }
    877.     public static Date plusSeconds(Date date, Integer seconds) {
    878.         if (null == date) {
    879.             return null;
    880.         }
    882.         Integer secondsCopy = seconds;
    883.         if (null == seconds) {
    884.             secondsCopy = 0;
    885.         }
    886.         return localDateTimeToDate(dateToLocalDateTime(date).plusSeconds(secondsCopy));
    887.     }
    889.     public static Long plusTime(Long time, Integer years, Integer months, Integer days, Integer hours, Integer minutes, Integer seconds) {
    890.         if (null == time) {
    891.             return null;
    892.         }
    894.         Integer yearsCopy = years;
    895.         if (null == years) {
    896.             yearsCopy = 0;
    897.         }
    899.         Integer monthsCopy = months;
    900.         if (null == months) {
    901.             monthsCopy = 0;
    902.         }
    904.         Integer daysCopy = days;
    905.         if (null == days) {
    906.             daysCopy = 0;
    907.         }
    909.         Integer hoursCopy = hours;
    910.         if (null == hours) {
    911.             hoursCopy = 0;
    912.         }
    914.         Integer minutesCopy = minutes;
    915.         if (null == minutes) {
    916.             minutesCopy = 0;
    917.         }
    919.         Integer secondsCopy = seconds;
    920.         if (null == seconds) {
    921.             secondsCopy = 0;
    922.         }
    923.         return localDateTimeToLong(
    924.             longToLocalDateTime(time).plusYears(yearsCopy).plusMonths(monthsCopy).plusDays(daysCopy).plusHours(hoursCopy).plusMinutes(minutesCopy).plusSeconds(secondsCopy));
    925.     }
    927.     public static Long plusYears(Long time, Integer years) {
    928.         if (null == time) {
    929.             return null;
    930.         }
    932.         Integer yearsCopy = years;
    933.         if (null == years) {
    934.             yearsCopy = 0;
    935.         }
    936.         return localDateTimeToLong(longToLocalDateTime(time).plusYears(yearsCopy));
    937.     }
    939.     public static Long plusMonths(Long time, Integer months) {
    940.         if (null == time) {
    941.             return null;
    942.         }
    944.         Integer monthsCopy = months;
    945.         if (null == months) {
    946.             monthsCopy = 0;
    947.         }
    948.         return localDateTimeToLong(longToLocalDateTime(time).plusMonths(monthsCopy));
    949.     }
    951.     public static Long plusDays(Long time, Integer days) {
    952.         if (null == time) {
    953.             return null;
    954.         }
    956.         Integer daysCopy = days;
    957.         if (null == days) {
    958.             daysCopy = 0;
    959.         }
    960.         return localDateTimeToLong(longToLocalDateTime(time).plusDays(daysCopy));
    961.     }
    963.     public static Long plusHours(Long time, Integer hours) {
    964.         if (null == time) {
    965.             return null;
    966.         }
    968.         Integer hoursCopy = hours;
    969.         if (null == hours) {
    970.             hoursCopy = 0;
    971.         }
    972.         return localDateTimeToLong(longToLocalDateTime(time).plusHours(hoursCopy));
    973.     }
    975.     public static Long plusMinutes(Long time, Integer minutes) {
    976.         if (null == time) {
    977.             return null;
    978.         }
    980.         Integer minutesCopy = minutes;
    981.         if (null == minutes) {
    982.             minutesCopy = 0;
    983.         }
    984.         return localDateTimeToLong(longToLocalDateTime(time).plusMinutes(minutesCopy));
    985.     }
    987.     public static Long plusSeconds(Long time, Integer seconds) {
    988.         if (null == time) {
    989.             return null;
    990.         }
    992.         Integer secondsCopy = seconds;
    993.         if (null == seconds) {
    994.             secondsCopy = 0;
    995.         }
    996.         return localDateTimeToLong(longToLocalDateTime(time).plusSeconds(secondsCopy));
    997.     }
    999.     public static Date setDayStart(Date date) {
    1000.         if (null == date) {
    1001.             return null;
    1002.         }
    1003.         return localDateTimeToDate(dateToLocalDateTime(date).withHour(0).withMinute(0).withSecond(0));
    1004.     }
    1006.     public static Long setDayStart(Long time) {
    1007.         if (null == time) {
    1008.             return null;
    1009.         }
    1010.         return localDateTimeToLong(longToLocalDateTime(time).withHour(0).withMinute(0).withSecond(0).withNano(0));
    1011.     }
    1013.     public static Date setDayEnd(Date date) {
    1014.         if (null == date) {
    1015.             return null;
    1016.         }
    1017.         return localDateTimeToDate(dateToLocalDateTime(date).withHour(23).withMinute(59).withSecond(59));
    1018.     }
    1020.     public static Long setDayEnd(Long time) {
    1021.         if (null == time) {
    1022.             return null;
    1023.         }
    1024.         return localDateTimeToLong(longToLocalDateTime(time).withHour(23).withMinute(59).withSecond(59));
    1025.     }
    1027.     private static String getTimeFormat(String strDateTime) {
    1028.         if (null == strDateTime) {
    1029.             throw new RuntimeException("获取时间格式错误, time =" + strDateTime);
    1030.         }
    1031.         String data;
    1032.         data = strDateTime.trim();
    1033.         if ("".equals(data) || "null".equals(data)) {
    1034.             throw new RuntimeException("获取时间格式错误, time =" + strDateTime);
    1035.         }
    1036.         String timeFormat = yMdHms;
    1037.         if (yPattern.matcher(data).matches()) {
    1038.             timeFormat = y;
    1039.         } else if (yMPattern.matcher(data).matches()) {
    1040.             timeFormat = yM;
    1041.         } else if (yMdPattern.matcher(data).matches()) {
    1042.             timeFormat = yMd;
    1043.         } else if (yMdHPattern.matcher(data).matches()) {
    1044.             timeFormat = yMdH;
    1045.         } else if (yMdHmPattern.matcher(data).matches()) {
    1046.             timeFormat = yMdHm;
    1047.         } else if (yMdHmsPattern.matcher(data).matches()) {
    1048.             timeFormat = yMdHms;
    1049.         } else if (yMdHmsSPattern.matcher(data).matches()) {
    1050.             timeFormat = yMdHmsS;
    1051.         } else if (yMdHmsSSSPattern.matcher(data).matches()) {
    1052.             timeFormat = yMdHmsSSS;
    1053.         }
    1054.         return timeFormat;
    1055.     }
    1056. }