Lambda LocalDate

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Period;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalUnit;

public enum UtilityDate {
	
	INSTANCE;
	
	/**
	 * 获取当日日期
	 * @return YYYY-MM-DD
	 */
	public String getToday() {
		return LocalDate.now().toString();
	}
	
	/**
	 * 获取指定日期的月份的第几个星期几是几号
	 * @param date 指定日期
	 * @param ordinal 第几个星期，无限制，但通常在-5到5之间
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getDayOfWeekInMonth(LocalDate date, int ordinal, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.dayOfWeekInMonth(ordinal, dayOfWeek)).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期当月的第一天
	 * @param date 指定日期
	 * @return YYYY-MM-DD
	 */
	public String getFirstDayOfMonth(LocalDate date) {
		return date.with(TemporalAdjusters.firstDayOfMonth()).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期下月的第一天
	 * @param date 指定日期
	 * @return YYYY-MM-DD
	 */
	public String getFirstDayOfNextMonth(LocalDate date) {
		return date.with(TemporalAdjusters.firstDayOfNextMonth()).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期当年的第一天
	 * @param date 指定日期
	 * @return YYYY-MM-DD
	 */
	public String getFirstDayOfYear(LocalDate date) {
		return date.with(TemporalAdjusters.firstDayOfYear()).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期明年的第一天
	 * @param date 指定日期
	 * @return YYYY-MM-DD
	 */
	public String getFirstDayOfNextYear(LocalDate date) {
		return date.with(TemporalAdjusters.firstDayOfNextYear()).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期同一个月中，第一个符合星期几要求的日期
	 * @param date 指定日期
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getFirstInMonth(LocalDate date, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.firstInMonth(dayOfWeek)).toString();
	}

	/**
	 * 获取一个新的日期，它的值为指定日期当月的最后一天
	 * @param date 指定日期
	 * @return YYYY-MM-DD
	 */
	public String getLastDayOfMonth(LocalDate date) {
		return date.with(TemporalAdjusters.lastDayOfMonth()).toString();
	}
	
//	lastDayOfNextMonth 创建一个新的日期，它的值为下月的最后一天
//	public String getLastDayOfNextMonth(LocalDate date) {
//		return date.with(TemporalAdjusters.lastdof)
//	}
	
	
	/**
	 * 获取一个新的日期，它的值为指定日期当年的最后一天
	 * @param date 指定日期
	 * @return YYYY-MM-DD
	 */
	public String getLastDayOfYear(LocalDate date) {
		return date.with(TemporalAdjusters.lastDayOfYear()).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期同一个月中，最后一个符合星期几要求的值
	 * @param date 指定日期
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getLastInMonth(LocalDate date, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.lastInMonth(dayOfWeek)).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期的下一个星期几
	 * @param date 指定日期
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getNextWeekByCurrentDate(LocalDate date, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.next(dayOfWeek)).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期的前一个星期几
	 * @param date 指定日期
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getPreviousWeekByCurrentDate(LocalDate date, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.previous(dayOfWeek)).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期的下一个星期几，如果当日符合，则返回当日
	 * @param date 指定日期
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getNextOrSameWeekByCurrentDate(LocalDate date, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.nextOrSame(dayOfWeek)).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期的上一个星期几，如果当日符合，则返回当日
	 * @param date 指定日期
	 * @param dayOfWeek 星期几
	 * @return YYYY-MM-DD
	 */
	public String getPreviousOrSame(LocalDate date, DayOfWeek dayOfWeek) {
		return date.with(TemporalAdjusters.previousOrSame(dayOfWeek)).toString();
	}
	
	/**
	 * 比较第一个参数日期是否在第二个参数日期之前
	 * @param firstDate 第一个参数日期
	 * @param secondDate 第二个参数日期
	 * @return true-是 false-否
	 */
	public boolean isFirstDateBeforeSecondDate(LocalDate firstDate, LocalDate secondDate) {
		return firstDate.isBefore(secondDate);
	}
	
	/**
	 * 比较第一个参数日期是否在第二个参数日期之后
	 * @param firstDate 第一个参数日期
	 * @param secondDate 第二个参数日期
	 * @return true-是  false-否
	 */
	public boolean isFirstDateAfterSecondDate(LocalDate firstDate, LocalDate secondDate) {
		return firstDate.isAfter(secondDate);
	}
	
	/**
	 * 比较第一个参数日期是否等于第二个参数日期
	 * @param firstDate 第一个参数日期
	 * @param secondDate 第二个参数日期
	 * @return true-是  false-否
	 */
	public boolean isFirstDateEqualSecondDate(LocalDate firstDate, LocalDate secondDate) {
		return firstDate.isEqual(secondDate);
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期加上指定天数
	 * @param date 指定日期
	 * @param daysToAdd 增加的天数，可以为负数
	 * @return YYYY-MM-DD
	 */
	public String plusDays(LocalDate date, long daysToAdd) {
		return date.plusDays(daysToAdd).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期减去指定天数
	 * @param date 指定日期
	 * @param daysToSubtract 减去的天数，可以为负数
	 * @return YYYY-MM-DD
	 */
	public String minusDays(LocalDate date, long daysToSubtract) {
		return date.minusDays(daysToSubtract).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期加上一个时间段
	 * @param date 指定日期
	 * @param amountToAdd 增加的时间段，可以为负数
	 * @return YYYY-MM-DD
	 */
	public String plus(LocalDate date, TemporalAmount amountToAdd) {
		return date.plus(amountToAdd).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期加上若干数量的时间单位
	 * @param date 指定日期
	 * @param amountToAdd 时间单位数量，可以为负数
	 * @param unit 时间单位 [ChronoUnit.CENTURIES、DAYS、DECADES、WEEKS、YEARS]
	 * @return YYYY-MM-DD
	 */
	public String plus(LocalDate date, long amountToAdd, TemporalUnit unit) {
		return date.plus(amountToAdd, unit).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期减去一个时间段
	 * @param date 指定日期
	 * @param amountToSubtract 减去的时间段，可以为负数
	 * @return YYYY-MM-DD
	 */
	public String minus(LocalDate date, TemporalAmount amountToSubtract) {
		return date.minus(amountToSubtract).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期减去若干数量的时间单位
	 * @param date 指定日期
	 * @param amountToSubtract 时间单位数量，可以为负数
	 * @param unit 时间单位 [ChronoUnit.CENTURIES、DAYS、DECADES、WEEKS、YEARS]
	 * @return YYYY-MM-DD
	 */
	public String minus(LocalDate date, long amountToSubtract, TemporalUnit unit) {
		return date.minus(amountToSubtract, unit).toString();
	}
	
	/**
	 * 获取年份值，它的值为指定日期的年份值
	 * @param date 指定日期
	 * @return 年份值
	 */
	public int getYearByDate(LocalDate date) {
		return date.getYear();
	}
	
	/**
	 * 获取月份值，它的值为指定日期的月份值
	 * @param date 指定日期
	 * @return 月份值
	 */
	public int getMonthByDate(LocalDate date) {
		return date.getMonthValue();
	}
	
	/**
	 * 获取日期值，它的值为指定日期月份中的日期值
	 * @param date 指定日期
	 * @return 日期值
	 */
	public int getDayOfMonth(LocalDate date) {
		return date.getDayOfMonth();
	}
	
	/**
	 * 获取天数值，它的值为指定日期在当年中的天数
	 * @param date 指定日期
	 * @return 天数值
	 */
	public int getDayOfYear(LocalDate date) {
		return date.getDayOfYear();
	}
	
	/**
	 * 获取星期，它的值为指定日期在当周中的星期
	 * @param date 指定日期
	 * @return 星期
	 */
	public String getDayOfWeek(LocalDate date) {
		return date.getDayOfWeek().toString();
	}
	
	/**
	 * 获取英文月份，它的值为指定日期当月的月份
	 * @param date 指定日期
	 * @return 英文月份
	 */
	public String getMonthOfEN(LocalDate date) {
		return date.getMonth().toString();
	}
	
	/**
	 * 获取英文星期，它的值为指定日期的星期
	 * @param date 指定日期
	 * @return 英文星期
	 */
	public String getWeekOfEN(LocalDate date) {
		return date.getDayOfWeek().toString();
	}
	
	/**
	 * 获取中文月份，它的值为指定日期当月的月份
	 * @param date 指定日期
	 * @return 中文月份
	 */
	public String getMonthOfCN(LocalDate date) {
		String month = "";
		switch (date.getMonthValue()) {
		case 1:
			month = "一月";
			break;
		case 2:
			month = "二月";
			break;
		case 3:
			month = "三月";
			break;
		case 4:
			month = "四月";
			break;
		case 5:
			month = "五月";
			break;
		case 6:
			month = "六月";
			break;
		case 7:
			month = "七月";
			break;
		case 8:
			month = "八月";
			break;
		case 9:
			month = "九月";
			break;
		case 10:
			month = "十月";
			break;
		case 11:
			month = "十一月";
			break;
		case 12:
			month = "十二月";
			break;
		default:
			break;
		}
		return month;
	}
	
	/**
	 * 获取中文星期，它的值为指定日期的星期
	 * @param date 指定日期
	 * @return 中文星期
	 */
	public String getWeekOfCN(LocalDate date) {
		String week = "";
		switch (date.getDayOfWeek()) {
		case MONDAY:
			week = "星期一";
			break;
		case TUESDAY:
			week = "星期二";
			break;
		case WEDNESDAY:
			week = "星期三";
			break;
		case THURSDAY:
			week = "星期四";
			break;
		case FRIDAY:
			week = "星期五";
			break;
		case SATURDAY:
			week = "星期六";
			break;
		case SUNDAY:
			week = "星期日";
			break;
		default:
			break;
		}
		return week;
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期后的第几天
	 * @param date 指定日期
	 * @param days 天数
	 * @return YYYY-MM-DD
	 */
	public String getNextNDay(LocalDate date, long days) {
		return date.with(adjuster -> adjuster.plus(days, ChronoUnit.DAYS)).toString();
	}
	
	/**
	 * 获取一个新的日期，它的值为指定日期前的第几天
	 * @param date 指定日期
	 * @param days 天数
	 * @return YYYY-MM-DD
	 */
	public String getPreviousNDay(LocalDate date, long days) {
		return date.with(adjuster -> adjuster.minus(days, ChronoUnit.DAYS)).toString();
	}
	
	public static void main(String[] args) {
		System.out.println(UtilityDate.INSTANCE.getWeekOfCN(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getWeekOfEN(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getPreviousNDay(LocalDate.now(), 1));
		System.out.println(UtilityDate.INSTANCE.getNextNDay(LocalDate.now(), 1));
		System.out.println(UtilityDate.INSTANCE.getMonthOfCN(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getMonthOfEN(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getDayOfWeek(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getDayOfYear(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getDayOfMonth(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getMonthByDate(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getYearByDate(LocalDate.now()));
		System.out.println("----------------------------");
		System.out.println(LocalDate.now().get(ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH));
		System.out.println(LocalDate.of(2022, 3, 3).get(ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR));
		System.out.println(LocalDate.now().get(ChronoField.ALIGNED_WEEK_OF_MONTH));
		System.out.println(LocalDate.now().get(ChronoField.ALIGNED_WEEK_OF_YEAR));
		System.out.println(LocalDate.now().get(ChronoField.MONTH_OF_YEAR));
		System.out.println(LocalDate.now().get(ChronoField.YEAR));
		System.out.println(LocalDate.now().getDayOfMonth());
		System.out.println(LocalDate.now().getMonthValue());
		System.out.println(LocalDate.now().getDayOfWeek());
		System.out.println(LocalDate.now().getMonth());
		System.out.println(LocalDate.now().getYear());
		System.out.println("----------------------------");
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), 1, ChronoUnit.CENTURIES)); // 当前时间减去一个世纪
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), 1, ChronoUnit.DAYS));      // 当前时间减去一天
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), 1, ChronoUnit.DECADES));   // 当前时间减去十年
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), 1, ChronoUnit.WEEKS));     // 当前时间减去一周
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), 1, ChronoUnit.YEARS));     // 当前时间减去一年
		System.out.println("----------------------------");
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.ZERO));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.between(LocalDate.of(2022, 3, 3), LocalDate.of(2022, 3, 5))));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.from(Period.ofDays(2))));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.of(1, 0, 0)));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.ofDays(-10)));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.ofMonths(1)));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.ofWeeks(1)));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.ofYears(1)));
		System.out.println(UtilityDate.INSTANCE.minus(LocalDate.now(), Period.parse("P2Y")));
		System.out.println("----------------------------");
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), 1, ChronoUnit.CENTURIES)); // 当前时间增加一个世纪
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), 1, ChronoUnit.DAYS));      // 当前时间增加一天
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), 1, ChronoUnit.DECADES));   // 当前时间增加十年
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), 1, ChronoUnit.WEEKS));     // 当前时间增加一周
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), 1, ChronoUnit.YEARS));     // 当前时间增加一年
		System.out.println("----------------------------");
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.ZERO));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.between(LocalDate.of(2022, 3, 3), LocalDate.of(2022, 3, 5))));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.from(Period.ofDays(2))));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.of(1, 0, 0)));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.ofDays(-10)));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.ofMonths(1)));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.ofWeeks(1)));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.ofYears(1)));
		System.out.println(UtilityDate.INSTANCE.plus(LocalDate.now(), Period.parse("P2Y")));

		System.out.println(LocalDate.now().plus(Period.ofDays(1)));
//		System.out.println(LocalDate.now().plus());
		System.out.println(LocalDate.now().plusMonths(1));
		System.out.println(LocalDate.now().plusWeeks(1));
		System.out.println(LocalDate.now().plusYears(1));
		System.out.println(UtilityDate.INSTANCE.plusDays(LocalDate.now(), 2));
		System.out.println(UtilityDate.INSTANCE.isFirstDateEqualSecondDate(LocalDate.of(2012, 6, 30), LocalDate.of(2012, 6, 30)));
		System.out.println(UtilityDate.INSTANCE.isFirstDateAfterSecondDate(LocalDate.of(2012, 6, 30), LocalDate.of(2012, 6, 29)));
		System.out.println(UtilityDate.INSTANCE.isFirstDateBeforeSecondDate(LocalDate.of(2012, 6, 30), LocalDate.of(2012, 7, 1)));
		System.out.println(UtilityDate.INSTANCE.getPreviousOrSame(LocalDate.now(), DayOfWeek.MONDAY));
		System.out.println(UtilityDate.INSTANCE.getNextOrSameWeekByCurrentDate(LocalDate.now(), DayOfWeek.THURSDAY));
		System.out.println(UtilityDate.INSTANCE.getNextWeekByCurrentDate(LocalDate.now(), DayOfWeek.THURSDAY));
		System.out.println(UtilityDate.INSTANCE.getPreviousWeekByCurrentDate(LocalDate.now(), DayOfWeek.FRIDAY));
		System.out.println(UtilityDate.INSTANCE.getLastInMonth(LocalDate.now(), DayOfWeek.FRIDAY));
		System.out.println(UtilityDate.INSTANCE.getLastDayOfYear(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getLastDayOfMonth(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getFirstInMonth(LocalDate.now(), DayOfWeek.FRIDAY));
		System.out.println(UtilityDate.INSTANCE.getFirstDayOfNextYear(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getFirstDayOfYear(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getFirstDayOfNextMonth(LocalDate.now()));
		System.out.println(UtilityDate.INSTANCE.getToday());
		System.out.println(UtilityDate.INSTANCE.getDayOfWeekInMonth(LocalDate.now(), 1, DayOfWeek.FRIDAY));
		System.out.println(UtilityDate.INSTANCE.getFirstDayOfMonth(LocalDate.now()));
		LocalDate date = LocalDate.now();
		
		System.out.println(date.with(TemporalAdjusters.firstDayOfMonth()));
		
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(-5, DayOfWeek.FRIDAY))); // 2022-02-25	这个月的倒数第五个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(-4, DayOfWeek.FRIDAY))); // 2022-03-04	这个月的倒数第四个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(-3, DayOfWeek.FRIDAY))); // 2022-03-11	这个月的倒数第三个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(-2, DayOfWeek.FRIDAY))); // 2022-03-18	这个月的倒数第二个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(-1, DayOfWeek.FRIDAY))); // 2022-03-25	这个月的最后一个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(0, DayOfWeek.FRIDAY)));  // 2022-02-25	上个月的最后一个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(1, DayOfWeek.FRIDAY)));  // 2022-03-04	这个月的第一个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY)));  // 2022-03-11	这个月的第二个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(3, DayOfWeek.FRIDAY)));  // 2022-03-18	这个月的第三个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(4, DayOfWeek.FRIDAY)));  // 2022-03-25	这个月的第四个星期五是几号
		System.out.println(date.with(TemporalAdjusters.dayOfWeekInMonth(5, DayOfWeek.FRIDAY)));  // 2022-04-01	这个月的第五个星期五是几号
	}

}