一、接口中的静态方法和默认方法

在java8之前，接口中只能有全局静态常量和抽象方法。

二、新时间日期API

传统时间格式化存在线程安全问题

新时间日期API：

  • LocalDate,LocalDateTime,LocalTime：人读的时间和日期
  • Instant(时间戳)：机读的时间戳
  • Duration：计算两个时间之间的间隔
  • Period：计算两个日期之间的间隔

  • OffsetTime：对时间做偏移量运算(比如加几个小时，减几个小时)

    1.   @Test
    2.   public void test3() throws ExecutionException, InterruptedException {
    3.       DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
    5.       Callable<LocalDate> task = new Callable<LocalDate>() {
    7.           @Override
    8.           public LocalDate call() throws Exception {
    9.               return LocalDate.parse("20210717", dtf);
    10.           }
    11.       };
    13.       ExecutorService pool = Executors.newFixedThreadPool(10);
    15.       List<Future<LocalDate>> results = new ArrayList<>();
    17.       for (int i = 0; i < 10; i++) {
    18.           results.add(pool.submit(task));
    19.       }
    21.       for (Future<LocalDate> result : results) {
    22.           System.out.println(result.get());
    23.       }
    24.   }

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

    1、本地时间与时间戳

    1. public class LocalDateTimTest {
    3.   /**
    4.    * Duration:计算两个“时间”之间的间隔
    5.    * Period:计算两个“日期”之间的间隔
    6.    */
    7.   @Test
    8.   public void test4() {
    9.       Instant instant = Instant.now();
    10.       try {
    11.           Thread.sleep(1000);
    12.       } catch (InterruptedException e) {
    13.           e.printStackTrace();
    14.       }
    15.       Instant instant1 = Instant.now();
    16.       Duration duration = Duration.between(instant, instant1);
    17.       System.out.println(duration);   // PT1.009S
    19.       System.out.println("-----------------");
    21.       LocalTime time = LocalTime.now();
    22.       try {
    23.           Thread.sleep(1000);
    24.       } catch (InterruptedException e) {
    25.           e.printStackTrace();
    26.       }
    27.       LocalTime time1 = LocalTime.now();
    28.       long millis = Duration.between(time, time1).toMillis();
    29.       System.out.println(millis); // 1006
    30.   }
    32.   /**
    33.    * 以下是机读的——时间戳（以Unix元年——1970年1月1日00:00:00 到某个时间之间的毫秒值）
    34.    */
    35.   @Test
    36.   public void test3() {
    37.       Instant now = Instant.now();    // 默认获取 UTC 时区（与中国差八个小时，比中国慢8个小时）
    38.       System.out.println(now);     // 2021-07-17T14:09:32.062Z
    40.       OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8)); // 加上8个小时即为中国时间
    41.       System.out.println(offsetDateTime);     // 2021-07-17T22:09:32.062+08:00
    43.       // 获取时间戳
    44.       System.out.println(now.toEpochMilli());     // 1626531117816
    45.   }
    47.   /**
    48.    * 以下是人读的
    49.    */
    50.   @Test
    51.   public void test() {
    52.       LocalDateTime now = LocalDateTime.now(); // now() : 获取当前日期时间
    53.       System.out.println(now);    // 2021-07-17T21:55:51.507
    55.       LocalDate now1 = LocalDate.now();
    56.       System.out.println(now1);   // 2021-07-17
    58.       LocalTime now2 = LocalTime.now();
    59.       System.out.println(now2);   // 21:55:51.508
    60.   }
    62.   @Test
    63.   public void test2() {
    64.       LocalDateTime localDateTime = LocalDateTime.of(2020, 6, 6, 13, 14, 30, 345); // 指定日期时间
    65.       System.out.println(localDateTime);  // 2020-06-06T13:14:30.000000345
    67.       LocalDate localDate = LocalDate.of(2019, 06, 4);
    68.       System.out.println(localDate);  // 2019-06-04
    69.   }
    70. }

    2、时间校正器

  • TemporalAdjuster：时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。

  • TemporalAdjusters：该类通过静态方法提供了大量的常用TemporalAdjuster的实现。

    1.   @Test
    2.   public void test5() {
    3.       LocalDateTime localDateTime = LocalDateTime.now();
    4.       System.out.println(localDateTime);  // 2021-07-18T08:46:10.854
    6.       LocalDateTime localDateTime1 = localDateTime.withDayOfMonth(10);
    7.       System.out.println(localDateTime1); // 2021-07-10T08:46:10.854
    9.       LocalDateTime dateTime = localDateTime.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));
    10.       System.out.println(dateTime);   // 2021-07-23T08:48:01.609
    11.   }

    3、时间格式化与时区的处理

    1.   /**
    2.    * DateTimeFormatter：格式化时间/日期
    3.    */
    4.   @Test
    5.   public void test6() {
    6.       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_DATE;
    8.       LocalDateTime localDateTime = LocalDateTime.now();
    9.       System.out.println(localDateTime);  // 2021-07-18T08:54:41.321
    11.       // 根据自定义格式来格式化日期
    12.       String format = localDateTime.format(dateTimeFormatter);
    13.       System.out.println(format); // 2021-07-18
    14.   }
    1.  /**
    2.    * DateTimeFormatter：格式化时间/日期
    3.    */
    4.   @Test
    5.   public void test6() {
    6.       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_DATE;
    8.       LocalDateTime localDateTime = LocalDateTime.now();
    9.       System.out.println(localDateTime);  // 2021-07-18T08:59:28.196
    11.       // 根据指定格式来格式化日期
    12.       String format = localDateTime.format(dateTimeFormatter);
    13.       System.out.println(format); // 2021-07-18
    15.       // 根据自定义格式来格式化日期
    16.       DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
    17.       String format1 = dtf2.format(localDateTime);
    18.       System.out.println(format1);    // 2021年07月18日 08:59:28
    20.       // 将字符串解析回时间日期
    21.       CharSequence text;
    22.       LocalDateTime newDateTime = localDateTime.parse(format1, dtf2);
    23.       System.out.println(newDateTime);    // 2021-07-18T08:59:28
    24.   }
    1.   /**
    2.    * 对时区的处理
    3.    * ZoneDate、ZonedTime、ZonedDateTime
    4.    */
    5.   @Test
    6.   public void test7() {
    7.       // 指定时区来获取时间
    8.       LocalDateTime localDateTime = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    9.       System.out.println(localDateTime);  // 2021-07-18T09:07:19.661
    11.       // 构建一个带时区的时间
    12.       LocalDateTime localDateTime1 = LocalDateTime.now();
    13.       ZonedDateTime zonedDateTime = localDateTime1.atZone(ZoneId.of("Asia/Shanghai"));
    14.       System.out.println(zonedDateTime);  // 2021-07-18T09:07:19.670+08:00[Asia/Shanghai]
    15.   }

    三、重复注解与类型注解

    Java 8 对注解提供了两点改进：可重复的注解及可用于类型的注解。

    1、重复注解

    1. /**
    2. * 自定义注解
    3. */
    4. @Repeatable(MyAnnotations.class) // 若想定义重复注解，必须用@Repeatable修饰，然后注入此注解的容器类
    5. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    6. @Retention(RetentionPolicy.RUNTIME)
    7. public @interface MyAnnotation {
    8.   String value() default "hgk";
    9. }
    1. /**
    2. * 创建一个容器
    3. */
    4. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    5. @Retention(RetentionPolicy.RUNTIME)
    6. public @interface MyAnnotations {
    7.   MyAnnotation[] value();
    8. }

    ```java public class AnnTest {

    @Test public void test() throws NoSuchMethodException {

    1.   Class<AnnTest> clazz = AnnTest.class;
    2.   Method showMethod = clazz.getMethod("show");
    4.   MyAnnotation[] mas = showMethod.getDeclaredAnnotationsByType(MyAnnotation.class);
    5.   for (MyAnnotation ma : mas) {
    6.       System.out.println(ma.value());
    7.       /**
    8.        * 输出：
    9.        * Hello
    10.        * World
    11.        */
    12.   }

    }

    @MyAnnotation(“Hello”) @MyAnnotation(“World”) public void show() { }

} ```