java8之LocalDate方法的用法研究

  前言：字字看来皆是血，几天辛苦不寻常,花了几天把LocalDate的方法研究了个遍，其中不乏自己的思考

说明链接：java.util.time包的描述

/**
 * 
 */
package com.ljh.myo2o.dao;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.TemporalQueries;
import java.time.temporal.ValueRange;
import java.util.Arrays;
import java.util.Locale;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @description:
 * @author :林建辉
 * @CreateTime:2018-11-23 02:23:41
 */
public class DateAndTimeDemo {
	private Logger logger = LoggerFactory.getLogger(DateAndTimeDemo.class);

	/**
	 * discription:
	 * 
	 * @author:林建辉
	 * @createTime:2018-11-23 02:23:41
	 * @param args
	 */
	public static void main(String[] args) {
		// 从默认时区的系统时钟获取当前日期
		// LocalDate:只包含日期而没有时间
		// 该类重写了toString()方法,所以打印的时候是以yyyy-MM-dd 格式输出
		LocalDate today = LocalDate.now();
		// 今天的日期是: 2018-11-23
		System.out.println("今天的日期是: " + today);
		// 从指定的年月日中获取LocalDate实例
		// 指定的日必须对年和月有效否则将抛出DateTimeException
		// 此方法有一个重载，就是第二个参数为Month枚举
		LocalDate specifiedDate = LocalDate.of(2018, 1, 1);
		LocalDate sDate = LocalDate.of(2018, Month.JANUARY, 1);
		// 判断两个日期是否相等就用equals方法，LocalDate类重写了equals方法
		System.out.println(specifiedDate.equals(sDate));// true
		// 如果想知道某一年的第340天是几月几号，可以使用下面的方法
		LocalDate date = LocalDate.ofYearDay(2018, 340);
		System.out.println(date);// 2018-12-06
		// 如果想知道今天是一年中的第几天，可以使用下面的方法，其它同理
		int dayOfYear = date.getDayOfYear();
		int dayOfMonth = date.getDayOfMonth();
		System.out.println(dayOfYear + "__" + dayOfMonth);
		// 下面是java.util.time包中唯二的两个枚举
		// 不仅有枚举值，也包含一些计算方法如：plus/minus/firstMonthOfQuarter
		DayOfWeek dayOfWeek = date.getDayOfWeek();
		Month month = date.getMonth();
		// 获取月份可以使用以下方法
		int monthValue = month.getValue();
		int monthValue2 = date.getMonthValue();
		// 获取该月份有多少天
		date.lengthOfMonth();
		month.length(date.isLeapYear());// leap year 闰年

		// EpochDay:纪元日 ，第0天是1970-01-01天，负数代表早些日子
		long epochDayNums = date.toEpochDay();
		LocalDate.ofEpochDay(epochDayNums);
		// Chronology:年表
		// LocalDate dateNow = date.getChronology().dateNow();

		// TemporalAccessor是所有时间类以及时间接口的父类
		// LocalDate from = LocalDate.from(TemporalAccessor temporal);

		// System.out.println(LocalDateTime.now().toString().replace("T", " "));

		// 静态方法的引用中的返回值类型就是功能函数里的泛型，该静态方法的参数就是功能函数中方法的参数
		// TemporalQuery q=LocalDate::from;

		// 其内部就是调用其重载方法
		LocalDate parse1 = LocalDate.parse("2018-11-11");
		LocalDate parse2 = LocalDate.parse("2018-11-11", DateTimeFormatter.ISO_LOCAL_DATE);
		System.out.println(parse1);
		System.out.println(parse2);

		// 虽然不知道有什么用,用于判断
		boolean supportedChronoField = date.isSupported(ChronoField.DAY_OF_MONTH);
		boolean supportedChronoUnit = date.isSupported(ChronoUnit.YEARS);
		System.out.println(supportedChronoField);
		System.out.println(supportedChronoUnit);

		// 获取某个日期字段的有效范围值
		ValueRange range = date.range(ChronoField.DAY_OF_MONTH);
		System.out.println(range);// 1 - 31

		// int i = date.get(ChronoField.DAY_OF_MONTH);//6
		// 反正也不知道啥用
		// 哪种写法更牛逼点
		/*
		 * for (ChronoField c : ChronoField.values()) { if (date.isSupported(c))
		 * { if ("EpochDayProlepticMonth".contains(c.toString())) {
		 * System.out.println(date.getLong(c)+"--"+c); }else {
		 * System.out.println(date.get(c)+"--"+c); }
		 * 
		 * } }
		 */
		Arrays.asList(ChronoField.values()).forEach((c) -> {
			if (date.isSupported(c)) {
				if ("EpochDayProlepticMonth".contains(c.toString())) {
					System.out.println(date.getLong(c) + "--" + c);
				} else {
					System.out.println(date.get(c) + "--" + c);
				}
			}
		});

		// with系列方法
		/*
		 * LocalDate with(TemporalAdjuster adjuster) LocalDate
		 * with(TemporalField field, long newValue) LocalDate withYear(int year)
		 * LocalDate withMonth(int month) LocalDate withDayOfYear(int dayOfYear)
		 * 由于LocalDate 是final类，每次的修改都要用变量保存起来 示例表示返回7月份的最后一天的日期 result =
		 * localDate.with(JULY).with(lastDayOfMonth());
		 */
		// LocalDate withDayOfMonth =
		// date.with(Month.JULY).withDayOfMonth(Month.JULY.length(date.with(Month.JULY).isLeapYear()));
		LocalDate lastDateOfJuly = date.with(Month.JULY);
		lastDateOfJuly = lastDateOfJuly.withDayOfMonth(lastDateOfJuly.lengthOfMonth());
		System.out.println(lastDateOfJuly);

		/*
		 * // these two lines are equivalent 
		 * Period period = start.until(end); 
		 * Period.between(start, end);
		 */

		/*
		 * plus和minus系列方法: Period类和Duration类实现了TemporalAmount接口
		 * ChronoUnit实现了TemporalUnit接口 LocalDate plus(TemporalAmount
		 * amountToAdd) LocalDate plus(long amountToAdd, TemporalUnit unit)
		 * LocalDate plusYears(long yearsToAdd) LocalDate plusMonths(long
		 * monthsToAdd) LocalDate plusWeeks(long weeksToAdd) LocalDate
		 * plusDays(long daysToAdd)
		 */
		Period period = Period.between(LocalDate.of(2018, 12, 7), LocalDate.of(2018, 12, 31));
		LocalDate plusDate = date.plus(period);
		System.out.println(plusDate);
		
	      System.out.printf("LocalDate precision is %s%n",
	         date.query(TemporalQueries.precision()));
	      
	      /*
	       * 插曲
	      StringBuilder sb = new StringBuilder();//实现了Appendable接口
	      //格式输出到Appendable,以中国的格式输出
	      Formatter formatter = new Formatter(sb, Locale.CHINA);
	     //格式输出语法： %[argument_index$][flags][width][.precision]conversion
	      formatter.format("%4$2s%3$2s%2$2s%1$2s", "a", "b", "c", "d");
	      System.out.println(formatter.out());
	      formatter.format(Locale.PRC, "e = %+.4f", Math.E);
	      System.out.println(formatter.out());
	      formatter.close();
	      
	      String format = String.format("hello,%s","world!");
	      System.out.println(format);
	      	
	      System.out.format("hello,%s","world!");*/
	      
	      //没有得到预期效果
	      LocalDate newDate =(LocalDate)date.adjustInto(LocalDate.of(2018, 12, 31));
	      System.out.println("newDate:"+newDate);
	      
	      //这样调整就行
	      LocalDate with = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.MONDAY));
	      System.out.println(with);//今天的日期为25号，调整后的日期为2018-11-26
	     
	      //计算距离2019-01-30有多少天
	      long until = LocalDate.now().until(LocalDate.of(2019, 1, 30), ChronoUnit.DAYS);
	      System.out.println(until);//66
	      
	      //until 的重载
	      Period period2 = LocalDate.now().until(LocalDate.of(2019, 1, 30));
	      System.out.println(period2.getDays());//为什么是5,这个方法有bug
	      
	      /*
	       * 从源码里可以看到，格式化就是调用DateTimeFormatter.format()方法
	       *  public String format(DateTimeFormatter formatter) {
        	 	Objects.requireNonNull(formatter, "formatter");
        	    return formatter.format(this);
    		  }
	       */
	      //写个示例而已，虽然没有必要这么做
	      DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
	      DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd",Locale.CHINA);
	      String format = LocalDate.now().format(formatter);
	      System.out.println(format);
	      
	      /*
	       * atTime系列方法：用于调整时间，给日期加时间
	       * LocalDateTime atTime(LocalTime time)
	       * LocalDateTime atTime(int hour, int minute)
	       * LocalDateTime atTime(int hour, int minute, int second)
	       * LocalDateTime atTime(int hour, int minute, int second, int nanoOfSecond)
	       * OffsetDateTime atTime(OffsetTime time)
	       */
	      LocalDateTime atTime = LocalDate.now().atTime(10, 25);
	      System.out.println(atTime);//2018-11-25T10:25
	      //打印出来我们发现时间和日期多了个T,不符合中国的日期标准，格式化一下
	      String format2 = atTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
	      System.out.println(format2);//2018-11-25T10:25:00
	      //打印出来我们发现，使用预定格式的格式化器还是有个T，只是多了秒
	      //当预定格式的格式化器也无法满足的时候，使用自定义的格式化器
	      DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	      String format3 = atTime.format(dtf);
	      System.out.println(format3);//2018-11-25 10:25:00,完美解决
	      
	      //将时分秒归零
	      LocalDateTime atStartOfDay = LocalDate.now().atStartOfDay();
	      String format4 = atStartOfDay.format(dtf);
	      System.out.println(format4);//2018-11-25 00:00:00
	      
	      /*
	       * int compareTo(ChronoLocalDate other)和boolean equals(Object obj)
	       * 有同样的效果，都重写了父类的方法
	       * 其实equals 方法就是调用了compareTo方法
	       */
	      if (LocalDate.now().equals(LocalDate.of(2018, 11, 25))) {
			System.out.println(true);
		  }
	      if (LocalDate.now().compareTo(LocalDate.of(2018, 11, 25))==0) {
				System.out.println(true);
		  }
	      
	      /*
	       * is系列方法：
	       * boolean isAfter(ChronoLocalDate other)
	       * boolean isBefore(ChronoLocalDate other)
	       * boolean isEqual(ChronoLocalDate other)
	       * 和上面的compareTo和equals方法是统一性质
	       */
	      //至此：大功告成，字字看来皆是血，几天辛苦不寻常
	}
}