【Java日期类Date、LocalDate、LocalTime、 LocalDateTime及转换】

日期类 Date

世界标准时间 （GMT=UTC）

GMT：格林威治标准时间 1900-01-01 00:00:00

从19 世纪中叶起，世界上以英国皇家格林尼治天文台公布的时间为标准时间，即“格林尼治标准时间（Greenwich Mean Time）”，简称GMT

UTC : 世界协调时间 1970-01-01 00:00:00

世界标准时间（Coordinated Universal Time），又称世界统一时间、国际协调时间、协调世界时，简称UTC，由原子钟提供，非常精确。

UTC与GMT的区别

这两者几乎是同一概念。它们都是指的格林尼治标准时间，只不过UTC的称呼更为正式一点。两者的区别在于前者是一个天文上的概念，而后者是基于一个原子钟。在UTC中，每一年或两年会有一个“闰秒”，而我们一般不理 会这个“闰秒”，但是在Java中，这造成我们有时会出现60秒或61秒。

北京时间GMT与UTC存在秒差。通常所说的北京时间，表示为UTC+8，即北京时间比世界标准时间快8小时，也即时差为8小时。

获取日期对象及获取时间毫秒数的两种方法：

方式一：使用系统类System.currentTimeMillis()获取毫秒数
输出的毫秒数是从1970-01-01 00:00:00到程序运行的时候的时间毫秒数

public class DateTest {
    @Test
    public void test01(){
        // 标准时间 UTC GMT
        // 1900-01-01 00:00:00
        // 1970-01-01 00:00:00
        Date date = new Date();
        // Thu Apr 14 20:46:15 CST 2022 
        System.out.println(date);
        long millis = System.currentTimeMillis();
        // 1649940375497 1970-01-01 00:00:00到程序运行的时候的时间毫秒数
        System.out.println(millis);
    }
 }

输出时间毫秒数

Thu Apr 14 20:46:15 CST 2022
1649940375497

方式二：使用date.getTime() 返回long数据类型
输出的毫秒数是从1970-01-01 00:00:00到程序运行的时候的时间毫秒数

public class DateTest {
    @Test
    public void test01(){
        // 标准时间 UTC GMT
        // 1900-01-01 00:00:00
        // 1970-01-01 00:00:00
        Date date = new Date();
        // Thu Apr 14 20:46:15 CST 2022 
        System.out.println(date);
        long time = date.getTime();
        // 1649940375467 1970-01-01 00:00:00到程序运行的时候的时间毫秒数
        System.out.println(time);
    }
 }

输出时间毫秒数

Thu Apr 14 20:46:15 CST 2022
1649940375467

Date对象获取所有日期数据

Date对象获取当前日期

Date 对象常用API
Date date = new Date();

方法	描述
date.getYear()	获取当前年份，从1900年开始的在输出年份时date.getYear() + 1900
date.getMonth()	获取当前月份(0-11,0代表1月) 所以获取当前月份是 date.getMonth()+1
date.getDate()	获取当前日(1-31)
date.getDay()	获取当前星期X(0-6,0代表星期天)
date.getTime()	获取当前时间(从1970.1.1开始的毫秒数)
date.getHours()	获取当前小时数(0-23)
date.getMinutes()	获取当前分钟数(0-59)
date.getSeconds()	获取当前秒数(0-59)
date.toLocaleString()	获取当前日期( 年 月 日 下午 : : )

年份是从1900年开始的在输出年份时date.getYear() + 1900

月份date.getMonth()返回的是从0到11（0是一月份）所以月份date.getMonth()+1

日期使用date.getDate();

使用date.getDay()获取星期 ，0到6表示星期日到星期六

public class DateTest {
 @Test
    public void test02(){
        // 日期字符串
        StringBuilder dateText = new StringBuilder();
        // 获取日期对象
        Date date = new Date();
        // 年 月 日 时 分 秒 星期
        int year = date.getYear() + 1900;
        dateText.append(year + "年");
        int month = date.getMonth() + 1;
        dateText.append(month < 10 ? "0" + month + "月" : month + "月");
        int dayOfMonth = date.getDate();
        dateText.append(dayOfMonth < 10 ? "0" + month + "日" : dayOfMonth + "日");
        int hours = date.getHours();
        dateText.append(hours < 10 ? "0" + hours + "时" : " " + hours + "时");
        int minutes = date.getMinutes();
        dateText.append(minutes < 10 ? "0" + minutes + "分" : minutes + "分");
        int seconds = date.getSeconds();
        dateText.append(seconds < 10 ? "0" + seconds + "秒" : seconds + "秒");
        int dayOfWeek = date.getDay();
        String weekDay = " 星期";
        switch (dayOfWeek){
            case 1 ->weekDay += "一";
            case 2 ->weekDay += "二";
            case 3 ->weekDay += "三";
            case 4 ->weekDay += "四";
            case 5 ->weekDay += "五";
            case 6 ->weekDay += "六";
            default -> weekDay += "日";
        }
        dateText.append(weekDay);
        System.out.println(dateText.toString());
    }
}

输出当天的日期时间

2022年04月14日 22时27分48秒 星期四

时间补零占位方法抽取获取时间日期

public abstract class BaseDateUtil {
    /**
     * 时间补零占位
     * @param time 时间
     * @return     补零后的字符串
     */
    public static String zeroCompensation(int time){
        if (time < 10 ){
            return "0" + time;
        }
        return String.valueOf(time);
    }
}

public class DateTest {
@Test
    public void test002(){
        // 日期字符串
        StringBuilder dateText = new StringBuilder();
        // 获取日期对象
        Date date = new Date();
        // 年 月 日 时 分 秒 星期
        int year = date.getYear() + 1900;
        dateText.append(year + "年");
        int month = date.getMonth() + 1;
        dateText.append(BaseDateUtil.zeroCompensation(month) + "月");
        int dayOfMonth = date.getDate();
        dateText.append(BaseDateUtil.zeroCompensation(dayOfMonth) + "日 ");
        int hours = date.getHours();
        dateText.append(BaseDateUtil.zeroCompensation(hours) + "时");
        int minutes = date.getMinutes();
        dateText.append(BaseDateUtil.zeroCompensation(minutes) + "分");
        int seconds = date.getSeconds();
        dateText.append(BaseDateUtil.zeroCompensation(seconds) + "秒 ");

        int dayOfWeek = date.getDay();
        String weekDay = " 星期";
        switch (dayOfWeek){
            case 1 ->weekDay += "一";
            case 2 ->weekDay += "二";
            case 3 ->weekDay += "三";
            case 4 ->weekDay += "四";
            case 5 ->weekDay += "五";
            case 6 ->weekDay += "六";
            default -> weekDay += "日";
        }
        dateText.append(weekDay);
        System.out.println(dateText);
    }

输出

2022年04月15日 10时15分02秒  星期五

SimpleDateFormat实现日期格式化与时间字符串解析

SimpleDateFormat里的构造方法中需要传一个年月日时分秒模板

时间字符串模板中字母的定义：

日期格式化字符串

public class DateTest {
@Test
    public void test03() {
        Date date = new Date();
        System.out.println(date);
        // 实例化一个时间字符串格式对象 并传入时间字符串模板
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 将日期对象根据之前的时间字符串模板格式化为时间字符串
        String format = dateFormat.format(date);
        System.out.println(format);
    }
} 

输出

Fri Apr 15 10:28:00 CST 2022
2022-04-15 10:28:00

时区设置

public class DateTest {
@Test
    public void test03() {
        Date date = new Date();
        System.out.println(date);
        // 实例化一个时间字符串格式对象 并传入时间字符串模板
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        // 将日期对象根据之前的时间字符串模板格式化为时间字符串
        String format = dateFormat.format(date);
        System.out.println(format);
    }
}

输出

Fri Apr 15 10:28:39 CST 2022
2022-04-15 10:28:39

字符串转换为时间
注意：字符串模板必须与字符串格式一致

public class DateTest {
@Test
    public void test03() {
        Date date = new Date();
        System.out.println(date);
        // 实例化一个时间字符串格式对象 并传入时间字符串模板
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        // 将日期对象根据之前的时间字符串模板格式化为时间字符串
        String format = dateFormat.format(date);
        System.out.println(format);

        String source = "1983-11-22 20:30:00";
        try {
        	// 根据时间字符串模板将时间字符串解析为日期对象
            Date parse = dateFormat.parse(source);
            System.out.println(parse);
        }catch (ParseException e){
            throw new RuntimeException(e);
        }
    }
}

输出

Thu Apr 14 23:15:08 CST 2022
2022-04-14 23:15:08
Tue Nov 22 20:30:00 CST 1983

日期比较与标准时间转换

日期比较

时间比较方式一：

public class DateTest {
@Test
    public void test04() {
        // 实例化一个时间字符串格式对象 并传入时间字符串模板
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       
        String text01 = "1983-11-22 20:30:00";
        String text02 = "1988-08-11 20:30:00";
        try {
            Date date01 = dateFormat.parse(text01);
            Date date02 = dateFormat.parse(text02);
            boolean isBefore = date01.getTime() - date02.getTime() < 0 ? true : false;
            boolean isAfter = date01.getTime() - date02.getTime() > 0 ? true : false;
            System.out.println(isBefore);
            System.out.println(isAfter);
        }catch (ParseException e){
            throw new RuntimeException(e);
        }
    }
}

输出

true
false

使用系统自带方法时间比较方式二：

public class DateTest {
@Test
    public void test05() {
        // 实例化一个时间字符串格式对象 并传入时间字符串模板
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String text01 = "1983-11-22 20:30:00";
        String text02 = "1988-08-11 20:30:00";
        try {
            Date date01 = dateFormat.parse(text01);
            Date date02 = dateFormat.parse(text02);

            System.out.println(date01.before(date02));
            System.out.println(date01.after(date02));
        }catch (ParseException e){
            throw new RuntimeException(e);
        }
    }
}

输出

true
false

标准时间转换

public class DateTest {
@Test
    public void test06() {
        Date date = new Date();
        System.out.println(date);
        String gmtString = date.toGMTString();
        String localeString = date.toLocaleString();
        System.out.println(gmtString);
        System.out.println(localeString);
    }
}

输出

Fri Apr 15 10:40:37 CST 2022
15 Apr 2022 02:40:37 GMT
2022年4月15日 上午10:40:37

时区转换与构造方法将时间毫秒数转为日期对象

时区转换

public class DateTest {
 @Test
    public void test07() {
        // 输出当前系统默认时区
        // 1000  一秒钟
        // 1000 * 60  一分钟
        // 1000 * 60 * 60  一个小时
        // 1000 * 60 * 60 * 8 
        // sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null]
        System.out.println(TimeZone.getDefault());
        // 定义时间字符串格式化模板
        SimpleDateFormat tokyoSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 格式化的时候设置时区
        tokyoSdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));
        // 获取当前时间对象
        Date tokyoDate = new Date();
        // 将当前时间对象使用定义好的时间字符串模板格式化
        String tokyoDateText = tokyoSdf.format(tokyoDate);
        System.out.println(tokyoDateText);

        SimpleDateFormat NewYorkSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        NewYorkSdf.setTimeZone(TimeZone.getTimeZone("American/New Your"));
        Date NewYorkDate = new Date();
        String newYorkDateText = NewYorkSdf.format(NewYorkDate);
        System.out.println(newYorkDateText);
    }
 }

输出

sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null]
2022-04-15 11:46:40
2022-04-15 02:46:40

时间毫秒数转为日期对象

Date()传入时间

public class DateTest {
 @Test
    public void test08() {
        long time = System.currentTimeMillis();
        time -= 1000 * 60 * 60;
        Date date = new Date(time);
        System.out.println(date);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        String format = dateFormat.format(date);
        System.out.println(format);
    }
}

输出

Fri Apr 15 10:26:23 CST 2022
2022-04-15 10:26:23

日期工具类封装

日期对象格式化字符串

public abstract class BaseDateUtil {
    /**
     * 默认时区
     */
    private final static String timeZone = "Asia/Shanghai";
    /**
     * 默认时间字符串模板
     */
    private final static String pattern = "yyyy-MM-dd HH:mm:ss";
    /**
     * 将日期对象格式化为字符串
     * @param date      Date对象
     * @return          Date对象格式化后的日期字符串
     */
    public static String format(Date date){
        return format(date,timeZone,pattern);
    }
    /**
     * 将日期对象格式化为字符串
     * @param date      Date对象
     * @param pattern   日期格式化字符串模板
     * @return          Date对象格式化后的日期字符串
     */
    public static String format(Date date, String pattern){
        return format(date,timeZone,pattern);
    }
    /**
     * 将日期对象格式化为字符串
     * @param date      Date对象
     * @param timeZone  时区
     * @param pattern   日期格式化字符串模板
     * @return          Date对象格式化后的日期字符串
     */
    public static String format(Date date, String timeZone, String pattern){
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
        return dateFormat.format(date);
    }
    /**
     * 时间补零占位
     * @param time 时间
     * @return     补零后的字符串
     */
    public static String zeroCompensation(int time){
        if (time < 10 ){
            return "0" + time;
        }
        return String.valueOf(time);
    }
}

测试

public class BaseDateUtilTest {
    @Test
    public void format(){
        System.out.println(BaseDateUtil.format(new Date(),"Asia/Shanghai","yyyy-MM-dd HH:mm:ss"));
        System.out.println(BaseDateUtil.format(new Date(),"yyyy-MM-dd HH:mm:ss"));
        System.out.println(BaseDateUtil.format(new Date()));
    }
}

输出

2022-04-16 15:55:07
2022-04-16 15:55:08
2022-04-16 15:55:08

字符串解析时间

public abstract class BaseDateUtil {
    /**
     * 默认时区
     */
    private final static String timeZone = "Asia/Shanghai";
    /**
     * 默认时间字符串模板
     */
    private final static String pattern = "yyyy-MM-dd HH:mm:ss";
    /**
     * 将日期字符串解析为日期对象
     * @param text      日期字符串
     * @param timeZone  时区
     * @param pattern   日期格式化字符串模板
     * @return          日期字符串解析后的日期对象
     * @throws ParseException
     */
    public static Date parse(String text, String timeZone, String pattern) throws ParseException {
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
        return dateFormat.parse(text);
    }
    /**
     * 将日期字符串解析为日期对象
     * @param text      日期字符串
     * @param pattern   日期格式化字符串模板
     * @return          日期字符串解析后的日期对象
     * @throws ParseException
     */
    public static Date parse(String text, String pattern) throws ParseException {
        return parse(text, timeZone, pattern);
    }
    /**
     * 将日期字符串解析为日期对象
     * @param text      日期字符串
     * @return          日期字符串解析后的日期对象
     * @throws ParseException
     */
    public static Date parse(String text) throws ParseException {
        return parse(text, timeZone, pattern);
    }
    /**
     * 时间补零占位
     * @param time 时间
     * @return     补零后的字符串
     */
    public static String zeroCompensation(int time){
        if (time < 10 ){
            return "0" + time;
        }
        return String.valueOf(time);
    }
}

测试

public class BaseDateUtilTest {
    @Test
    public void parse() throws ParseException {
        System.out.println(BaseDateUtil.parse("1983-11-22 20:30:00","Asia/Shanghai","yyyy-MM-dd HH:mm:ss"));
        System.out.println(BaseDateUtil.parse("1983-11-22 20:30:00","yyyy-MM-dd HH:mm:ss"));
        System.out.println(BaseDateUtil.parse("1983-11-22 20:30:00"));
    }
}

输出

Tue Nov 22 20:30:00 CST 1983
Tue Nov 22 20:30:00 CST 1983
Tue Nov 22 20:30:00 CST 1983

日期类 LocalDate

获取当前日期

使用java.time包下的LocalDate

使用LocalDate.now()方法获取默认时区的当前时间

public class LocalDateTest {
    @Test
    public void test(){
        // 获取当前日期
        LocalDate now = LocalDate.now();
        System.out.println(now);
    }
}

输出

2022-04-16

根据参数设置日期

使用LocalDate.of()方法传入参数

public class LocalDateTest {
@Test
    public void test02(){
        // 获取当前日期
        LocalDate localDate = LocalDate.of(1983,11,22);
        System.out.println(localDate);
    }
 }

输出

1983-11-22

使用get方法获取日期

方法	描述
now.getDayOfYear()	获取当前日期所在年的第几天
now.getDayOfMonth()	获取当前日期所在月的第几天
now.getDayOfWeek()	获取当前日期所在周的星期
now.getMonthValue()	获取当前日期所在月份的数值
now.getMonth()	获取当前日期月份的英文单词
now.lengthOfMonth()	获取当前日期所在月份有多少天
now.lengthOfYear()	获取当前日期所在年份有多少天
now.isLeapYear()	获取当前日期所在年是否是闰年

public class LocalDateTest {
 @Test
    public void test03(){
        // 获取当前日期是所在年或月的第几天
        LocalDate now = LocalDate.now();
        System.out.println(now.getDayOfYear());
        System.out.println(now.getDayOfMonth());
        System.out.println(now.getDayOfWeek());

        // 获取当前日期所在月份的数值
        System.out.println(now.getMonth());
        System.out.println(now.getMonthValue());
        // 获取当前日期所在月份有多少天
        System.out.println(now.lengthOfMonth());
        // 获取当前日期所在年份有多少天
        System.out.println(now.lengthOfYear());
        // 获取当前日期所在年是否是闰年
        System.out.println(now.isLeapYear());
    }
 }

输出

106
16
SATURDAY
APRIL
4
30
365
false

使用with方法替换当前日期

with开头的方法，是将参数替换localDate中的对应属性，重新计算得到新的日期

方法	描述
now.withDayOfMonth()	将参数中的“日”替换localDate中的“日”
now.withDayOfYear()	将参数中的天数替换localDate中的天数（一年中的第几天）
now.withMonth()	将参数中的“月”替换localDate中的“月”
now.withYear()	将参数中的“年”替换localDate中的“年”

public class LocalDateTest {
 @Test
    public void test04(){
        // with开头的方法，是将参数替换localDate中的对应属性，重新计算得到新的日期
        LocalDate now = LocalDate.now();
        System.out.println(now);
        // 将参数中的“日”替换localDate中的“日”
        System.out.println(now.withDayOfMonth(7));
        // 将参数中的天数替换localDate中的天数（一年中的第几天）
        System.out.println(now.withDayOfYear(45));
        // 将参数中的“月”替换localDate中的“月”
        System.out.println(now.withMonth(11));
        // 将参数中的“年”替换localDate中的“年”
        System.out.println(now.withYear(1983));
        System.out.println(now.withYear(1983).withMonth(11).withDayOfMonth(22));
    }
}

输出

2022-04-16
2022-04-07
2022-02-14
2022-11-16
1983-04-16
1983-11-22

使用minus方法将当前日期推前

方法	描述
now.minusDays()	将当前日期减一天
now.minusWeeks()	将当前日期减一周
now.minusMonths()	将当前日期减一月
now.minusYears()	将当前日期减一年

public class LocalDateTest {
@Test
    public void test05(){
        LocalDate now = LocalDate.now();
        System.out.println(now);
        // 将当前日期减一天
        System.out.println(now.minusDays(1));
        // 将当前日期减一周
        System.out.println(now.minusWeeks(1));
        // 将当前日期减一月
        System.out.println(now.minusMonths(1));
        // 将当前日期减一年
        System.out.println(now.minusYears(1));
        System.out.println(now.minusYears(1).minusMonths(1).minusDays(1));
    }
}

输出

2022-04-16
2022-04-15
2022-04-09
2022-03-16
2021-04-16
2021-03-15

使用plus方法将当前日期推后

方法	描述
now.plusDays()	将当前日期加一天
now.plusWeeks()	将当前日期加一周
now.plusMonths()	将当前日期加一月
now.plusYears()	将当前日期加一年

public class LocalDateTest {
@Test
  public void test06(){
       LocalDate now = LocalDate.now();
       System.out.println(now);
       // 将当前日期加一天
       System.out.println(now.plusDays(1));
       // 将当前日期加一周
       System.out.println(now.plusWeeks(1));
       // 将当前日期加一月
       System.out.println(now.plusMonths(1));
       // 将当前日期加一年
       System.out.println(now.plusYears(1));
   }
}
   ```
输出
```java
2022-04-16
2022-04-17
2022-04-23
2022-05-16
2023-04-16

日期比较

方法	描述
date01.isBefore()	比较日期之前
date02.isAfter()	比较日期之后

public class LocalDateTest {
@Test
    public void test07(){
        LocalDate date01 = LocalDate.of(1983,11,22);
        LocalDate date02 = LocalDate.of(1988,8,11);
        System.out.println(date01.isBefore(date02));
        System.out.println(date02.isAfter(date01));
    }
}

输出

true
true

Date转换LocalDate

public class LocalDateTest {
@Test
    public void test08(){
        Date date = new Date();
        System.out.println(date);
        OffsetDateTime offsetDateTime = date.toInstant().atOffset(ZoneOffset.of("+8"));
        LocalDate localDate = offsetDateTime.toLocalDate();
        System.out.println(localDate);
    }
}

输出

Sun Apr 17 09:39:28 CST 2022
2022-04-17

日期类 LocalTime

获取当前时间

public class LocalTimeTest {
    @Test
    public void test01(){
        // 获取当前时间
        LocalTime now = LocalTime.now();
        System.out.println(now);
    }
}

输出

22:34:16.606020490

根据参数设置时间

public class LocalTimeTest {
@Test
    public void test02(){
        // 根据参数设置时间，参数分别是时，分，秒
        LocalTime localTime = LocalTime.of(10,11,22);
        System.out.println(localTime);
    }
 }

输出

10:11:22

使用get方法获取时间

方法	描述
now.getHour()	获取当前小时
now.getMinute()	获取当前分钟
now.getSecond()	获取当前秒钟
now.getNano()	获取当前毫秒数

public class LocalTimeTest {
@Test
    public void test03(){
        // 获取当前时，分，秒
        LocalTime now = LocalTime.now();
        System.out.println(now.getHour());
        System.out.println(now.getMinute());
        System.out.println(now.getSecond());
        System.out.println(now.getNano());
    }
 }

输出

22
59
28
45087385

使用with方法替换当前日期

with开头的方法，是将参数替换localTime中的对应属性，重新计算得到新的时间

方法	描述
now.withHour()	将参数中的“时”替换LocalTime中的“时”
now.withMinute()	将参数中的“分”替换LocalTime中的“分”
now.withSecond()	将参数中的“秒”替换LocalTime中的“秒”
now.withNano()	将参数中的“毫秒”替换LocalTime中的“毫秒”

public class LocalTimeTest {
@Test
    public void test04(){
        // with开头的方法，是将参数替换LocalTime中的对应属性，重新计算得到新的时间
        LocalTime now = LocalTime.now();
        System.out.println(now);
        // 将参数中的“时”替换LocalTime中的“时”
        System.out.println(now.withHour(7));
        // 将参数中的“分”替换LocalTime中的“分”
        System.out.println(now.withMinute(1));
        // 将参数中的“秒”替换LocalTime中的“秒”
        System.out.println(now.withSecond(1));
       // 将参数中的“毫秒”替换LocalTime中的“毫秒”
        System.out.println(now.withNano(1)); 
    }
}

输出

22:57:20.135402090
07:57:20.135402090
22:01:20.135402090
22:57:01.135402090
22:57:20.000000001

使用minus方法将当前日期推前

方法	描述
now.minusHours()	将当前时间减一小时
now.withMinute()	将当前时间减掉，重新得到新的分钟
now.minusSeconds()	将当前时间减一秒钟
now.minusNanos()	将当前时间减一毫秒钟

public class LocalTimeTest {
 @Test
    public void test05(){
        LocalTime now = LocalTime.now();
        System.out.println(now);
        // 将当前时间减一小时
        System.out.println(now.minusHours(1));
        // 将当前时间减掉，重新得到新的分钟
        System.out.println(now.withMinute(1));
        // 将当前时间减一秒钟
        System.out.println(now.minusSeconds(1));
        // 将当前时间减一毫秒钟
        System.out.println(now.minusNanos(1));
    }
}

输出

22:40:41.641537152
21:40:41.641537152
22:01:41.641537152
22:40:40.641537152
22:40:40.641537151

使用plus方法将当前日期推后

方法	描述
now.plusHours()	将当前时间加一小时
now.plusMinutes()	将当前时间加一分钟
now.plusSeconds()	将当前时间加一秒钟
now.plusNanos()	将当前时间加一毫秒钟

public class LocalTimeTest {
@Test
   public void test06(){
       LocalTime now = LocalTime.now();
       System.out.println(now);
       // 将当前时间加一小时
       System.out.println(now.plusHours(1));
       // 将当前时间加一分钟
       System.out.println(now.plusMinutes(1));
       // 将当前时间加一秒钟
       System.out.println(now.plusSeconds(1));
       // 将当前时间加一毫秒钟
       System.out.println(now.plusNanos(1));
   }
}
   ```
输出
```java
22:53:25.377187110
23:53:25.377187110
22:54:25.377187110
22:53:26.377187110
22:53:25.377187111

时间比较

方法	描述
time01.isBefore()	比较时间之前
time02.isAfter()	比较时间之后

public class  LocalTimeTest {
@Test
    public void test07(){
        LocalTime time01 = LocalTime.of(8,8,8);
        LocalTime time02 = LocalTime.of(6,6,6);
        System.out.println(time01.isBefore(time02));
        System.out.println(time02.isAfter(time01));
    }
}

输出

false
false

Date转换LocalTime

public class  LocalTimeTest {
 @Test
    public void test08(){
        Date date = new Date();
        System.out.println(date);
        OffsetDateTime offsetDateTime = date.toInstant().atOffset(ZoneOffset.of("+8"));
        LocalTime localTime = offsetDateTime.toLocalTime ();
        System.out.println(localTime);
    }
}

输出

Sun Apr 17 09:50:53 CST 2022
09:50:53.437

日期类 LocalDateTime

获取日期时间

public class LocalDateTimeTest {
    @Test
    public void test01(){
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
    }
 }

输出

2022-04-16T23:09:15.341262720

格式化日期时间

public class LocalDateTimeTest {
    @Test
    public void test02(){
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = formatter.format(now);
        System.out.println(format);
    }
}

输出

2022-04-16T23:10:49.533594172
2022-04-16 23:10:49

字符串解析日期时间

public class LocalDateTimeTest {
@Test
    public void test03(){
        // 定义时间字符串
        String text = "1983-11-22 20:30:30";
        // 将时间字符串根据模板解析为LocalDateTime
        LocalDateTime parse = LocalDateTime.parse(text, formatter);
        System.out.println(parse);
    }
}

输出

1983-11-22T20:30:30

比较日期时间

public class LocalDateTimeTest {
@Test
    public void test04(){
        // 定义时间字符串
        String text = "1983-11-22 20:30:30";
        // 将时间字符串根据模板解析为LocalDateTime
        LocalDateTime parse = LocalDateTime.parse(text, formatter);
        System.out.println(parse);
        // 获取当前时间
        LocalDateTime now = LocalDateTime.now();
        // 判断某时刻是否在某时刻之前
        System.out.println(parse.isBefore(now));
        System.out.println(parse.isAfter(now));
        // 判断某时刻与某时刻是否是同一时刻
        System.out.println(parse.isEqual(now));
    }
}

输出

1983-11-22T20:30:30
true
false
false

获取带有时区的时间并格式化时间

public class LocalDateTimeTest {
@Test
    public void test05(){
        // 获取当前时间
        LocalDateTime bj = LocalDateTime.now();
        // 获取带有时区的时间
        LocalDateTime tokyo = LocalDateTime.now(ZoneId.of("+9"));
        System.out.println("北京时间 >>> " + bj);
        System.out.println("日本东京时间 >>> " + tokyo);
        System.out.println(bj.format(formatter));
        System.out.println(formatter.format(tokyo));
    }
}

输出

北京时间 >>> 2022-04-17T08:46:25.072974735
日本东京时间 >>> 2022-04-17T09:46:25.073142716
2022-04-17 08:46:25
2022-04-17 09:46:25

获取带有时区的时间毫秒数

public class LocalDateTimeTest {
 @Test
    public void test06(){
        long second = LocalDateTime.now(ZoneOffset.of("+9")).toEpochSecond(ZoneOffset.of("+8"));
        System.out.println(second);
        long milliSecond = LocalDateTime.now(ZoneOffset.of("+9")).toInstant(ZoneOffset.of("+8")).toEpochMilli();
        System.out.println(milliSecond);
        System.out.println(System.currentTimeMillis());
    }
}

输出

1650160803
1650160803540
1650157203540

LocalDateTime与Date转换

Date转换 LocalDateTime

public class LocalDateTimeTest {
@Test
    public void test07(){
        Date date = new Date();
        System.out.println(date);
        OffsetDateTime offsetDateTime = date.toInstant().atOffset(ZoneOffset.of("+8"));
        LocalDateTime localDateTime = offsetDateTime.toLocalDateTime();
        System.out.println(localDateTime);
    }
}

输出

Sun Apr 17 11:04:22 CST 2022
2022-04-17T11:04:22.528

LocalDateTime转换Date

public class LocalDateTimeTest {
 @Test
    public void test08(){
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        Instant instant = LocalDateTime.now().toInstant(ZoneOffset.of("+8"));
        Date date = Date.from(instant);
        System.out.println(date);
    }
}

输出

2022-04-17T09:37:18.997785098
Sun Apr 17 09:37:18 CST 2022

LocalDateTime工具类封装

LocalDateTime格式化为时间 指定的时间格式化字符串

public class BaseLocalDateTimeUtil {
    /**
     * 时间格式化模板字符串
     */
    private final static String formatter = "yyyy-MM-dd HH:mm:ss";
    /**
     * 将LocalDateTime格式化为时间 指定的时间格式化字符串
     * @param dateTime   欲被格式化的时间
     * @return           根据时间格式字符串模板个还是花的时间字符串
     */
    public static String format(LocalDateTime dateTime){
        return DateTimeFormatter.ofPattern(formatter).format(dateTime);
    }
    /**
     * 将LocalDateTime格式化为时间 指定的时间格式化字符串
     * @param dateTime   欲被格式化的时间
     * @param formatter  时间字符串模板
     * @return           根据时间格式字符串模板个还是花的时间字符串
     */
    public static String format(LocalDateTime dateTime,String formatter){
        return DateTimeFormatter.ofPattern(formatter).format(dateTime);
    }
}

测试

public class BaseLocalDateTimeUtilTest {
    @Test
    public void format(){
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(BaseLocalDateTimeUtil.format(dateTime));
        System.out.println(BaseLocalDateTimeUtil.format(dateTime,"yyyy年MM月dd日 HH时mm分ss秒"));
    }
}

输出

2022-04-17 10:41:17
2022年04月17日 10时41分17秒

根据时间字符串模板将时间格式字符串解析为LocalDateTime

public class BaseLocalDateTimeUtil {
    /**
     * 时间格式化模板字符串
     */
    private final static String formatter = "yyyy-MM-dd HH:mm:ss";
    /**
     * 根据时间字符串模板将时间格式字符串解析为LocalDateTime
     * @param text      时间字符串
     * @return
     */
    public static LocalDateTime parse(String text){
        return LocalDateTime.parse(text,DateTimeFormatter.ofPattern(formatter));
    }
    /**
     * 根据时间字符串模板将时间格式字符串解析为LocalDateTime
     * @param text      时间字符串
     * @param formatter 时间字符串模板
     * @return
     */
    public static LocalDateTime parse(String text,String formatter){
        return LocalDateTime.parse(text,DateTimeFormatter.ofPattern(formatter));
    }
}

测试

public class BaseLocalDateTimeUtilTest {
    @Test
    public void parse(){
        String text01 = "1983-11-22 20:30:30";
        String text02 = "1983年11月22日 20时30分30秒";
        System.out.println(BaseLocalDateTimeUtil.parse(text01));
        System.out.println(BaseLocalDateTimeUtil.parse(text02,"yyyy年MM月dd日 HH时mm分ss秒"));
    }
}

输出

1983-11-22T20:30:30
1983-11-22T20:30:30

LocalDateTime类型的时间转为Date类型的时间

public class BaseLocalDateTimeUtil {
    /**
     * 时间格式化模板字符串
     */
    private final static String formatter = "yyyy-MM-dd HH:mm:ss";
    /**
     * 默认时区为东8区
     */
    private static final ZoneOffset zoneOffset = ZoneOffset.of("+8");
    /**
     * LocalDateTime类型的时间转为Date类型的时间
     * @param dateTime       LocalDateTime
     * @retur Date
     */
    public static  Date toDate(LocalDateTime dateTime){
        return Date.from(dateTime.toInstant(zoneOffset));
    }
    /**
     * LocalDateTime类型的时间转为Date类型的时间
     * @param dateTime       LocalDateTime
     * @param zoneOffset     时区
     * @retur Date
     */
    public static  Date toDate(LocalDateTime dateTime, ZoneOffset zoneOffset){
        return Date.from(dateTime.toInstant(zoneOffset));
    }
}

测试

public class BaseLocalDateTimeUtilTest {
@Test
    public void toDate(){
        Date date01 = BaseLocalDateTimeUtil.toDate(LocalDateTime.now());
        Date date02 = BaseLocalDateTimeUtil.toDate(LocalDateTime.now(), ZoneOffset.of("+9"));
        System.out.println(date01);
        System.out.println(date02);
    }
}

输出

Sun Apr 17 11:29:09 CST 2022
Sun Apr 17 10:29:09 CST 2022

Date类型的时间转为LocalDateTime类型的时间

public class BaseLocalDateTimeUtil {
    /**
     * 时间格式化模板字符串
     */
    private final static String formatter = "yyyy-MM-dd HH:mm:ss";
    /**
     * 默认时区为东8区
     */
    private static final ZoneOffset zoneOffset = ZoneOffset.of("+8");
    /**
     * Date类型的时间转为LocalDateTime类型的时间
     * @param date        Date
     * @retur Date
     */
    public static  LocalDateTime toDate(Date date){
        return date.toInstant().atOffset(zoneOffset).toLocalDateTime();
    }
    /**
     * Date类型的时间转为LocalDateTime类型的时间
     * @param date        Date
     * @param zoneOffset  时区
     * @retur Date
     */
    public static  LocalDateTime toDate(Date date, ZoneOffset zoneOffset){
        return date.toInstant().atOffset(zoneOffset).toLocalDateTime();
    }
}

测试

public class BaseLocalDateTimeUtilTest {
@Test
    public void toDate01() {
        LocalDateTime localDateTime01 = BaseLocalDateTimeUtil.toDate01(Date.from(Instant.now()));
        LocalDateTime localDateTime02 = BaseLocalDateTimeUtil.toDate01(Date.from(Instant.now()),ZoneOffset.of("+9"));
        System.out.println(localDateTime01);
        System.out.println(localDateTime02);
    }
}

输出

2022-04-17T20:18:50.389
2022-04-17T21:18:50.391

---