JDK8日期API

public class Demo01 {
    public static void main(String[] args) {
        // Instant封装的时间为祖鲁时间并非当前时间.
        // 祖鲁时间也是格林尼治时间,也就是国际标准时间.
        Instant instant = Instant.now();

        // LocalDate封装的只有年月日,没有时分秒,格式为yyyy-MM-dd.
        LocalDate localDate = LocalDate.now();

        // LocalTime封装的只有时分秒,没有年月日,格式为hh:mm:ss.sss,最后的sss是纳秒.
        LocalTime localTime = LocalTime.now();

        // LocalDateTime将LocalDate和LocalTime合二为一,在年月日与时分秒中间使用T作为分隔.
        LocalDateTime localDateTime = LocalDateTime.now();

        // ZonedDateTime中封装了年月日时分秒,以及UTC(祖鲁时间)偏移量,并且还有一个地区名.
        // +8:00代表中国是东八区,时间比国际标准时间快八小时.
        ZonedDateTime zonedDateTime = ZonedDateTime.now();

        // Instant:2020-04-24T03:56:32.582Z
        System.out.println("Instant:" + instant);
        // LocalDate:2020-04-24
        System.out.println("LocalDate:" + localDate);
        // LocalTime:11:56:32.725
        System.out.println("LocalTime:" + localTime);
        // LocalDateTime:2020-04-24T11:56:32.725
        System.out.println("LocalDateTime:" + localDateTime);
        // ZonedDateTime:2020-04-24T11:56:32.729+08:00[Asia/Shanghai]
        System.out.println("ZonedDateTime:" + zonedDateTime);
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //初始化Year的实例化对象.
        Year year = Year.now();
        //初始化YearMonth的实例化对象
        YearMonth month = YearMonth.now();
        //初始化MonthDay的实例化对象.
        MonthDay day = MonthDay.now();

        System.out.println(year); // 2020
        System.out.println(month);  // 2020-04
        System.out.println(day); // --04-24
    }
}

public class Demo03 {
    public static void main(String[] args) {
        LocalDate date = LocalDate.of(2018, 8, 8);
        System.out.println("LocalDate:" + date); // LocalDate:2018-08-08

        // LocalTime time = LocalTime.of(19, 0); // LocalTime:19:00
        // LocalTime time = LocalTime.of(19, 10, 4); // LocalTime:19:10:04
        LocalTime time = LocalTime.of(19, 10, 4, 12); // LocalTime:19:10:04.000000012
        System.out.println("LocalTime:" + time);

        LocalDateTime time1 = LocalDateTime.of(2018, 8, 8, 19, 0, 0, 0);
        System.out.println(time1); // 2018-08-08T19:00
        LocalDateTime time2 = LocalDateTime.of(date, time);
        System.out.println(time2); // 2018-08-08T19:10:04.000000012
    }
}

        //获取所有的时区信息
        Set availableZoneIds = ZoneId.getAvailableZoneIds();
        for (String zoneId : availableZoneIds) {
            System.out.println(zoneId);
        }

        //获取当前系统默认的时区信息
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);

        LocalDateTime time = LocalDateTime.of(2018, 11, 11, 8, 54, 38);
        ZonedDateTime zonedDateTime = time.atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println("Asia/Shanghai的时间是:" + zonedDateTime);

        ZonedDateTime otherZonedTime = zonedDateTime.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));
        System.out.println("在同一时刻,Asia/Tokyo的时间是:" + otherZonedTime);

public class Demo05 {
    public static void main(String[] args) {
        LocalDateTime.of(2011, Month.JUNE, 15, 11, 11, 11);

        //of方法可以根据传入的数字返回对应的月份.
        Month month = Month.of(12);
        System.out.println(month); // DECEMBER
    }
}

public class Demo06 {
    public static void main(String[] args) {
        LocalTime time = LocalTime.now();
        LocalTime plusNanosTime = time.plusNanos(500);
        LocalTime plusSecondsTime = time.plusSeconds(45);
        LocalTime plusMinutesTime = time.plusMinutes(19);
        LocalTime plusHoursTime = time.plusHours(3);

        System.out.println("当前的时间是:" + time);
        System.out.println("45秒后的时间是:" + plusSecondsTime);
        System.out.println("19分钟后的时间是:" + plusMinutesTime);
        System.out.println("500纳秒后的时间是:" + plusNanosTime);
        System.out.println("3小时后的时间是:" + plusHoursTime);
    }
}

        Period period = Period.of(1, 2, 3);
        LocalDate localDate = LocalDate.now().plus(period);
        System.out.println(localDate);

        LocalDateTime localDateTime = LocalDateTime.now();
        LocalDateTime localDateTime1 = localDateTime.plus(1, ChronoUnit.DECADES);// 十年
        System.out.println(localDateTime1);
        localDateTime1.plus(1, ChronoUnit.HALF_DAYS); // 半天

        LocalDateTime endTime = localDateTime.withDayOfMonth(1);
        System.out.println("修改前的时间是:" + localDateTime);
        System.out.println("修改之后的时间是:" + endTime);

        LocalDateTime endTime1 = localDateTime.with(ChronoField.DAY_OF_MONTH, 1);
        System.out.println("修改前的时间是:" + localDateTime);
        System.out.println("修改之后的时间是:" + endTime1);

public class Demo07 {
    public static void main(String[] args) {
        LocalDate time = LocalDate.now();
        // 将时间修改为当月的第一天
        LocalDate firstDayOfMonth = time.with(TemporalAdjusters.firstDayOfMonth());
        // 将时间修改为下个月的第一天.
        LocalDate firstDayOfNextMonth = time.with(TemporalAdjusters.firstDayOfNextMonth());
        //将时间修改为下一年的第一天.
        LocalDate firstDayOfNextYear = time.with(TemporalAdjusters.firstDayOfNextYear());
        //将时间修改为本年的第一天.
        LocalDate firstDayOfYear = time.with(TemporalAdjusters.firstDayOfYear());
        //将时间修改为本月的最后一天.
        LocalDate lastDayOfMonth = time.with(TemporalAdjusters.lastDayOfMonth());
        //将时间修改为本年的最后一天.
        LocalDate lastDayOfYear = time.with(TemporalAdjusters.lastDayOfYear());
        System.out.println("当月的第一天是:" + firstDayOfMonth);
        System.out.println("下个月的第一天是:" + firstDayOfNextMonth);
        System.out.println("下一年的第一天是:" + firstDayOfNextYear);
        System.out.println("本年的第一天是:" + firstDayOfYear);
        System.out.println("本月的最后一天是:" + lastDayOfMonth);
        System.out.println("本年的最后一天是:" + lastDayOfYear);
    }
}

        //将当前时间修改为下一个周日
        LocalDate nextSunday = time.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
        //将当前时间修改为上一个周三
        LocalDate previousWednesday = time.with(TemporalAdjusters.previous(DayOfWeek.WEDNESDAY));
        System.out.println("下一个周日是:" + nextSunday);
        System.out.println("上一个周三是:" + previousWednesday);

/**
 * 假如员工一个月中领取工资,发薪日是每个月的15号,如果发薪日是周末,则调整为周五.
 */
public class PayDayAdjuster implements TemporalAdjuster {

    @Override
    public Temporal adjustInto(Temporal temporal) {
        //1.将temporal转换为子类对象LocalDate,from方法可以将任何时态对象转换为LocalDate.
        LocalDate payDay = LocalDate.from(temporal);
        //2.判断当前封装的时间中的日期是不是当月15日,如果不是,则更改为15日.
        int day;
        if (payDay.getDayOfMonth() != 15) {
            day = 15;
        } else {
            day = payDay.getDayOfMonth();
        }
        LocalDate realPayDay = payDay.withDayOfMonth(day);
        //3.判断realPayDay对象中封装的星期数是不是周六或者是周日,如果是周六或者是周日则更改为周五.
        if (realPayDay.getDayOfWeek() == DayOfWeek.SUNDAY || realPayDay.getDayOfWeek() == DayOfWeek.SATURDAY) {
            //说明发薪日是周末,则更改为周五.
            realPayDay = realPayDay.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY));
        }
        return realPayDay;
    }
}

public class Demo08 {
    public static void main(String[] args) {
        //封装LocalDate对象为2018年12月1日.
        LocalDate payDay = LocalDate.of(2018, 12, 1);
        //2018年12月15日为周末,所以要提前到周五发放工资,通过自定义调节器完成对时间的修改.
        LocalDate realPayDay = LocalDate.from(new PayDayAdjuster().adjustInto(payDay));
        System.out.println("预计的发薪日是2018年12月15日,实际的发薪日为:" + realPayDay);
    }
}

/**
 * 获取某一天距离下一个劳动节的相隔天数的实现类.
 */
public class UntilDayQueryImpl implements TemporalQuery {
    @Override
    public Long queryFrom(TemporalAccessor temporal) {
        //获取当前的年/月/日信息.
        LocalDate now = LocalDate.from(temporal);
        //封装劳动节的时间,年参数传递year,month和day是5和1.
        LocalDate laborDay = LocalDate.of(now.getYear(), Month.MAY, 1);
        //判断当前时间是否已经超过了当年的劳动节,如果超过了,则laborDay+1年.
        if (now.isAfter(laborDay)) {
            laborDay = laborDay.plusYears(1);
        }
        //通过ChronoUnit的between方法计算两个时间点的差额.
        return ChronoUnit.DAYS.between(now, laborDay);
    }
}

public class Demo09 {
    public static void main(String[] args) {
        //封装LocalDate对象为当前时间.
        LocalDate time = LocalDate.now();
        //调用time对象的query方法查询距离下一个五一劳动节还有多少天.
        Long l = time.query(new UntilDayQueryImpl());
        System.out.println("距离下一个五一劳动节还有:" + l + "天.");
    }
}

public class Demo10 {
    public static void main(String[] args) {
        //初始化Date对象.
        Date d = new Date();
        //将Date类对象转换为Instant类对象.
        Instant i = d.toInstant();
        //Date类包含日期和时间信息,但是并不提供时区信息,和Instant类一样,可以通过Instant类的atZone方法添加时区信息之后进行转换.
        ZonedDateTime zonedDateTime = i.atZone(ZoneId.systemDefault());
        //将ZonedDateTime通过toLocalDate方法转换为LocalDate对象.
        LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
        // zonedDateTime.toLocalDate();
        // zonedDateTime.toLocalTime();
        System.out.println("转换之前的Date对象是:" + d);
        System.out.println("转换之后的LocalDate对象是:" + localDateTime);
    }
}

        //初始化java.sql.Date对象.
        java.sql.Date date = new java.sql.Date(System.currentTimeMillis());
        //将java.sql.Date对象通过toLocalDate方法转换为LocalDate对象.
        LocalDate localDate = date.toLocalDate();
        System.out.println("转换前的java.sql.Date对象是:" + date);
        System.out.println("转换后的LocalDate对象是:" + localDate);

        //初始化java.sql.Timestamp对象.
        Timestamp t = new Timestamp(System.currentTimeMillis());
        //将java.sql.Timestamp对象通过toLocalDateTime方法转换为LocalDateTime对象.
        LocalDateTime time = t.toLocalDateTime();
        System.out.println("转换之前的Timestamp对象是:" + t);
        System.out.println("转换之后的LocalDateTime对象是:" + time);

public class Demo11 {
    public static void main(String[] args) {
        //对LocalDateTime进行格式化与解析,初始化LocalDateTime对象.
        LocalDateTime time = LocalDateTime.now();
        //DateTimeFormatter类中定义了很多方式,通过常量名可以指定格式化方式.
        String result = time.format(DateTimeFormatter.ISO_DATE_TIME);
        System.out.println("ISO_DATE_TIME格式化之后的String是:" + result);
        String result1 = time.format(DateTimeFormatter.ISO_DATE);
        System.out.println("ISO_DATE格式化之后的String是:" + result1);

        //解析字符串的方式通过LocalDateTime类的静态方法parse方法传入需要解析的字符串即可.
        LocalDateTime localDateTime = LocalDateTime.parse(result);
        System.out.println("解析了字符串之后的LocalDateTime是:" + localDateTime);
    }
}

        //通过通过DateTimeFormatter的ofPattern方法可以自定义格式化模式.
        String result2 = time.format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss:SSS"));
        System.out.println("LocalDateTime格式化前是:" + time);
        System.out.println("LocalDateTime格式化后是:" + result2);