【JAVA】日期工具类_dateutil.endofday-CSDN博客

本文链接：https://blog.csdn.net/qq_40110781/article/details/82863303

MySQL中datetime类型23:59:59自动变为下一天的00:00:00

如：2024-08-11 23:59:59 变成了 2024-08-12 00:00:00。
解析：数据库入库的时候会有500毫秒的进位，然而程序在赋值时间给变量的时候很大概率会超过500ms，有时是999ms。

解决方案

// DateUtil Hutool官网   将生成的时间往前偏移999毫秒即可。
DateUtil.endOfDay(DateUtil.date()).offset(DateField.MILLISECOND,-999);

2021-02-10T05:49:10.942283Z 的格式转换字符串转date

 DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
 Date timeDate =  format.parse(monitorDataVo.getTime());   //monitorDataVo.getTime()字符串

public class DateUtil {

private static final Logger log = LogManager.getLogger();

/**
 * 秒
 */
public static final long SECOND_MILLI = 1000;

/**
 * 分
 */
public static final long MINUTE_MILLI = 60 * 1000;

/**
 * 时
 */
public static final long HOUR_MILLI = 60 * 60 * 1000;

/**
 * 天
 */
public static final long DAY_MILLI = 24 * 60 * 60 * 1000;

/**
 * 东八区
 */
private static final String ZONE_8 = "+8";

/**
 * 获取当前时间
 * @return  当前时间
 */
public static LocalDateTime localDateTime(){
    return LocalDateTime.now();
}

/**
 * 当前时间 date 类型
 * @return date类型
 */
public static Date date(){
    return new Date();
}

public static Date localDateTime2Date(LocalDateTime localDateTime){
    return Date.from(localDateTime
            .atZone(ZoneId.systemDefault())
            .toInstant());
}

public static LocalDateTime date2LocalDateTime(Date date){
    return date.toInstant()
            .atZone(ZoneId.systemDefault())
            .toLocalDateTime();
}


/**
 * 获取当前时间戳
 * @return  时间戳
 */
public static long timeStamp(){
    return Instant.now().getEpochSecond();
}


/**
 * 获取相应时间的时间戳
 * @param localDateTime 时间
 * @return  毫秒级时间戳
 */
public static long timeStamp(LocalDateTime localDateTime){
    return localDateTime.toInstant(ZoneOffset.of(ZONE_8)).toEpochMilli();
}

/**
 * 将String转化成date
 *
 * @throws ParseException
 * */
public static Date stringToDate(String str, String sfgs)
        throws ParseException {
    SimpleDateFormat sf = new SimpleDateFormat(sfgs);
    return sf.parse(str);
}


/**
 * datetime -> String
 * @return
 */
public static String getDateTimeStr(Date date){
    String dateStr = "";
    if(date != null){
        Format format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateStr = format.format(date);
    }
    return dateStr;
}

/**
 * 取得两个日期的间隔天数
 * @param one
 * @param two
 * @return
 */
public static int getDiffDays(Date one, Date two) {
    long from = one.getTime();
    long to = two.getTime();

    //一天等于多少毫秒：24*3600*1000

    int day = (int)((to-from)/(24*60*60*1000));
    return day;
}


/**
 * 取得新的日期
 *
 * @param date1
 *            日期
 * @param days
 *            天数
 *
 * @return 新的日期
 */
public static Date addDays(Date date1, long days) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date1);
    cal.add(Calendar.DATE, (int) days);
    return cal.getTime();
}

/**
 * 比较时间大小
 * @param date1
 * @param date2
 * @return
 */
public static boolean compareDate(Date date1, Date date2){
    if (date1.getTime() > date2.getTime()) {
        return true;
    }
    return false;
}

/**
*获取选择时间前几天时间
*  @param days
*/
public static Date getDaysBefore(int days, Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.add(Calendar.DATE, days);
    return calendar.getTime();
}



public static void main(String[] args) {
    System.out.println(monthBeforeStringDate("2018-08-01",-2));
   // System.out.println(getDiffDays(getDaysBefore(-1,new Date()),new Date()));
}

/**
 * 字符串转换成日期
 * @param str
 * @return date
 */
public static Date strToDate(String str) {
    if(StringUtils.isEmpty(str)){
        return null;
    }
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = null;
    try {
        date = format.parse(str);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return date;
}

/**
 * 获取前三个月日期
 * @return
 */
public static String monthBeforeDate(int month) {
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.MONTH, month);    //得到前3个月
    System.out.print(format.format(calendar.getTime()));
    return format.format(calendar.getTime());
}

/**
 * 根据指定日期往前获取前几个月
 * @param month
 * @return
 */
public static String monthBeforeStringDate(String date,int month) {
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    Date dateNew = null;
    try {
        dateNew = format.parse(date);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(dateNew);
    calendar.add(Calendar.MONTH, month);    //得到前3个月
    System.out.print(format.format(calendar.getTime()));
    return format.format(calendar.getTime());
}



public static String replaceDateRule(String source){
    return source.replace("-","").substring(0,6);

}



 // 获取指定年月的第一天
public static String getFirstDayOfMonth1(int year, int month) {
    Calendar calendar = Calendar.getInstance();
    //设置年份
    calendar.set(Calendar.YEAR, year);
    //设置月份
    calendar.set(Calendar.MONTH, month-1);
    //获取某月最小天数
    int firstDay = calendar.getMinimum(Calendar.DATE);
    //设置日历中月份的最小天数
    calendar.set(Calendar.DAY_OF_MONTH,firstDay);
    //格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    return sdf.format(calendar.getTime());
}

/**
 * 获取指定年月的最后一天
 * @param year 年
 * @param month 月
 * @return
 */
public static String getLastDayOfMonth1(int year, int month) {
    Calendar calendar = Calendar.getInstance();
    //设置年份
    calendar.set(Calendar.YEAR, year);
    //设置月份
    calendar.set(Calendar.MONTH, month-1);
    //获取某月最大天数
    int lastDay = calendar.getActualMaximum(Calendar.DATE);
    //设置日历中月份的最大天数
    calendar.set(Calendar.DAY_OF_MONTH, lastDay);
    //格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    return sdf.format(calendar.getTime());
}

//返回两个日期相差的小时数
public static long dateDiff(String startTime, String endTime, String format) throws Exception {
    //按照传入的格式生成一个simpledateformate对象
    SimpleDateFormat sd = new SimpleDateFormat(format);
    //一天的毫秒数
    long nd = 1000*24*60*60;
    //一小时的毫秒数
    long nh = 1000*60*60;
    //一分钟的毫秒数
    long nm = 1000*60;
    //一秒钟的毫秒数
    long ns = 1000;
    long diff;
    //获得两个时间的毫秒时间差异
    diff = sd.parse(endTime).getTime() - sd.parse(startTime).getTime();
    //计算差多少天
    long day = diff/nd;
    //计算差多少小时
    long hour = diff%nd/nh;
    //计算差多少分钟
    long min = diff%nd%nh/nm;
    //计算差多少秒//输出结果
    long sec = diff%nd%nh%nm/ns;
    //System.out.println("时间相差："+day+"天"+hour+"小时"+min+"分钟"+sec+"秒。");
    long sumHour = day * 24 + hour;
    return sumHour ;
}

/**
 *获取选择时间前几天时间
 * 【正数+1天，负数-1天】
 *  @param days
 */
public static Date getDaysBefore(int days, Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.add(Calendar.DATE, days);
    return calendar.getTime();
}

/**
 *获取选择时间后加月份
 * 【正数+1月，负数-1月】
 *  @param mouth
 */
public static Date getMouthAfter(int mouth, Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.add(Calendar.MONTH, mouth);
    return calendar.getTime();
}

常用工具类2

1.计算给定时间至今的天数：long date2day(String date)

2.得到当前年:int getYear()    

3.得到当前月:  int getMonth() 
    
4.得到当前日:int getDay()

5.返回当前月(01~12):String getMonth2()   

6.返回当前日(01~31): String getDay2()

7.返回指定格式的当前时间: 
 String getDate(String format)[YYYY-MM-DD,YY-MM,YY年MM月,YY/YYYY]
 
8.计算某天是星期几: whatDayIsSpecifyDate(String)

9.计算两日期间相差天数:
 signDaysBetweenTowDate(String nowDate, String beforeDate)
 
10.获得当前时间（年月日 时分秒）：getCurrentDateTime

11.根据日期获取星座: 
String date2Constellation(String strDate)       YYYY-MM-DD 

12.根据日期获取生肖 ：
 String date2Zodica(String strDate)             YYYY-MM-DD
 
13.根据日期获取年龄: 
int getAge(String strbirthDay)                  YYYY-MM-DD

Java 时间转换常用方法【localdate、localdatetime、date】

1.获得某天最大时间 2017-10-15 23:59:59
2. 获得某天最小时间 2017-10-15 00:00:00
3. 时间戳转Date
4. Date转时间戳
5. 格式化Date
6. 给日期加上指定时长
7. 得到指定时间节点的日期时间
8. 判断两个时间点是否为同一天、同一年
9. Java 8 日期时间 API

  // 1获得某天最大时间 2017-10-15 23:59:59
public static Date getEndOfDay(Date date) {
	LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(date.getTime()),       ZoneId.systemDefault());;
	LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX);
	return Date.from(endOfDay.atZone(ZoneId.systemDefault()).toInstant());
}
// 2获得某天最小时间 2017-10-15 00:00:00
public static Date getStartOfDay(Date date) {
	LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(date.getTime()), ZoneId.systemDefault());
	LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN);
	return Date.from(startOfDay.atZone(ZoneId.systemDefault()).toInstant());
} 

**测试代码**
  public static void main(String[] args) {
	Date date = new Date();
	System.out.println("今天开始时间：" + getStartOfDay(date));
	System.out.println("今天结束时间：" + getEndOfDay(date));
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	System.out.println(sdf.format(getStartOfDay(date)));
	System.out.println(sdf.format(getEndOfDay(date)));
}
*运行结果*
结果输出如下：

在这里插入图片描述

声明式时间格式化

private static String Date_Format_Patten = “yyyy-MM-dd HH:mm:ss”;
DateUtil.stringToDate(interviewTime,Date_Format_Patten)；

时间戳转Date

注：以下的方法中很多常量和方法我都没有提取出来，正式项目中还是建议大家封装在时间处理类中，规范化操作

public static void main(String[] args) {
    // 10位的秒级别的时间戳
    long time1 = 1527767665;
    String result1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time1 * 1000));
    System.out.println("10位数的时间戳（秒）--->Date:" + result1);
    Date date1 = new Date(time1*1000);   //对应的就是时间戳对应的Date
    // 13位的秒级别的时间戳
    double time2 = 1515730332000d;
    String result2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time2);
    System.out.println("13位数的时间戳（毫秒）--->Date:" + result2);
}

执行结果

10位数的时间戳（秒）--->Date:2018-05-31 19:54:25
13位数的时间戳（毫秒）--->Date:2018-01-12 12:12:12

尤其要注意上面10位的秒级别的时间戳时，不能用int来定义time1变量，否则会得到错误的结果：

public static void main(String[] args) {
    // 10位的秒级别的时间戳   
    int time1 = 1527767665;   //错误做法
    String result1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time1 * 1000));
    System.out.println("10位数的时间戳（秒）--->Date:" + result1);
}

执行出的错误结果

10位数的时间戳（秒）--->Date:1969-12-17 23:21:47

4、Date转时间戳

public static void main(String[] args) {
    //获取指定时间的时间戳，除以1000说明得到的是秒级别的时间戳（10位）
    long time = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).parse("2018-06-30 20:00:00", new ParsePosition(0)).getTime() / 1000;
 
    //获取时间戳
    long now1 = System.currentTimeMillis();
    long now2 = new Date().getTime();
 
    System.out.println("获取指定时间的时间戳:" + time);
    System.out.println("当前时间戳:" +now1);
    System.out.println("当前时间戳:" +now2);
}

执行结果

获取指定时间的时间戳:1530360000
当前时间戳:1527769494340
当前时间戳:1527769494340

5、格式化Date

public static void main(String[] args) {
    //使用common-lang包下面的DateFormatUtils类
    String format1 = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
    //使用最原始的SimpleDateFormat类
    String format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
 
    System.out.println("格式化时间1:" + format1);
    System.out.println("格式化时间2:" + format2);
}

执行结果

格式化时间1:2018-05-31 20:26:49
格式化时间2:2018-05-31 20:26:49

DateFormatUtils是commons.lang3.time.DateFormatUtils下的，如果你的项目中没有，maven中引入下：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-lang3</artifactId>
   <version>3.6</version>
</dependency>

6、给日期加上指定时长
比如，给现在的时间加上12个小时，这个需求也很常见，例如我做过的某个秒杀接口要返回剩余秒杀时间给前端，那么我就直接计算（比如秒杀持续时间为12小时）：秒杀(倒计时)截止时间=（当前时间+12H）即可。

public static void main(String[] args) {
    //将指定日期加上固定时间，DateUtils还有其它添加分钟、小时、月份之类的方法api
    //使用到的是commons-lang包下面的DateUitls类
    Date date = DateUtils.addDays(new Date(), 10);   //
    System.out.println("当前时间为:"+DateFormatUtils.format(new Date(),"yyyy-MM-dd HH:mm:ss"));
    String format = DateFormatUtils.format(date, "yyyy-MM-dd HH:mm:ss");
    System.out.println("当前时间加上10天后:" + format);
}

执行结果

当前时间为:2018-05-31 20:31:53
当前时间加上10天后:2018-06-10 20:31:53

DateUtils也是commons.lang3.time包下的，别忘了加maven依赖。
7、得到指定时间节点的日期时间

public static void main(String[] args) throws ParseException {
        //得到指定日期
        String date = "2018-03-03 15:20:12";
        Date parse = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(date);
        System.out.println(parse);
    }

8、判断两个时间点是否为同一天、同一年
给定两个日期，快速判断两者是否为同一天或者同一年，比如我做过的一个接口需求是：每人每天有一次抽奖机会，那么当用户当天第二次发送请求时候，我就得判断查询参与记录，并且判断最新一次参与时间和当天是否为同一天。

/**
     * 判断是否为同一天：使用commons-lang包下的DateUtils类
     *
     * @param day1
     * @param day2
     * @return
     */
    public boolean isSameDay(Date day1, Date day2) {
        return DateUtils.isSameDay(day1, day2);
    }
 
    /**
     * 判断是否为同一天：使用joda依赖包里的时间类，效率从一定程度上优于DateUtils.isSameDay()方法
     *
     * @param date1
     * @param date2
     * @return
     */
    public static boolean isSameDay1(Date date1,Date date2){
        if(date1==null || date2==null){
            throw new IllegalArgumentException("date must be not null");
        }
        LocalDate localDate1 = new LocalDate(new DateTime(date1.getTime()));
        LocalDate localDate2 = new LocalDate(new DateTime(date2.getTime()));
        return localDate1.equals(localDate2);
    }

9、Java 8 日期时间 API
Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：
Local(本地) − 简化了日期时间的处理，没有时区的问题。
Zoned(时区) − 通过制定的时区处理日期时间。
本地化日期时间 API
LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况。代码如下：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
 
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8tester = new Java8Tester();
      java8tester.testLocalDateTime();
   }
    
   public void testLocalDateTime(){
    
      // 获取当前的日期时间
      LocalDateTime currentTime = LocalDateTime.now();
      System.out.println("当前时间: " + currentTime);
        
      LocalDate date1 = currentTime.toLocalDate();
      System.out.println("date1: " + date1);
        
      Month month = currentTime.getMonth();
      int day = currentTime.getDayOfMonth();
      int seconds = currentTime.getSecond();
        
      System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
        
      LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
      System.out.println("date2: " + date2);
        
      // 12 december 2014
      LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
      System.out.println("date3: " + date3);
        
      // 22 小时 15 分钟
      LocalTime date4 = LocalTime.of(22, 15);
      System.out.println("date4: " + date4);
        
      // 解析字符串
      LocalTime date5 = LocalTime.parse("20:15:30");
      System.out.println("date5: " + date5);
       //获取当前年
      Calendar calendar = Calendar.getInstance();
      int yearNow = calendar.get(Calendar.YEAR); 
      System.out.println("date6: " + yearNow );
   }
}

执行以上脚本，输出结果为：

$ javac Java8Tester.java 
$ java Java8Tester
当前时间: 2016-04-15T16:55:48.668
date1: 2016-04-15
月: APRIL, 日: 15, 秒: 48
date2: 2012-04-10T16:55:48.668
date3: 2014-12-12
date4: 22:15
date5: 20:15:30
date6：2018

使用时区的日期时间API
如果我们需要考虑到时区，就可以使用时区的日期时间API：

import java.time.ZonedDateTime;
import java.time.ZoneId;
 
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
    
   public void testZonedDateTime(){
    
      // 获取当前时间日期
      ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
      System.out.println("date1: " + date1);
        
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);
        
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("当期时区: " + currentZone);
   }
}

执行以上脚本，输出结果为：

$ javac Java8Tester.java 
$ java Java8Tester
date1: 2015-12-03T10:15:30+08:00[Asia/Shanghai]
ZoneId: Europe/Paris
当期时区: Asia/Shanghai

LocalDateTime、LocalDate、Date的相互转换
LocalDateTime 转 LocalDate ——直接调用 toLocalDate() 方法

LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = localDateTime.toLocalDate();

LocalDateTime 转 Date

在LocalDateTime 转 Date 时，需要使用到 Java 8的几个类
ZoneId/ZoneOffset：表示时区
ZonedDateTime： 表示特定时区的日期和时间
Instant：表示时刻，不直接对应年月日信息，需要通过时区转换

LocalDateTime localDateTime = LocalDateTime.now();
//获取系统默认时区
ZoneId zoneId = ZoneId.systemDefault();
//时区的日期和时间
ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
//获取时刻
Date date = Date.from(zonedDateTime.toInstant());
System.out.println("格式化前：localDateTime:" + localDateTime + "  Date:" + date);
//格式化LocalDateTime、Date
DateTimeFormatter localDateTimeFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("格式化后：localDateTime:" + localDateTimeFormat.format(localDateTime) + "  Date:" + dateFormat.format(date));

输出结果如下：

格式化前：localDateTime:2020-10-27T11:35:09.969  Date:Tue Oct 27 11:35:09 CST 2020
格式化后：localDateTime:2020-10-27 11:35:09  Date:2020-10-27 11:35:09

LocalDate 转 LocalDateTime ——一般调用 atTime() 方法进行赋值

LocalDate localDate = LocalDate.now();
LocalDateTime localDateTime1 = localDate.atStartOfDay();
LocalDateTime localDateTime2 = localDate.atTime(8,20,33);
LocalDateTime localDateTime3 = localDate.atTime(LocalTime.now());

LocalDate 转 Date ——先调用 atStartOfDay() 方法转 LocalDateTime 再转 Date

LocalDate localDate = LocalDate.now();
ZoneId zoneId = ZoneId.systemDefault();
Date date = Date.from(localDate.atStartOfDay().atZone(zoneId).toInstant());

Date 转 LocalDateTime ——先转 ZonedDateTime 再转 LocalDateTime

Date date = new Date();
ZoneId zoneId = ZoneId.systemDefault();
LocalDateTime localDateTime = date.toInstant().atZone(zoneId).toLocalDateTime();

Date 转 LocalDate——跟 LocalDate 同理

Date date = new Date();
ZoneId zoneId = ZoneId.systemDefault();
LocalDate localDate = date.toInstant().atZone(zoneId).toLocalDate();

Java8 localdatetime 常用范例

		LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("当前时间：" + localDateTime);//2020-12-08T11:19:04.305
 
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 06, 02, 12, 22, 23);
        System.out.println("指定时间：" + localDateTime1);//2020-06-02T12:22:23
 
        //手动指定时间 当天0点 方法一（缺点：毫秒未归0）
        LocalDateTime localDateTime11 = LocalDateTime.now().withHour(0).withMinute(0).withSecond(0);
        System.out.println("手动指定日期时间当天0点：" + localDateTime11);//2020-12-08T00:00:00.306
       //手动指定时间 当天0点 方法二
        LocalDateTime today_start = LocalDateTime.of(LocalDate.now(),LocalTime.MIN);
        System.out.println("手动指定日期时间当天0点：" + today_start );//2020-12-08T00:00
        //指定当前周一
        LocalDateTime monday= LocalDateTime.now().with(DayOfWeek.MONDAY);
        LocalDateTime localDateTime2 = LocalDateTime.now().plusMonths(2);
        System.out.println("当前时间添加2月：" + localDateTime2);//2021-02-08T11:19:04.306
        LocalDateTime localDateTime3 = LocalDateTime.now().minusDays(2);
        System.out.println("当前时间减少2天：" + localDateTime3);//2020-12-06T11:19:04.306
        // 获取秒数
        Long second = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        System.out.println("获取秒数" + second);//1607397544
        // 获取毫秒数方法1
        Long milliSecond = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        System.out.println("获取毫秒数1:" + milliSecond);//1607397544306
        // 或者
        ZoneOffset zoneOffset = endTime.atZone(ZoneOffset.systemDefault()).getOffset();
        Long milliSecond1 = LocalDateTime.now().toInstant(zoneOffset).toEpochMilli();
        System.out.println("获取毫秒数1:" + milliSecond1);//1607397544306
 
        //获取毫秒数方法2
        long milliSecond2 = Instant.now().toEpochMilli();
        System.out.println("获取毫秒数2:" + milliSecond2);//1607397544307
        //long转LocalDateTime
        LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(milliSecond2), ZoneOffset.of("+8"));//2021-01-05T23:59:59.999
		LocalDateTime localDateTime21 = LocalDateTime.now().withDayOfMonth(10);
        System.out.println("手动指定日期时间：" + localDateTime21);//2020-12-10T11:19:04.307
        LocalDateTime with = LocalDateTime.now().with(TemporalAdjusters.firstDayOfMonth());
        System.out.println("使用TemporalAdjuster获取当月第一天：" + with);//2020-12-01T11:19:04.307
        System.out.println("获取下一年的第一天:" + localDateTime.with(TemporalAdjusters.firstDayOfNextYear()));//2021-01-01T11:19:04.305
        System.out.println("获取年中最后一天" + localDateTime.with(TemporalAdjusters.lastDayOfYear()));//2020-12-31T11:19:04.305
 
        System.out.println("获取月中第一天" +localDateTime.with(TemporalAdjusters.firstDayOfMonth()));
        System.out.println("获取月中最后一天" + localDateTime.with(TemporalAdjusters.lastDayOfMonth()));//2020-12-31T11:19:04.305
        System.out.println("获取下个星期一" + localDateTime.with(TemporalAdjusters.next(DayOfWeek.MONDAY)));//2020-12-14T11:19:04.305
        // 也可自定义格式
        DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 两种写法效果一样
        System.out.println("自定义格式化日期一："+formatter1.format(LocalDateTime.now()));//2020-12-08 11:19:04
        System.out.println("自定义格式化日期二："+LocalDateTime.now().format(formatter1));//2020-12-08 11:19:04
        // 字符串转换时间
        LocalDateTime parse = LocalDateTime.parse("2020-12-08 11:18:00", formatter1);
        System.out.println("字符串转日期："+parse);//2020-12-08T11:18