第十一章容器类&新日期时间

分手后的思念是犯贱 2023-02-28 15:19 13阅读 0赞

### 目录 ###

*   *  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 包含许多静态方法，可以直接调用

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

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);
    	}
    }