2020-12-10

Java8新特性-新时间与日期API

总结一下java8中的新特性新时间与日期API

LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间息。也不包含与时区相关的信息。

LocalDateTime常用方法

LocalDate / LocalTime用法类似，只不过LocalDate 包含年月日，LocalTime只包含时分秒

方法名	返回值类型	解释
now( )	static LocalDateTime	从默认时区的系统时钟获取当前日期
of(int year, int month, int dayOfMonth, int hour, int minute, int second)	static LocalDateTime	从年，月，日，小时，分钟和秒获得 LocalDateTime的实例，将纳秒设置为零
plus(long amountToAdd, TemporalUnit unit)	LocalDateTime	返回此日期时间的副本，并添加指定的数量
get(TemporalField field)	int	从此日期时间获取指定字段的值为 int

@Test
public void test1(){
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);// 2020-12-10T11:48:43.387

    LocalDateTime ld2 = LocalDateTime.of(2020, 12, 10, 11, 11, 10);
    System.out.println(ld2);// 2020-12-10T11:11:10

    LocalDateTime ldt3 = ld2.plusYears(20);
    System.out.println(ldt3);// 2040-12-10T11:11:10

    LocalDateTime ldt4 = ld2.minusMonths(2);
    System.out.println(ldt4);// 2020-10-10T11:11:10

    System.out.println(ldt.getYear());// 2020
    System.out.println(ldt.getMonthValue());// 12
    System.out.println(ldt.getDayOfMonth());// 10
    System.out.println(ldt.getHour());// 11
    System.out.println(ldt.getMinute());// 48
    System.out.println(ldt.getSecond());// 43
}

时间戳Instant

Instant：用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算，也就是UTC时间或者GMT格林威治时间

GMT=UTC
UTC+8=北京时间

//2. Instant : 时间戳。 （使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值）
@Test
public void test2(){
    Instant ins = Instant.now();  //默认使用 UTC 时区
    System.out.println(ins);// 2020-12-10T03:50:25.814Z

    OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));
    System.out.println(odt);// 2020-12-10T11:50:25.814+08:00

    System.out.println(ins.getNano());// 814000000

    Instant ins2 = Instant.ofEpochSecond(5);
    System.out.println(ins2);// 1970-01-01T00:00:05Z
}

时间 / 日期差

Duration：计算两个时间之间的间隔
Period：计算两个日期之间的间隔

//Duration : 用于计算两个“时间”间隔
//Period : 用于计算两个“日期”间隔
@Test
public void test3(){
    Instant ins1 = Instant.now();

    System.out.println("--------------------");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
    }

    Instant ins2 = Instant.now();
    // 获取两个时间间隔
    Duration duration = Duration.between(ins1, ins2);
    System.out.println("所耗费时间为(单位毫秒)：" + duration.toMillis());// 所耗费时间为(单位秒)：1001

    System.out.println("----------------------------------");

    LocalDate ld1 = LocalDate.now();
    System.out.println("现在日期为："+ ld1);// 现在日期为：2020-12-10
    LocalDate ld2 = LocalDate.of(2011, 1, 1);
    // 获取两个日期间隔
    Period pe = Period.between(ld2, ld1);
    System.out.println("年间隔" + pe.getYears());// 9
    System.out.println("月间隔" + pe.getMonths());// 11
    System.out.println("天间隔" + pe.getDays());// 9
}

时间校正器

TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。

TemporalAdjuster是一个函数接口，因此还可也用lambda表达式实现里面的接口

@FunctionalInterface
public interface TemporalAdjuster {

    Temporal adjustInto(Temporal temporal);

}

@Test
public void test4(){
    // 当前日期
	LocalDateTime ldt = LocalDateTime.now();
	System.out.println(ldt);
    // 本月第12天
	LocalDateTime ldt2 = ldt.withDayOfMonth(12);
	System.out.println(ldt2);
	// 下一个周日
	LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
	System.out.println(ldt3);
	
	//自定义：下一个工作日
	LocalDateTime ldt5 = ldt.with((l) -> {
		LocalDateTime ldt4 = (LocalDateTime) l;
		
		DayOfWeek dow = ldt4.getDayOfWeek();
		
		if(dow.equals(DayOfWeek.FRIDAY)){
			return ldt4.plusDays(3);
		}else if(dow.equals(DayOfWeek.SATURDAY)){
			return ldt4.plusDays(2);
		}else{
			return ldt4.plusDays(1);
		}
	});
	
	System.out.println(ldt5);
	
}

解析与格式化

java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

预定义的标准格式
语言环境相关的格式
自定义的格式

@Test
	public void test5(){
//		DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;	
	DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");
	
	LocalDateTime ldt = LocalDateTime.now();
	String strDate = ldt.format(dtf);
	
	System.out.println(strDate);
	
	LocalDateTime newLdt = ldt.parse(strDate, dtf);
	System.out.println(newLdt);
}

DateTimeFormatter时间工具类,转自DateTimeFormatter时间工具类

 
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
 
/**
 * @author xiaobu
 * @version JDK1.8.0_171
 * @date on  2019/1/11 11:52
 * @description V1.0 LocalDateTime工具类
 * SQL -> Java
 * date -> LocalDate
 * time -> LocalTime
 * timestamp -> LocalDateTime
 */
public class DateTimeUtils {
 
    public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HHmmss");
    public static final DateTimeFormatter YEAR_MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");
    public static final DateTimeFormatter SHORT_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyMMdd");
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    public static final DateTimeFormatter SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyMMddHHmmss");
    public static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public static final DateTimeFormatter LONG_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss SSS");
 
    /**
     * 返回当前的日期
     */
    public static LocalDate getCurrentLocalDate() {
        return LocalDate.now();
    }
 
    /**
     * 返回当前时间
     */
    public static LocalTime getCurrentLocalTime() {
        return LocalTime.now();
    }
 
    /**
     * 返回当前日期时间
     */
    public static LocalDateTime getCurrentLocalDateTime() {
        return LocalDateTime.now();
    }
 
    /**
     * yyyy-MM-dd
     */
    public static String getCurrentDateStr() {
        return LocalDate.now().format(DATE_FORMATTER);
    }
 
    /**
     * yyMMdd
     */
    public static String getCurrentShortDateStr() {
        return LocalDate.now().format(SHORT_DATE_FORMATTER);
    }
 
    public static String getCurrentMonthStr() {
        return LocalDate.now().format(YEAR_MONTH_FORMATTER);
    }
 
    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentDateTimeStr() {
        return LocalDateTime.now().format(DATETIME_FORMATTER);
    }
 
 
    public static String getCurrentLongDateTimeStr(){
        return LocalDateTime.now().format(LONG_DATETIME_FORMATTER);
    }
 
    /**
     * yyMMddHHmmss
     */
    public static String getCurrentShortDateTimeStr() {
        return LocalDateTime.now().format(SHORT_DATETIME_FORMATTER);
    }
 
    /**
     * HHmmss
     */
    public static String getCurrentTimeStr() {
        return LocalTime.now().format(TIME_FORMATTER);
    }
 
    public static String getCurrentDateStr(String pattern) {
        return LocalDate.now().format(DateTimeFormatter.ofPattern(pattern));
    }
 
    public static String getCurrentDateTimeStr(String pattern) {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(pattern));
    }
 
    public static String getCurrentTimeStr(String pattern) {
        return LocalTime.now().format(DateTimeFormatter.ofPattern(pattern));
    }
 
    public static LocalDate parseLocalDate(String dateStr, String pattern) {
        return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(pattern));
    }
 
    public static LocalDateTime parseLocalDateTime(String dateTimeStr, String pattern) {
        return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ofPattern(pattern));
    }
 
    public static LocalTime parseLocalTime(String timeStr, String pattern) {
        return LocalTime.parse(timeStr, DateTimeFormatter.ofPattern(pattern));
    }
 
    public static String formatLocalDate(LocalDate date, String pattern) {
        return date.format(DateTimeFormatter.ofPattern(pattern));
    }
 
    public static String formatLocalDateTime(LocalDateTime datetime, String pattern) {
        return datetime.format(DateTimeFormatter.ofPattern(pattern));
    }
 
    public static String formatLocalTime(LocalTime time, String pattern) {
        return time.format(DateTimeFormatter.ofPattern(pattern));
    }
 
    public static LocalDate parseLocalDate(String dateStr) {
        return LocalDate.parse(dateStr, DATE_FORMATTER);
    }
 
    public static LocalDateTime parseLocalDateTime(String dateTimeStr) {
        return LocalDateTime.parse(dateTimeStr, DATETIME_FORMATTER);
    }
 
    public static LocalDateTime parseLongLocalDateTime(String longDateTimeStr){
        return LocalDateTime.parse(longDateTimeStr, LONG_DATETIME_FORMATTER);
    }
 
    public static LocalTime parseLocalTime(String timeStr) {
        return LocalTime.parse(timeStr, TIME_FORMATTER);
    }
 
    public static String formatLocalDate(LocalDate date) {
        return date.format(DATE_FORMATTER);
    }
 
    public static String formatLocalDateTime(LocalDateTime datetime) {
        return datetime.format(DATETIME_FORMATTER);
    }
 
    public static String formatLocalTime(LocalTime time) {
        return time.format(TIME_FORMATTER);
    }
 
    /**
     * 日期相隔秒
     */
    public static long periodHours(LocalDateTime startDateTime,LocalDateTime endDateTime){
       return Duration.between(startDateTime, endDateTime).get(ChronoUnit.SECONDS);
    }
 
    /**
     * 日期相隔天数
     */
    public static long periodDays(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.DAYS);
    }
 
    /**
     * 日期相隔周数
     */
    public static long periodWeeks(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.WEEKS);
    }
 
    /**
     * 日期相隔月数
     */
    public static long periodMonths(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.MONTHS);
    }
 
    /**
     * 日期相隔年数
     */
    public static long periodYears(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.YEARS);
    }
 
    /**
     * 是否当天
     */
    public static boolean isToday(LocalDate date) {
        return getCurrentLocalDate().equals(date);
    }
    /**
     * 获取当前毫秒数
     */
    public static Long toEpochMilli(LocalDateTime dateTime) {
        return dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }
 
    /**
     * 判断是否为闰年
     */
    public static boolean isLeapYear(LocalDate localDate){
        return localDate.isLeapYear();
    }
}

时区

Java 8不仅分离了日期和时间，也把时区分离出来了。现在有一系列单独的类如ZoneId来处理特定时区，ZoneDateTime类来表示某时区下的时间。这在Java 8以前都是 GregorianCalendar类来做的。下面这个例子展示了如何把本时区的时间转换成另一个时区的时间。

获取所有时区id

1	Set<String> set = ZoneId.getAvailableZoneIds();

// ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
@Test
public void test7(){
    LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    System.out.println(ldt);

    ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
    System.out.println(zdt);
}

LocalDateTime常用方法

时间戳Instant

时间 / 日期 差

时间校正器

解析与格式化

时区

时间 / 日期差