Java8 新特性学习

摘自：https://blog.csdn.net/shuaicihai/article/details/72615495

Lambda 表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。 
Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分： 
- 左侧：指定了 Lambda 表达式需要的所有参数 
- 右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

Lambda 表达式语法

语法格式一：无参，无返回值，Lambda 体只需一条语句

 Runnable runnable = () -> System.out.println("hello Lambda");

语法格式二：Lambda 需要一个参数

Consumer<String> con = (t) -> System.out.println(t);

语法格式三：Lambda 只需要一个参数时，参数的小括号可以省略

 Consumer<String> con = t -> System.out.println(t);

语法格式四：Lambda 需要两个参数，并且有返回值

 Comparator<Integer> comparator = (x,y) -> {
         System.out.println("相加结果是:"+(x+y));
         return Integer.compare(x,y);
     };

语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略

 Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);

语法格式六：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

 Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。

  /**
      * Lambda表达式基础语法,Java8中引入新的操作符"->"
      * Lambda表达式分为左右两部分:
      *  左:Lambda表达式的参数列表
      *  右:Lambda表达式中所需执行的功能,即Lambda体
      */
     public class LambdaDemo {

         @Test
         public void test1(){
             Runnable r = new Runnable() {

                 @Override
                 public void run() {
                     System.out.println("hello world");
                 }
             };
             r.run();
             System.out.println("------------");

             //Lambda表达式
             Runnable runnable = () -> System.out.println("hello Lambda");
             runnable.run();
         }

         @Test
         public void test2(){
             Consumer<String> consumer = new Consumer<String>() {

                 @Override
                 public void accept(String t) {
                     System.out.println(t);
                 }
             };
             consumer.accept("hello consumer !");
             System.out.println("---------------");

             //Lambda表达式
     //      Consumer<String> con = (t) -> System.out.println(t);
             Consumer<String> con = t -> System.out.println(t);
             con.accept("hello Lambda !");
         }

         @Test
         public void test3(){
             Comparator<Integer> comparator = (x,y) -> {
                 System.out.println("相加结果是:"+(x+y));
                 return Integer.compare(x,y);
             };

             int compare = comparator.compare(1, 2);
             System.out.println(compare);
         }

         @Test
         public void test4(){
             Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);

             int compare = comparator.compare(1, 2);
             System.out.println(compare);
         }

         @Test
         public void test5(){
             show(new HashMap<>());
         }

         public void show(Map<String,Integer> map){

         }
     }

函数式接口

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

Java 内置四大核心函数式接口

  /**
      * 函数式接口
      */
     public class TestFunction {

         //Consumer<T>消费型接口
         @Test
         public void test1(){
             cost(8888, (m) -> System.out.println("共消费:" + m + "元"));
         }

         public void cost(double money,Consumer<Double> con){
             con.accept(money);
         }

         //Supplier<T> 供给型接口
         @Test
         public void test2(){
             List<Integer> list = getNumList(8, () -> (int)(Math.random() * 100));
             for (Integer integer : list) {
                 System.out.println(integer);
             }
         }

         //产生指定数量的整数,放入集合中
         public List<Integer> getNumList(int num,Supplier<Integer> sup){
             List<Integer> list = new ArrayList<Integer>();

             for (int i = 0; i < num; i++) {
                 Integer n = sup.get();
                 list.add(n);
             }

             return list;
         }

         //Function<T,R> 函数型接口
         @Test
         public void test3(){
             String string = strHandler(" 函数型接口测试 ", (str) -> str.trim().substring(0, 5));
             System.out.println(string);
         }

         //用于处理字符串
         public String strHandler(String str,Function<String, String> fun){
             return fun.apply(str);
         }

         //Predicate<T> 断言型接口
         @Test
         public void test4(){
             List<String> list = Arrays.asList("hello","Lambda","ok");
             List<String> strList = filterStr(list, (s) -> s.length() > 3);
             for (String string : strList) {
                 System.out.println(string);
             }
         }

         //将满足条件的字符串,放入集合中
         public List<String> filterStr(List<String> list, Predicate<String> pre){
             List<String> strList = new ArrayList<>();

             for (String str : list) {
                 if (pre.test(str)) {
                     strList.add(str);
                 }
             }
             return strList;
         }
     }

其他接口

方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。

如下三种主要使用情况： 
- 对象::实例方法 
- 类::静态方法 
- 类::实例方法

使用注意事项: 
* 1.Lambda 体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的函数列表和返回值类型保持一致。 
* 2.若Lambda 参数列表中第一个参数是实例方法调用者,第二个参数是实例方法的参数 可以使用 ClassName :: method

构造器引用

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！ 
格式： ClassName::new

数组引用

格式： type[] :: new

  /**
      * 方法引用:若Lambda 体中的内容有方法已经实现了,我们可以使用"方法引用"
      */
     public class TestMethodRef {

         @Test
         public void test1(){
             Consumer<String> con = (x) -> System.out.println(x);
             con.accept("shuai");

             //方法引用,对象::实例方法名
             Consumer<String> consumer = System.out::println;
             consumer.accept("test");
         }

         @Test
         public void test2(){
             Person person = new Person();
             Supplier<String> supplier = () -> person.getName();
             String str = supplier.get();
             System.err.println(str);

             //方法引用,对象::实例方法名
             Supplier<Integer> sup = person::getAge;
             Integer age = sup.get();
             System.out.println(age);
         }

         //类::静态方法名
         @Test
         public void test3(){
             Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
             //使用前提,compare的参数和返回值与Comparator一致
             Comparator<Integer> comparator = Integer :: compare;
         }

         //类::实例方法名
         @Test
         public void test4(){
             BiPredicate<String, String> bp = (x,y) -> x.equals(y);
             //使用条件:第一个参数是实例方法调用者,第二个参数是实例方法的参数
             BiPredicate<String, String> biPredicate = String :: equals;
         }

         //构造器引用
         @Test
         public void test5(){
             Supplier<Person> sup = () -> new Person();

             //构造器引用方式
             Supplier<Person> supplier = Person :: new;
             Person person = supplier.get();
             System.out.println(person);
         }

         //构造器引用
         @Test
         public void test6(){
             Function<Integer, Person> fun = (x) -> new Person(x);

             Function<Integer, Person> function = Person :: new;
             Person person = function.apply(2);
             System.out.println(person);
             System.out.println("--------------------");

             BiFunction<String, Integer, Person> biFunction = Person :: new;
             Person person2 = biFunction.apply("张三", 23);
             System.out.println(person2);
         }

         //数组引用
         @Test
         public void test7(){
             Function<Integer, String[]> fun = (x) -> new String[x];
             String[] strs = fun.apply(8);
             System.out.println(strs.length);

             Function<Integer, String[]> function = String[] :: new;
             String[] strArray = function.apply(6);
             System.out.println(strArray.length);
         }
     }

Stream API

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 
“集合讲的是数据，流讲的是计算！” 
1. Stream 自己不会存储元素。 
2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。 
3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

• 创建 Stream 
  一个数据源（如：集合、数组），获取一个流
• 中间操作 
  一个中间操作链，对数据源的数据进行处理
• 终止操作(终端操作) 
  一个终止操作，执行中间操作链，并产生结果

创建 Stream

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法： 
- default Stream stream() : 返回一个顺序流 
- default Stream parallelStream() : 返回一个并行流

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流： 
- static Stream stream(T[] array): 返回一个流

可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。 
- public static Stream of(T… values) : 返回一个流

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。 
- 迭代 
public static Stream iterate(final T seed, final UnaryOperator f) 
- 生成 
public static Stream generate(Supplier s) :

  //创建Stream
     @Test
     public void test1(){
         //1.可以通过Collection系列集合提供的stream() 或parallelStream()
         List<String> list = new ArrayList<>();
         Stream<String> stream = list.stream();

         //2.通过Arrays中静态方法 stream() 获取数组流
         Person[] persons = new Person[10];
         Stream<Person> stream2 = Arrays.stream(persons);

         //3.通过Stream类中的静态方法 of()
         Stream<String> stream3 = Stream.of("a","b","c");

         //4.创建无限流
         //迭代
         Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
         stream4.limit(8).forEach(System.out :: println);

         //生成
         Stream.generate(() -> Math.random()).limit(6)
             .forEach(System.out :: println);
     }       

Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

筛选与切片

映射

排序

   /**
      * Stream API的中间操作
      */
     public class TestSteamAPI2 {

         List<Person> persons = Arrays.asList(
                 new Person(2, "钱四", 24),
                 new Person(1, "张三", 33),
                 new Person(2, "李四", 24),
                 new Person(3, "王五", 65),
                 new Person(4, "赵六", 26),
                 new Person(4, "赵六", 26),
                 new Person(5, "陈七", 27)
         );

         //内部迭代，由Stream API完成
         @Test
         public void test1(){
             //中间操作,不会执行任何操作
             Stream<Person> stream = persons.stream()
                                         .filter((e) -> {
                                             System.out.println("Stream的中间操作");
                                             return e.getAge() > 25;
                                         });
             //终止操作，一次性执行全部内容，即"惰性求值"
             stream.forEach(System.out :: println);
         }

         //外部迭代
         @Test
         public void test2(){
             Iterator<Person> iterator = persons.iterator();
             while (iterator.hasNext()) {
                 System.out.println(iterator.next());
             }
         }

         //limit，截断
         @Test
         public void test3(){
             persons.stream()
                 .filter((e) -> {
                     System.out.println("迭代操作"); //短路
                     return e.getAge() > 24;
                 })
                 .limit(2)
                 .forEach(System.out :: println);
         }

         //跳过skip,distinct去重(要重写equals和hashcode)
         @Test
         public void test4(){
             persons.stream()
                     .filter((e) -> e.getAge() > 23)
                     .skip(2)
                     .distinct()
                     .forEach(System.out :: println);
         }

         //映射
         @Test
         public void test5(){
             List<String> list = Arrays.asList("a","bb","c","d","e");

             list.stream().map((str) -> str.toUpperCase())
                 .forEach(System.out :: println);
             System.out.println("---------------");

             persons.stream().map((Person :: getName)).forEach(System.out :: println);
             System.out.println("---------------");

             Stream<Stream<Character>> stream = list.stream()
                 .map(TestSteamAPI2 :: filterCharacter);

             stream.forEach((s) -> {
                 s.forEach(System.out :: println);
             });
             System.out.println("-----------------");

             //flatMap
             Stream<Character> stream2 = list.stream()
                 .flatMap(TestSteamAPI2 :: filterCharacter);
             stream2.forEach(System.out :: println);
         }

         //处理字符串
         public static Stream<Character> filterCharacter(String str){
             List<Character> list = new ArrayList<>();

             for (Character character : str.toCharArray()) {
                 list.add(character);
             }
             return list.stream();
         }

         //排序
         @Test
         public void test6(){
             List<String> list = Arrays.asList("bb","c","aa","ee","ddd");

             list.stream()
                 .sorted() //自然排序
                 .forEach(System.out :: println);
             System.out.println("------------");

             persons.stream()
                     .sorted((p1,p2) -> {
                         if (p1.getAge() == p2.getAge()) {
                             return p1.getName().compareTo(p2.getName());
                         } else {
                             return p1.getAge() - p2.getAge();
                         }
                     }).forEach(System.out :: println);

         }

     }

Stream 的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

查找与匹配

归约

 
 
map 和 reduce 的连接通常称为 map-reduce 模式。

收集

 
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

  /**
      * Stream API的终止操作
      */
     public class TestSteamAPI3 {

         List<Person> persons = Arrays.asList(
                 new Person(2, "钱四", 24,Status.YOUNG),
                 new Person(1, "张三", 23,Status.YOUNG),
                 new Person(2, "李四", 24,Status.YOUNG),
                 new Person(3, "王五", 65,Status.OLD),
                 new Person(4, "赵六", 26,Status.MIDDLE),
                 new Person(4, "赵六", 56,Status.OLD),
                 new Person(5, "陈七", 27,Status.MIDDLE)
         );

         //查找与匹配
         @Test
         public void test1(){
             boolean b = persons.stream()
                                 .allMatch((e) -> e.getStatus().equals(Status.YOUNG));
             System.out.println(b);

             boolean b2 = persons.stream()
                     .anyMatch((e) -> e.getStatus().equals(Status.YOUNG));
             System.out.println(b2);

             boolean b3 = persons.stream()
                     .noneMatch((e) -> e.getStatus().equals(Status.MIDDLE));
             System.out.println(b3);

             Optional<Person> op = persons.stream()
                     .sorted((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge()))
                     .findFirst();
             System.out.println(op.get());

             Optional<Person> optional = persons.stream()
                     .filter((e) -> e.getStatus().equals(Status.OLD))
                     .findAny();
             System.out.println(optional.get());
         }

         //最大，最小
         @Test
         public void test2(){
             long count = persons.stream()
                     .count();
             System.out.println(count);

             Optional<Person> optional = persons.stream()
                     .max((e1,e2) -> Integer.compare(e1.getId(), e2.getId()));
             System.out.println(optional.get());

             Optional<Integer> op = persons.stream()
                     .map(Person :: getAge)
                     .min(Integer :: compare);
             System.out.println(op.get());
         }

         //归约
         @Test
         public void test3(){
             List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8);

             Integer sum = list.stream()
                 .reduce(0, (x,y) -> x + y);
             System.out.println(sum);
             System.out.println("------------");

             Optional<Integer> optional = persons.stream()
                     .map(Person :: getAge)
                     .reduce(Integer :: sum);
             System.out.println(optional.get());
         }

         //收集
         @Test
         public void test4(){
             List<String> list = persons.stream()
                     .map(Person :: getName)
                     .collect(Collectors.toList());
             list.forEach(System.out :: println);
             System.out.println("------------");

             Set<String> set = persons.stream()
                     .map(Person :: getName)
                     .collect(Collectors.toSet());
             set.forEach(System.out :: println);
             System.out.println("------------");

             HashSet<String> hashSet = persons.stream()
                     .map(Person :: getName)
                     .collect(Collectors.toCollection(HashSet :: new));
             hashSet.forEach(System.out :: println);
         }

         @Test
         public void test5(){
             Long count = persons.stream()
                     .collect(Collectors.counting());
             System.out.println("总人数="+count);
             System.out.println("----------------");

             //平均值
             Double avg = persons.stream()
                     .collect(Collectors.averagingInt(Person :: getAge));
             System.out.println("平均年龄="+avg);
             System.out.println("---------------");

             //总和
             Integer sum = persons.stream()
                     .collect(Collectors.summingInt(Person :: getAge));
             System.out.println("年龄总和="+sum);
             System.out.println("----------------");

             //最大值
             Optional<Person> max = persons.stream()
                     .collect(Collectors.maxBy((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge())));
             System.out.println("最大年龄是"+max.get());
             System.out.println("----------------");

             //最小值
             Optional<Person> min = persons.stream()
                     .collect(Collectors.minBy((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge())));
             System.out.println("最小年龄是"+min.get());
         }

         //分组
         @Test
         public void test6(){
             Map<Status, List<Person>> map = persons.stream()
                     .collect(Collectors.groupingBy(Person :: getStatus));//根据年龄层分组
             System.out.println(map);
         }

         //多级分组
         @Test
         public void test7(){
             Map<Status, Map<String, List<Person>>> map = persons.stream()
                     .collect(Collectors.groupingBy(Person :: getStatus ,Collectors.groupingBy((e) -> {
                         if (e.getId()%2 == 1) {
                             return "单号";
                         } else {
                             return "双号";
                         }
                     })));
             System.out.println(map);
         }

         //分区
         @Test
         public void test8(){
             Map<Boolean, List<Person>> map = persons.stream()
                     .collect(Collectors.partitioningBy((e) -> e.getAge() > 30));
             System.out.println(map);
         }

         //IntSummaryStatistics
         @Test
         public void test9(){
             IntSummaryStatistics iss = persons.stream()
                     .collect(Collectors.summarizingInt(Person :: getAge));
             System.out.println(iss.getSum());
             System.out.println(iss.getAverage());
             System.out.println(iss.getMax());
         }

         @Test
         public void test10(){
             String str = persons.stream()
                     .map(Person :: getName)
                     .collect(Collectors.joining(",","人员名单：","等"));
             System.out.println(str);
         }
     }

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。 
Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

  /**
      * FrokJoin框架
      */
     public class ForkJoinCalculate extends RecursiveTask<Long>{
         private static final long serialVersionUID = 1L;

         private long start;
         private long end;

         private static final long THRESHOLD = 10000;

         public ForkJoinCalculate() {

         }

         public ForkJoinCalculate(long start, long end) {
             this.start = start;
             this.end = end;
         }

         @Override
         protected Long compute() {
             long length = end - start ;
             if (length <= THRESHOLD) {
                 long sum = 0;
                 for (long i = start; i <= end; i++) {
                     sum += i;
                 }
                 return sum;
             }else {
                 long middle = (start + end) / 2;
                 ForkJoinCalculate left = new ForkJoinCalculate();
                 left.fork();//拆分子任务，同时压入线程队列

                 ForkJoinCalculate right = new ForkJoinCalculate();
                 right.fork();
                 return left.join() + right.join();
             }
         }

     }

测试并行流

  public class TestForkJoin {

         /**
          * FrokJoin框架
          */
         @Test
         public void test1(){
             Instant start = Instant.now();

             ForkJoinPool pool = new ForkJoinPool();
             ForkJoinTask<Long> task = new ForkJoinCalculate(0,10000000000L);
             Long sum = pool.invoke(task);
             System.out.println(sum);

             Instant end = Instant.now();
             System.out.println(Duration.between(start,end).toMillis());
         }

         /**
          * for循环
          */
         @Test
         public void test2(){
             Instant start = Instant.now();
             long sum = 0L;

             for (long i = 0; i <= 10000000000L; i++) {
                 sum += i;
             }
             System.out.println(sum);

             Instant end = Instant.now();
             System.out.println(Duration.between(start, end).toMillis());
         }

         /**
          * Java8并行流
          */
         @Test
         public void test3(){
             Instant start = Instant.now();
             LongStream.rangeClosed(0, 10000000000L)
                         .parallel()
                         .reduce(0,Long :: sum);
             Instant end = Instant.now();
             System.out.println(Duration.between(start, end).toMillis());
         }
     }

接口中的默认方法与静态方法

接口中的默认方法

Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。 
接口默认方法的”类优先”原则 
若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时 
- 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。 
- 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突。

接口中的静态方法

Java8 中，接口中允许添加静态方法。

   public interface MyInterface {

         default String getName(){
             return "接口测试";
         }

         public static void show(){
             System.out.println("接口中的静态方法");
         }
     }

新时间日期 API

LocalDate、LocalTime、LocalDateTime

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

传统写法：

  public class DateFormatThreadLocal {

         private static final ThreadLocal<DateFormat> tl = new ThreadLocal<DateFormat>(){
             protected DateFormat initialValue() {
                 return new SimpleDateFormat("yyyyMMdd");
             }
         };

         public static Date convert(String source) throws ParseException{
             return tl.get().parse(source);
         }
     }       

     public static void main(String[] args) throws InterruptedException, ExecutionException {
 //      SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

         Callable<Date> callable = new Callable<Date>() {

             @Override
             public Date call() throws Exception {
 //              return sdf.parse("20170521");
                 return DateFormatThreadLocal.convert("20170521");
             }

         };
         ExecutorService pool = Executors.newFixedThreadPool(10);
         List<Future<Date>> results = new ArrayList<>();
         for (int i = 0; i < 8; i++) {
             results.add(pool.submit(callable));
         }
         for (Future<Date> future : results) {
             System.out.println(future.get());
         }

         //关闭资源
         pool.shutdown();
     }

新特性：

  public static void main(String[] args) throws InterruptedException, ExecutionException {
         DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
         Callable<LocalDate> callable = new Callable<LocalDate>() {

             @Override
             public LocalDate call() throws Exception {
                 return LocalDate.parse("20170521",dtf);
             }

         };
         ExecutorService pool = Executors.newFixedThreadPool(10);
         List<Future<LocalDate>> results = new ArrayList<>();
         for (int i = 0; i < 8; i++) {
             results.add(pool.submit(callable));
         }
         for (Future<LocalDate> future : results) {
             System.out.println(future.get());
         }

         //关闭资源
         pool.shutdown();
 }

LocalDate LocalTime LocalDateTime

  //1.LocalDate LocalTime LocalDateTime
     @Test
     public void test1(){
         LocalDateTime ldt = LocalDateTime.now();
         System.out.println(ldt);

         LocalDateTime ldt2 = LocalDateTime.of(2017, 05, 21, 21, 43, 55, 33);
         System.out.println(ldt2);

         LocalDateTime ldt3 = ldt.plusYears(3);
         System.out.println(ldt3);

         LocalDateTime ldt4 = ldt.minusMonths(5);
         System.out.println(ldt4);
     }

Instant 时间戳

用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算。

   //2.Instant
     @Test
     public void test2(){
         Instant now = Instant.now();
         System.out.println(now);

         OffsetDateTime atOffset = now.atOffset(ZoneOffset.ofHours(6));
         System.out.println(atOffset);

         Instant ins = Instant.ofEpochSecond(60);
         System.out.println(ins);
     }

Duration 和 Period

• Duration:用于计算两个“时间”间隔

• Period:用于计算两个“日期”间隔

   //3.Duration
   @Test
   public void test3(){
       Instant now = Instant.now();
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       Instant now2 = Instant.now();
       //计算时间差
       Duration duration = Duration.between(now, now2);
       System.out.println(duration.getSeconds());
       System.out.println("----------------");
  
       LocalTime lt1 = LocalTime.now();
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       LocalTime lt2 = LocalTime.now();
       System.out.println(Duration.between(lt1, lt2).toMillis());
   }
  
   //4.Period
   @Test
   public void test4(){
       LocalDate ld1 = LocalDate.of(2017, 1, 1);
       LocalDate ld2 = LocalDate.now();
       Period period = Period.between(ld1, ld2);
       System.out.println(period.getYears());
       System.out.println(period.getMonths());
       System.out.println(period.getDays());
   }

日期的操作

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

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

   //5.TemporalAdjuster:时间校正器
   @Test
   public void test5(){
       LocalDateTime ldt = LocalDateTime.now();
       System.out.println(ldt);
  
       LocalDateTime ldt2 = ldt.withDayOfMonth(8);
       System.out.println(ldt2);
  
       LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
       System.out.println(ldt3);
  
       //自定义
       LocalDateTime ldt5 =  ldt.with((l) -> {
           LocalDateTime ldt4 = (LocalDateTime) l;
           DayOfWeek dow = ldt4.getDayOfWeek();
           if (dow.equals(DayOfWeek.FRIDAY)) {
               return ldt4.plusDays(3);
           }else if (dow.equals(DayOfWeek.SATURDAY)) {
               return ldt4.plusDays(2);
           } else {
               return ldt4.plusDays(1);
           }
       });
       //下个工作日
       System.out.println(ldt5);
   }

1

解析与格式化

java.time.format.DateTimeFormatter 类 
该类提供了三种格式化方法： 
- 预定义的标准格式 
- 语言环境相关的格式 
- 自定义的格式

  //DateTimeFormatter:格式化时间/日期
     @Test
     public void test6(){
         DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
         LocalDateTime ldt = LocalDateTime.now();

         System.out.println(ldt);
         String format = ldt.format(dtf);
         System.out.println(format);
         System.out.println("------------");
         DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
         String format2 = dtf2.format(ldt);
         System.out.println(format2);

         LocalDateTime ldt2 = ldt.parse(format2,dtf2);
         System.out.println(ldt2);
     }

时区的处理

Java8 中加入了对时区的支持，带时区的时间为分别为： 
ZonedDate、ZonedTime、ZonedDateTime 
其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式 
例如 ：Asia/Shanghai 等 
ZoneId：该类中包含了所有的时区信息 
- getAvailableZoneIds() : 可以获取所有时区时区信息 
- of(id) : 用指定的时区信息获取 ZoneId 对象

  //ZonedDate ZoneTime ZoneDateTime
     @Test
     public void test7(){
         LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
         System.out.println(ldt);

         LocalDateTime ldt2 = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
         ZonedDateTime zdt = ldt2.atZone(ZoneId.of("Asia/Shanghai"));
         System.out.println(zdt);
     }

与传统日期处理的转换

其他新特性

HashMap

HashMap:减少碰撞,位置相同时,条件达到链表上超过8个,总数超过64个时,数据结构改为红黑树。

ConcurrentHashMap:取消锁分段，与HashMap相同，达到条件时，数据结构改为红黑树。

Optional 类

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。 
常用方法： 
- Optional.of(T t) : 创建一个 Optional 实例 
- Optional.empty() : 创建一个空的 Optional 实例 
- Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例 
- isPresent() : 判断是否包含值 
- orElse(T t) : 如果调用对象包含值，返回该值，否则返回t 
- orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值 
- map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty() 
- flatMap(Function mapper):与 map 类似，要求返回值必须是Optional

 /**
      * Optional类
      */
     public class TestOptional {

         @Test
         public void test1(){
             //参数不能为空
             Optional<Person> op = Optional.of(new Person());

             Person person = op.get();
             System.out.println(person);
         }

         @Test
         public void test2(){
             //构建空optional
             Optional<Person> op = Optional.empty();
             System.out.println(op.get());
         }

         @Test
         public void test3(){
             //如果为null，调用empty，如果不为null，调用of
             Optional<Person> op = Optional.ofNullable(null);
     //      Optional<Person> op = Optional.ofNullable(new Person());
             if (op.isPresent()) {
                 System.out.println(op.get());
             }

             //有值就用值，没值就替代
             Person person = op.orElse(new Person("张三", 23));
             System.out.println(person);
         }
     }

重复注解与类型注解

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

  @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
     @Retention(RetentionPolicy.RUNTIME)
     public @interface MyAnnotations {

         MyAnnotation[] value();
     }

     @Repeatable(MyAnnotations.class)
     @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ElementType.TYPE_PARAMETER})
     @Retention(RetentionPolicy.RUNTIME)
     public @interface MyAnnotation {

         String value() default "aric";
     }

     /**
      * 重复注解与类型注解
      */
     public class TestAnnotation {

         @MyAnnotation("hello")
         @MyAnnotation("test")
         public void show(@MyAnnotation("a") String str){
             System.out.println(str);
         }
     }