设置容器的时区为上海

目录

• 11.1、Optional 容器类

• 11.1.1、概述
• 11.1.2、常用方法

• 11.2、新日期时间

• 11.2.1、概述
• 11.2.2、LocalDate类
• 11.2.3、LocalTime类
• 11.2.4、LocalDateTime类
• 11.2.5、Instant类
• 11.2.6、Period类
• 11.2.7、Duration类
• 11.2.8、时间校正器
• 11.2.9、格式化时间
• 11.2.10、解析时间
• 11.2.11、带时区的日期或时间

11.1、Optional 容器类

11.1.1、概述

Optional 类是一个容器类，代表一个值存在或不存在， 原来用 null 表示一个值不存在，现在 Optional类 可以更好的表达这个概念并且可以避免空指针异常

11.1.2、常用方法

import java.util.Optional;

public class Main {
	public static void main(String[] args) {
		// 创建一个 Optional 实例
		Optional<String> op1 = Optional.of("Hello,World");

		// 创建一个空的 Optional 实例
		Optional<Object> op2 = Optional.empty();

		// 若参数不为 null，创建 Optional 实例，否则创建空实例
		Optional<Object> op3 = Optional.ofNullable(null);

		// 判断是否包含值
		boolean isPresent = op1.isPresent();
		System.out.println(isPresent);

		// 如果调用对象包含值，返回该值，否则返回参数
		Object orElse = op2.orElse("Hello,World");
		System.out.println(orElse);

		// 如果调用对象包含值，返回该值，否则返回 s 获取的值
		Object orElseGet = op3.orElseGet(() -> 10 + 20);
		System.out.println(orElseGet);

		// 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
		Optional<String> op4 = op1.map((s) -> s.toUpperCase());
		System.out.println(op4.get());
	}
}

11.2、新日期时间

11.2.1、概述

Java 的 java.util.Date 和 java.util.Calendar 类易用性差，不支持时区，而且都不是线程安全的，Java 8的日期和时间类包含 LocalDate、LocalTime、LocalDateTime、Instant、Duration 以及 Period，这些类都包含在 java.time 包中，它们是线程安全的，LocalDate 只会获取年月日，LocalTime 只会获取时分秒，LocalDateTime 获取年月日时分秒，相当于 LocalDate + LocalTime，推荐使用LocalDateTime

11.2.2、LocalDate类

描述：本地日期，可以获取年、月、日、星期几

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.ChronoField;

public class Main {
	public static void main(String[] args) {
		// 静态方法，获取当前年月日
		LocalDate localDate = LocalDate.now();

		// 静态方法，构造指定年月日
		LocalDate localDate1 = LocalDate.of(2019, 9, 12);

		// 获取年、月、日、星期几
		int year = localDate.getYear();
		Month month = localDate.getMonth();
		int day = localDate.getDayOfMonth();
		DayOfWeek dayOfWeek = localDate.getDayOfWeek();
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(dayOfWeek);
		System.out.println("----------");

		// 获取年、月、日、星期几
		int year1 = localDate.get(ChronoField.YEAR);
		int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);
		int day1 = localDate.get(ChronoField.DAY_OF_MONTH);
		int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);
		System.out.println(year1);
		System.out.println(month1);
		System.out.println(day1);
		System.out.println(dayOfWeek1);
	}
}

11.2.3、LocalTime类

描述：本地时间，可以获取时、分、秒

import java.time.LocalTime;
import java.time.temporal.ChronoField;

public class Main {
	public static void main(String[] args) {
		// 静态方法，获取当前时分秒
		LocalTime localTime = LocalTime.now();
		// 静态方法，获取指定时分秒
		LocalTime localTime1 = LocalTime.of(14, 14, 14);

		// 获取时、分、秒
		int hour = localTime.getHour();
		int minute = localTime.getMinute();
		int second = localTime.getSecond();
		System.out.println(hour);
		System.out.println(minute);
		System.out.println(second);
		System.out.println("----------");

		// 获取时、分、秒
		int hour1 = localTime.get(ChronoField.HOUR_OF_DAY);
		int minute1 = localTime.get(ChronoField.MINUTE_OF_HOUR);
		int second1 = localTime.get(ChronoField.SECOND_OF_MINUTE);
		System.out.println(hour1);
		System.out.println(minute1);
		System.out.println(second1);
		System.out.println("----------");
	}
}

11.2.4、LocalDateTime类

描述：本地日期时间，可以获取年、月、日、时、分、秒、纳秒

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Main {
	public static void main(String[] args) {
		// 静态方法，根据当前时间创建对象
		LocalDateTime ldt = LocalDateTime.now();
		System.out.println(ldt);
		System.out.println("----------");

		// 静态方法，根据指定时间创建对象
		LocalDateTime ld2 = LocalDateTime.of(2015, 10, 10, 01, 02, 03);
		System.out.println(ld2);
		System.out.println("----------");

		/**
		 * plusYears plusMonths plusWeeks plusDays
		 */
		LocalDateTime ldt3 = ld2.plusYears(20);
		System.out.println(ldt3);
		System.out.println("----------");

		/**
		 * minusYears minusMonths minusWeeks minusDays
		 */
		LocalDateTime ldt4 = ld2.minusMonths(2);
		System.out.println(ldt4);
		System.out.println("----------");

		System.out.println(ldt.getYear());// 年
		System.out.println(ldt.getMonthValue());// 月
		System.out.println(ldt.getDayOfMonth());// 日
		System.out.println(ldt.getHour());// 时
		System.out.println(ldt.getMinute());// 分
		System.out.println(ldt.getSecond());// 秒
		System.out.println(ldt.getNano());// 纳秒
		System.out.println("----------");

		// 获取LocalDate
		LocalDate localDate = ldt.toLocalDate();
		System.out.println(localDate.now());
		System.out.println("----------");
		
		// 获取LocalTime
		LocalTime localTime = ldt.toLocalTime();
		System.out.println(localTime.now());
		System.out.println("----------");
	}
}

11.2.5、Instant类

描述：时间戳，可以获取秒、毫秒、纳秒

import java.time.Instant;

public class Main {
	public static void main(String[] args) {
		// 创建Instant对象
		Instant instant = Instant.now();
		
		// 获取秒数
		long currentSecond = instant.getEpochSecond();
		System.out.println(currentSecond);
		
		// 获取毫秒数
		long currentMilli = instant.toEpochMilli();
		System.out.println(currentMilli);
		
		// 获取纳秒数
		int currentNano = instant.getNano();
		System.out.println(currentNano);
	}
}

11.2.6、Period类

描述：用于计算两个“日期”间隔，可以获取年、月、天、总月

import java.time.LocalDate;
import java.time.Period;

public class Main {
	public static void main(String[] args) {
		LocalDate ld1 = LocalDate.now();
		LocalDate ld2 = LocalDate.of(2020, 1, 21);

		Period period = Period.between(ld2, ld1);
		int years = period.getYears();
		int months = period.getMonths();
		int days = period.getDays();
		long totalMonths = period.toTotalMonths();

		System.out.println(years);// 年
		System.out.println(months);// 月
		System.out.println(days);// 天
		System.out.println(totalMonths);// 总月
	}
}

11.2.7、Duration类

描述：用于计算两个“时间”间隔，可以获取天、时、时、分、秒、毫秒、纳秒

import java.time.Duration;
import java.time.Instant;

public class Main {
	public static void main(String[] args) {
		Instant ins1 = Instant.now();

		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		Instant ins2 = Instant.now();

		Duration duration = Duration.between(ins1, ins2);
		long days = duration.toDays();// 天
		long hours = duration.toHours();// 时
		long minutes = duration.toMinutes();// 分
		long seconds = duration.getSeconds();// 秒
		long millis = duration.toMillis();// 毫秒
		long nanos = duration.toNanos();// 纳秒

		System.out.println(days);
		System.out.println(hours);
		System.out.println(minutes);
		System.out.println(seconds);
		System.out.println(millis);
		System.out.println(nanos);
	}
}

11.2.8、时间校正器

描述：TemporalAdjusters 包含许多静态方法，可以直接调用

方法名	描述
dayOfWeekInMonth	返回同一个月中每周的第几天
firstDayOfMonth	返回当月的第一天
firstDayOfNextMonth	返回下月的第一天
firstDayOfNextYear	返回下一年的第一天
firstDayOfYear	返回本年的第一天
firstInMonth	返回同一个月中第一个星期几
lastDayOfMonth	返回当月的最后一天
lastDayOfNextMonth	返回下月的最后一天
lastDayOfNextYear	返回下一年的最后一天
lastDayOfYear	返回本年的最后一天
lastInMonth	返回同一个月中最后一个星期几
next / previous	返回后一个/前一个给定的星期几
nextOrSame / previousOrSame	返回后一个/前一个给定的星期几，如果这个值满足条件，直接返回

import java.time.DayOfWeek;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;

public class Main {
	public static void main(String[] args) {
		LocalDateTime localDateTime = LocalDateTime.of(2020, Month.JULY, 21, 12, 30, 32);
		// 增加一年
		localDateTime = localDateTime.plusYears(1);
		localDateTime = localDateTime.plus(1, ChronoUnit.YEARS);
		System.out.println(localDateTime);
		System.out.println("----------");

		// 减少一年
		localDateTime = localDateTime.minusYears(1);
		localDateTime = localDateTime.minus(1, ChronoUnit.YEARS);
		System.out.println(localDateTime);
		System.out.println("----------");

		// 指定年份
		localDateTime = localDateTime.withYear(2020);
		localDateTime = localDateTime.with(ChronoField.YEAR, 2020);
		System.out.println(localDateTime);
		System.out.println("----------");

		// 获取该年的第一天
		localDateTime = localDateTime.with(TemporalAdjusters.firstDayOfYear());
		System.out.println(localDateTime);
		System.out.println("----------");

		// 自定义：下一个工作日
		localDateTime = localDateTime.with((l) -> {
			LocalDateTime ldt = (LocalDateTime) l;
			DayOfWeek dow = ldt.getDayOfWeek();
			if (dow.equals(DayOfWeek.FRIDAY)) {
				return ldt.plusDays(3);
			} else if (dow.equals(DayOfWeek.SATURDAY)) {
				return ldt.plusDays(2);
			} else {
				return ldt.plusDays(1);
			}
		});
		System.out.println(localDateTime);
		System.out.println("----------");
	}
}

11.2.9、格式化时间

描述：通过localDate.format方法格式化，格式可以是内置的也可以是自定义的

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
	public static void main(String[] args) {
		LocalDate localDate = LocalDate.of(2020, 05, 05);

		// 内置格式
		String s1 = localDate.format(DateTimeFormatter.ISO_LOCAL_DATE);
		System.out.println(s1);

		// 自定义格式
		String s2 = localDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
		System.out.println(s2);
	}
}

11.2.10、解析时间

描述：通过LocalDate.parse方法解析，格式可以是内置的也可以是自定义的

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
	public static void main(String[] args) {
		// 内置格式
		LocalDate localDate1 = LocalDate.parse("2019-09-12", DateTimeFormatter.ISO_LOCAL_DATE);
		System.out.println(localDate1);

		// 自定义格式
		LocalDate localDate2 = LocalDate.parse("2019-09-12", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
		System.out.println(localDate2);
	}
}

11.2.11、带时区的日期或时间

描述：ZonedDate、ZonedTime、ZonedDateTime

import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Main {
	public static void main(String[] args) {
		ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
		System.out.println(zdt);
	}
}