http://blog.itpub.net/9399028/viewspace-2674082/ 新特性
image.png

1.Lambda表达式

  1. /**
  2.  * Lambda表达式 针对函数式接口，接口中只有一个方法时
  3.  */
  4. public class LambdaTest {
  6.     @Test
  7.     public void test1() {
  8.         Runnable r1 = new Runnable() {
  9.             @Override
  10.             public void run() {
  11.                 System.out.println("非lambda写法");
  12.             }
  13.         };
  15.         // -> lambda操作符
  16.         Runnable r2 = (() -> {
  17.             System.out.println("lambda写法");
  18.         });
  20.         //
  21.         // -> lambda操作符  省去 最外层的() 
  22.         Runnable r3 = () -> System.out.println("lambda写法");
  24.         r1.run();
  25.         r2.run();
  26.     }
  28.     @Test
  29.     public void test2() {
  30.         //比较器
  31.         Comparator<Integer> com = new Comparator<Integer>() {
  32.             @Override
  33.             public int compare(Integer o1, Integer o2) {
  34.                 return o1-o2;
  35.             }
  36.         };
  38.         Comparator<Integer> com1 = (o1, o2) -> {
  39.             return o1 - o2;
  40.         };
  42.          //省去 {} 省去return 原理 函数式接口，内部本就知道是否有返回值
  43.         Comparator<Integer> com2 = (o1, o2) -> o1 - o2;
  45.         // //方法引用 更简洁
  46.         Comparator<Integer> com2 = Integer :: compare;
  48.     }
  49. }

lambda表达式的使用

1. 举例 (o1,o2) -> Integer.compare(o1,o2)

2. 格式

  1. ->:lambda操作符或箭头操作符
  2. ->:左边 lambda形参列表 (接口中抽象方法的形参)
  3. ->:右边 lambda体 (重写的抽象方法的方法体)

    3. 使用(分为6种情况)

    其实分为：
    左边()是否可以省去，
    右边{}是否可以省去
    1.无参，无返回值，
    2.只有一个参数，
    3.两个以上参数，
    4.方法体两条以上，
    5.方法体只有一条。
    1. //语法格式1 无参 无返回值
    2. Runnable r1 = new Runnable() {
    3.   @Override
    4.   public void run() {
    5.       System.out.println("非lambda写法");
    6.   }
    7. };
    8. // -> lambda操作符
    9. Runnable r2 = () -> System.out.println("lambda写法");
    1. //语法格式二： 需要一个参数 没有返回值
    2.   Consumer<String> con = new Consumer<String>() {
    3.       @Override
    4.       public void accept(String s) {
    5.           System.out.println(s);
    6.       }
    7.   };
    8.   con.accept("con");
    9.   Consumer<String> con1 = (String s) -> System.out.println(s);
    10.   con1.accept("con1");

    4. lambda表达式的本质：作为函数式接口的实例 (函数式接口)

    2.函数式(Functional)接口

  • 如果一个接口种只声明了一个抽象方法，就称为函数式接口Runable CompareTo
  • 可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常(即:非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明)。
  • 我们可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明说明这个接口是一个函数式接口。
  • 在java.util.function包下定义了Java8的丰富的函数式接口 ```java

@FunctionalInterface
public interface MyInterface { void method(); }

  1. <a name="9KXgW"></a>
  2. ### 1.内置四大核心函数式接口
  3. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21994224/1625211466837-6ec59516-8e13-45d5-bed7-5461abe7c06e.png#align=left&display=inline&height=250&margin=%5Bobject%20Object%5D&name=image.png&originHeight=286&originWidth=597&size=129371&status=done&style=none&width=521) 
  4. ```java
  5. //示例
  6. public class FunctionTest {
  8.     @Test
  9.     public void test1() {
  10.         happyTime(66.66,(d) -> System.out.println("消费"+d));
  11.     }
  13.     public void happyTime(double money, Consumer<Double> consumer) {
  14.         consumer.accept(money);
  15.     }
  16. }
  1.     //断定型接口示例
  2.     @Test    
  3.     public void test2() {
  4.       List<String> newList = filterString(Arrays.asList("123456","156","486","DASD","DASDW"), s -> s.contains("A"));
  5.       newList.forEach(System.out::println);
  6.     }
  8.     public List<String> filterString(List<String> stringList, Predicate<String> predicate){
  9.         List<String> filter = new ArrayList<>();
  10.         for (String s : stringList) {
  11.             if (predicate.test(s)) {
  12.                 filter.add(s);
  13.             }
  14.         }
  15.         return filter;
  16.     }

2.其他接口

image.png

3.方法引用与构造器引用

3.1介绍

  • 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用!
  • 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法,可以认为是Lambda表达式的一个语法糖。
  • 要求:实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致!
  • 格式:使用操作符“::”将类(或对象)与方法名分隔开来。

  • 如下三种主要使用情况:

    1. 对象:∵实例方法名
    2. 类:静态方法名

    3. 类:实例方法名

      3.2使用情景

      当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用(引用别人的方法)!
      方法引用使用的要求:要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同!(针对情况a，b)

      3.3使用格式

      使用格式： 类(或对象) :: 方法名

      3.4示例

      对象::示例方法名

      1. //情况一 对象::实例方法
      2. //consumer中的void accept(T t)
      3. //PrintStream 中void println(T t)
      4. @Test
      5. public void test1() {
      6.   Consumer<String> con1 = str -> System.out.println(str);
      7.   con1.accept("输出");
      8.   System.out.println("********************");
      9.   PrintStream ps = System.out;
      10.   Consumer<String> con2 = ps::println;    
      11.   con2.accept("方法引用输出");
      12. }
      14. //supplier 中 T get()
      15. //Employee中String getName()
      16. @Test
      17. public void test2() {
      18.   Employee employee = EmployeeData.getEmployees().get(0);
      19.   Supplier<String> sup1 = () ->  employee.getName() ;
      20.   System.out.println(sup1.get());
      21.   //方法引用
      22.   Supplier<String> sup2 = employee::getName;
      23.   System.out.println(sup2.get());
      24. }

      类::静态方法

      1. //情况二: 类::静态方法
      2. //Comparator中 compare(t1,t2)
      3. //Integer  中compare(t1,t2)
      4. @Test
      5. public void test3() {
      6.   Comparator<Integer> com1 = (c1,c2) -> Integer.compare(c1,c2);
      7.   com1.compare(12,2);
      8.   //方法引用
      9.   Comparator<Integer> com2 = Integer::compare;
      10.   com2.compare(27,93);
      11. }

      类::实例方法

      ```java //情况三: 类::实例方法 难 传入的参数调用类中的方法 //Comparator compare(T t1,T t2) //String compareTo(T t2) @Test public void test4() { Comparator com1 = (s1,s2) -> s1.compareTo(s2); System.out.println(com1.compare(“abc”,”adb”)); System.out.println(“**“); Comparator com2 = String::compareTo; System.out.println(com2.compare(“abc”,”abd”)); }

      //BigPredicate中 boolean test(T t1,T t2); //String中的boolean t1.equals(t2) @Test public void test5() { BiPredicate pre1 = (s1,s2) -> s1.equals(s2); System.out.println(pre1.test(“avc”,”avc”)); System.out.println(“*“); BiPredicate pre2 = String::equals; System.out.println(pre2.test(“avc”,”avc”)); }

      //Function 中R apply(T t) //Employee String getName(); @Test public void test7() { Function f1 = e -> e.getName(); System.out.println(f1.apply( EmployeeData.getEmployees().get(0))); System.out.println(“*“); Function f2 = Employee::getName; System.out.println(f2.apply( EmployeeData.getEmployees().get(0))); }

  1. <a name="Dj7zr"></a>
  2. ### 3.5构造器引用
  3. 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致<br />抽象方法的返回值类型即为构造器所属类的类型
  4. ```java
  5. //构造器引用
  6.     //Supplier中T get()
  7.     //空参构造器
  8.     @Test
  9.     public void test1() {
  10.         Supplier<Employee> sup1 = () -> new Employee();
  11.         Employee e1 = sup1.get();
  12.         Supplier<Employee> sup2 = Employee::new;
  13.         Employee e2 = sup2.get();
  14.     }
  16.     //Function 中R apply(T t)
  17.     @Test
  18.     public void test2() {
  19.         Function<Integer,Employee>  func1 =  id -> new Employee(id);
  20.         Employee e1 = func1.apply(1);
  21.         Function<Integer,Employee>  func2 = Employee::new;
  22.         Employee e2 = func2.apply(2);
  23.     }
  24.   //BiFunction 中R apply(T t,R r)
  25.     @Test
  26.     public void test3() {
  27.         BiFunction<Integer,String,Employee> fun1 = (id,name) -> new Employee(id,name);
  28.         Employee e1 = fun1.apply(1,"a");
  29.         BiFunction<Integer,String,Employee> fun2 = Employee::new;
  30.         Employee e2 = fun2.apply(2,"b");
  31.     }

3.6数组引用

数组看作是类 写法和构造器相似一致

  1.    //数组引用
  2.     //Function中的R apply(T t)
  3.     @Test
  4.     public void test4() {
  5.         //返回指定长度数组
  6.         Function<Integer,String[]> func1 = length -> new String[length];
  8.         Function<Integer,String[]> func2 = String[]::new;
  9.     }

4.强大的Stream API

使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。
Collection是一种静态的内存数据结构，Stream是有关计算的。
Stream不会改变源对象，相反，会返回一个持有结果的新的Stream
必须有终止操作，否则不会执行中间链

1.四种创建方式：

  • 通过集合
  • 通过数组
  • 通过Stream的of()方法

  • 创建无限流

    1. /**
    2. * stream关注对数据的运算
    3. * 操作是延迟执行的， 只有执行终止操作 中间操作才会执行
    4. * 终止操作后，不可再执行中间操作链 需要再新建stream
    5. * 实例化
    6. * 一系列中间操作  一条链
    7. * 终止操作
    8. */
    9. public class StreamAPITest {
    11. //创建Stream方式一  通过集合
    12. @Test
    13. public void test1() {
    14.    List<Employee> employees = EmployeeData.getEmployees();
    15.    // default Stream<E> stream(); 返回一个顺序流
    16.    Stream<Employee> stream = employees.stream();
    18.    //default Stream<E> parallelStream(); 返回一个并行流
    19.    Stream<Employee> employeeStream = employees.parallelStream();
    20. }
    22. //方式二： 通过数组
    23. @Test
    24. public void test2() {
    25. //        Arrays.stream(T[] array)
    26.    Integer[] a  = {1,2,3,4,5};
    27.    Stream<Integer> stream = Arrays.stream(a);
    28. //自定义数组
    29.    Employee e1 = new Employee(1001,"张叁",23,3399);
    30.    Employee e2 = new Employee(1002,"李肆",24,9444);
    31.    Employee e3 = new Employee(1003,"王伍",25,5555);
    32.    Employee e4 = new Employee(1004,"赵陆",26,96435);
    33.    Employee e5 = new Employee(1005,"周柒",27,77777);
    35.    Employee[] arr1 = new Employee[]{e1,e2,e3,e4,e5};
    36.    Stream<Employee> stream1 = Arrays.stream(arr1);
    37. }
    39. //方式三 通过Stream的of()方法
    40. @Test
    41. public void test3() {
    42.    Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
    43. }
    45. //方式四 创建无限流
    46. @Test
    47. public void test4() {
    48. //        迭代
    49. //        public static<T> Stream<T> iterate(final T seed,final Unaryoperator<T> f)
    50.    //遍历前10各偶数
    51.    Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
    52. //        生成
    53. //        public static<T> Stream<T> generate(Supplier<T> s)
    54.    Stream.generate(Math::random).limit(10).forEach(System.out::println);
    55. }

    2.stream的中间操作

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

    1.筛选和切片

    image.png

    1. //1-筛选切片
    2. @Test
    3. public void test1() {
    4.    List<Employee> employees = EmployeeData.getEmployees();
    5.    //查询员工表中工资大于7000的
    6.    //执行终止操作后stream流会被关闭 无法再次使用
    7.    List<Object> objects = Arrays.asList(employees.stream().filter(t -> t.getSalary() > 7000).toArray());
    8.    System.out.println(objects);
    9. //        filter(Predicate p)——接收Lambda ,从流中排除某些元素。
    10. //        limit(n)——截断流,使其元素不超过给定数是。
    11.    employees.stream().limit(3).forEach(System.out::println);
    12.    System.out.println("===========");
    13. //        skip(n)——跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
    14.    employees.stream().skip(3).forEach(System.out::println);
    15.    System.out.println("===========");
    16. //        distinct()——筛选，通过流所生成元素的hashCode()和equals()去除重复元素
    17.    employees.stream().distinct().forEach(System.out::println);
    18. }

    2.映射

    image.png

    1. //2-映射
    2. @Test
    3. public void test2() {
    4. //      map(Function f) 接收一个函数作为参数，将元素转换成其他形式获取提取信息，该函数会被应用到每个元素上，并将其映射成一个新元素
    5.    List<String> strings = Arrays.asList("c", "s", "aa", "dd");
    6.    strings.stream().map(String::toUpperCase).forEach(System.out::println);
    7. //      可以筛选元素中的某一条属性
    8.    List<Employee> employees = EmployeeData.getEmployees();
    9.    List<String> names = employees.stream().map(Employee::getName).collect(Collectors.toList());
    10.    System.out.println(names);
    11. //        示例1获取员工姓名长度大于2的名称
    12.    Stream<Employee> employeeStream = employees.stream().filter(Employee::nameLength);
    13.    List<String> namess = employeeStream.map(Employee::getName).collect(Collectors.toList());
    14.    System.out.println(namess);
    15.    System.out.println("===========");
    16. //      示例二
    17. //      此map方法将解析后的元素作为整体存入stream流中
    18.    Stream<Stream<Character>> streamStream = strings.stream().map(StreamAPITest2::fromStringToStream);
    19.    streamStream.forEach(s -> s.forEach(System.out::println));
    20.    System.out.println("=============");
    21. //      flatMap(function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
    22. //      将处理后的stream流进一步解析 相当于平铺开
    23.    Stream<Character> characterStream = strings.stream().flatMap(StreamAPITest2::fromStringToStream);
    24.    characterStream.forEach(System.out::println);
    25. }
    26. //  将字符串中的多个字符构成的集合转换为对应的Stream的实例
    27. public static Stream<Character> fromStringToStream(String str) {
    28.    ArrayList<Character> list =new ArrayList<>();
    29.    for (Character c : str.toCharArray()) {
    30.        list.add(c);
    31.    }
    32.    return list.stream();
    33. }

3.排序

image.png

  1. //  3.排序
  2.     @Test
  3.     public void test3() {
  4. //        sorted()自然排序
  5.         List<Integer> list = Arrays.asList(12,15,6,7,60,16);
  6.         List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
  7.         System.out.println(collect);
  8.         System.out.println("===========");
  9. //        sorted(Comparator com)定制排序 需要传入比较器
  10.         List<Employee> employees = EmployeeData.getEmployees();
  11.         employees.stream().sorted(new MyComparator()).forEach(System.out::println);
  12. //        lambda表达式
  13.         employees.stream().sorted((e1,e2) -> (e2.getId() - e1.getId())).forEach(System.out::println);
  14.     }

3.stream的终止操作

1.匹配与查找

image.png
image.png
外部迭代 iterator

  1. //    1-匹配与查找
  2.     @Test
  3.     public void test1() {
  4.         List<Employee> employees = EmployeeData.getEmployees();
  5. //        allMatch(Predicate p) -- 检查是否匹配所有元素
  6. //        是否所有员工的年龄都大于18
  7.         boolean b = employees.stream().allMatch(e -> e.getAge() > 18);
  8.         System.out.println(b);
  9.         System.out.println("==============");
  10. //        anyMatch(Predicate p)- 检查是否至少匹配一个元素。
  11. //        是否存在员工工资大于7000
  12.         boolean b1 = employees.stream().anyMatch(e -> e.getSalary() > 7000);
  13.         System.out.println(b1);
  14.         System.out.println("==============");
  15. //        noneMatch(Predicate p)一检查是否没有匹配的元素。
  16. //        是否存在无姓员工
  17.         boolean b2 = employees.stream().noneMatch(e -> e.getName().startsWith("李"));
  18.         System.out.println(b2);
  19.         System.out.println("==============");
  20. //        findFirst-返回第一个元素
  21.         Optional<Employee> first = employees.stream().findFirst();
  22.         Employee employee = first.get();
  23.         System.out.println(employee);
  24.         System.out.println("==============");
  25. //        findAny- -返回当前流中的任意元素  并行流
  26.         Employee employee1 = employees.parallelStream().findAny().get();
  27.         System.out.println(employee1);
  28.         System.out.println("==============");
  29. //        count-返回流 中元素的总个数
  30.         long count = employees.stream().filter(e -> e.getSalary() > 7000).count();
  31.         System.out.println(count);
  32. //        max(Comparator c)一返回流中最大值
  33. //        练习:返回最高的工资:
  34.         Optional<Employee> max = employees.stream().max((e1, e2) -> Double.compare(e1.getSalary(),e2.getSalary()));
  35.         System.out.println(max);
  36. //        min(Comparator c)一返回流中最小值
  37. //        练习:返回最低_工资的员工
  38.         Optional<Double> min = employees.stream().map(Employee::getSalary).min(Double::compareTo);
  39.         System.out.println(min);
  40.         System.out.println("==============");
  41. //        forEach(Consumer c)- -内部迭代
  42.         employees.stream().forEach(System.out::println);
  45.     }
  47.     @Test
  48.     public void testtt() {
  49.         List<Employee> employees = EmployeeData.getEmployees();
  50.         for (int i =0;i<20;i++) {
  51.             Employee employee1 = employees.stream().findAny().get();
  52.             System.out.println(employee1);
  53.         }
  54.     }

2.归约

image.png
备注: map和 reduce 的连接通常称为map-reduce 模式，因Google
用它来进行网络搜索而出名。

  1. //    2.归约
  2.     @Test
  3.     public void test2() {
  4. //        reducp(T identity, BinaryOperator)- - 可以将流中元素反复结合起来，得到一个值。返回一个T
  5. //        练习1.计算1-10的自然数的和
  6.         List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
  7. //        第一个参数 初始值
  8.         Integer reduce = list.stream().reduce(1, Integer::sum);
  9.         System.out.println(reduce);
  10. //        reduce(BinaryOperator)一可以将流中元素反复结合起来， 得到一个值。返回Option<T>
  11. //        练习2:计算公司所有员工工资的总和
  12.         List<Employee> employees = EmployeeData.getEmployees();
  13.         Optional<Double> reduce1 = employees.stream().map(Employee::getSalary).reduce(Double::sum);
  14.         System.out.println(reduce1);
  15.         System.out.println(reduce1.get());
  16.     }

3.收集

image.png
Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set.Map)。
另外，Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，
具体方法与实例如下表:
image.png

  1. //    3.收集
  2.     @Test
  3.     public void test3() {
  4.         List<Employee> employees = EmployeeData.getEmployees();
  5. //        collect(Collector c)将 流转换为其他形式。接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
  6. //      练习 查找工资大于7000的员工 存入list中
  7.         List<Employee> collect = employees.stream().filter(e -> e.getSalary() > 7000).collect(Collectors.toList());
  8.         collect.forEach(System.out::println);
  9.     }

5.Option类

●Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
●创建Optional类对象的方法:
➢Optional.of(T t): 创建一个Optional实例，t必须非空;
➢Optional.empty(): 创建一个空的 Optional实例
➢Optional.ofNullable(T t): t 可以为nullI

  1.   @Test
  2.     public void test1() {
  3.         Girl girl = new Girl();
  4.         girl = null;
  5.         //t 不能为空
  6.         Optional<Girl> optionalGirl = Optional.of(girl);
  7.     }
  9.     @Test
  10.     public void test2() {
  11.         Girl girl = new Girl();
  12. //        girl = null;
  13.         Optional<Girl> optionalGirl = Optional.ofNullable(girl);
  14.         System.out.println(optionalGirl);
  15.     }

●判断Optional容 器中是否包含对象:
➢boolean isPresent() :判断是否包含对象
➢void ifPresent(Consumer<? super T> consumer):如果有值，就执行Consumer
接口的实现代码，并且该值会作为参数传给它。
●获取Optional容 器的对象:
➢T get):如果调用对象包含值，返回该值，否则抛异常
➢T orElse(T other):如果有值则将其返回，否则返回指定的other对象。
➢T orElseGet(Supplier<? extends T> other) :如果有值则将其返回，否则返回由
Supplier接口实现提供的对象。
➢T orElse Throw(Supplier<? extends X> exceptionSupplier):如果有值则将其返
回，否则抛出由Supplier接口实现提供的异常。

  1. @Test
  2.     public void test3() {
  3. //        Boy boy = new Boy();
  4. //        String girlName = getGirlName(boy);
  5. //        System.out.println(girlName);
  7.         Boy boy1 = new Boy();
  8.         System.out.println(getGirlName1(null));
  9.     }
  11.     //优化
  12.     public String getGirlName1(Boy boy) {
  13. //        没有optional时
  14. //        if (null != boy) {
  15. //            Girl girl = boy.getGirl();
  16. //            if (null !=girl) {
  17. //                return girl.getName();
  18. //            }
  19. //        }
  20. //        return null;
  21. //        使用optional
  22.         Optional<Boy> boyOptional = Optional.ofNullable(boy);
  23.         Boy boy1 = boyOptional.orElse(new Boy());
  24.         Optional<Girl> girlOptional = Optional.ofNullable(boy1.getGirl());
  25.         Girl girl = girlOptional.orElse(new Girl());
  26.         return girl.getName();
  27.     }


6.StringJoiner

StringJoiner是Java8新出的一个类，用于构造由分隔符分隔的字符序列，并可选择性地从提供的前缀开始和以提供的后缀结尾。

  1. java.lang.String
  2. java.lang.StringBuffer
  3. java.lang.StrungBuilder

三者共同之处:都是final类,不允许被继承，主要是从性能和安全性上考虑的，因为这几个类都是经常被使用着，且考虑到防止其中的参数被参数修改影响到其他的应用。

  • StringBuffer是线程安全，可以不需要额外的同步用于多线程中;
  • StringBuilder是非同步,运行于多线程中就需要使用着单独同步处理，但是速度就比StringBuffer快多了;
  • StringBuffer与StringBuilder两者共同之处:可以通过append、indert进行字符串的操作。
  • String实现了三个接口:Serializable、Comparable、CarSequence
  • StringBuilder只实现了两个接口Serializable、CharSequence，相比之下String的实例可以通过compareTo方法进行比较，其他两个不可以。

    示例：

    ```java StringJoiner sj = new StringJoiner(“:”, “[“, “]”); sj.add(“George”).add(“Sally”).add(“Fred”); String desiredString = sj.toString();

[George:Sally:Fred]

  1. ```java
  2. package java.util;
  4. public final class StringJoiner {
  5.     private final String prefix;//前缀
  6.     private final String delimiter;//间隔符
  7.     private final String suffix;//后缀
  8.     private StringBuilder value;//值
  10.     private String emptyValue;//空值
  12.     public StringJoiner(CharSequence delimiter) {
  13.         this(delimiter, "", "");//默认前缀和后缀为"",重载调用
  14.     }
  16.     public StringJoiner(CharSequence delimiter,
  17.                         CharSequence prefix,
  18.                         CharSequence suffix) {
  19.         //间隔符，前缀和后缀判断是否为null，null将抛出异常
  20.         Objects.requireNonNull(prefix, "The prefix must not be null");
  21.         Objects.requireNonNull(delimiter, "The delimiter must not be null");
  22.         Objects.requireNonNull(suffix, "The suffix must not be null"); 
  23.         // 成员变量赋值
  24.         this.prefix = prefix.toString();
  25.         this.delimiter = delimiter.toString();
  26.         this.suffix = suffix.toString();
  27.         this.emptyValue = this.prefix + this.suffix;//空值被设置为只有前后缀
  28.     }
  29.     //设置空值，检查是否为null
  30.     public StringJoiner setEmptyValue(CharSequence emptyValue) {
  31.         this.emptyValue = Objects.requireNonNull(emptyValue,
  32.             "The empty value must not be null").toString();
  33.         return this;
  34.     }
  36.     @Override
  37.     public String toString() {
  38.         if (value == null) {
  39.             return emptyValue;//没有值将返回空值或者后续设置的空值
  40.         } else {
  41.             if (suffix.equals("")) {
  42.                 return value.toString();//后缀为""直接返回字符串，不用添加
  43.             } else {
  44.                 //后缀不为""，添加后缀，然后直接返回字符串，修改长度
  45.                 int initialLength = value.length();
  46.                 String result = value.append(suffix).toString();
  47.                 // reset value to pre-append initialLength
  48.                 value.setLength(initialLength);
  49.                 return result;
  50.             }
  51.         }
  52.     }
  53.     初始化，先添加前缀，有了之后每次先添加间隔符，StringBuilder后续append字符串
  54.     public StringJoiner add(CharSequence newElement) {
  55.         prepareBuilder().append(newElement);
  56.         return this;
  57.     }
  58.     //合并StringJoiner，注意后面StringJoiner 的前缀就不要了，后面的appen进来
  59.     public StringJoiner merge(StringJoiner other) {
  60.         Objects.requireNonNull(other);
  61.         if (other.value != null) {
  62.             final int length = other.value.length();
  63.             // lock the length so that we can seize the data to be appended
  64.             // before initiate copying to avoid interference, especially when
  65.             // merge 'this'
  66.             StringBuilder builder = prepareBuilder();
  67.             builder.append(other.value, other.prefix.length(), length);
  68.         }
  69.         return this;
  70.     }
  71.     //初始化，先添加前缀，有了之后每次先添加间隔符
  72.     private StringBuilder prepareBuilder() {
  73.         if (value != null) {
  74.             value.append(delimiter);
  75.         } else {
  76.             value = new StringBuilder().append(prefix);
  77.         }
  78.         return value;
  79.     }
  81.     public int length() {
  82.         // Remember that we never actually append the suffix unless we return
  83.         // the full (present) value or some sub-string or length of it, so that
  84.         // we can add on more if we need to.
  85.         //不忘添加后缀的长度
  86.         return (value != null ? value.length() + suffix.length() :
  87.                 emptyValue.length());
  88.     }
  89. }


7.接口新增：默认方法与静态方法

8.最新的Date/Time API (JSR 310)

1、LocalDate/LocalTime/LocalDateTime

  • LocalDate为日期处理类、LocalTime为时间处理类、LocalDateTime为日期时间处理类，方法都类似，具体可以看API文档或源码，选取几个代表性的方法做下介绍。

  • now相关的方法可以获取当前日期或时间，of方法可以创建对应的日期或时间，parse方法可以解析日期或时间，get方法可以获取日期或时间信息，with方法可以设置日期或时间信息，plus或minus方法可以增减日期或时间信息；

    2 、TemporalAdjusters

  • 这个类在日期调整时非常有用，比如得到当月的第一天、最后一天，当年的第一天、最后一天，下一周或前一周的某天等。

    3、DateTimeFormatter

  • 以前日期格式化一般用SimpleDateFormat类，但是不怎么好用，现在1.8引入了DateTimeFormatter类，默认定义了很多常量格式（ISO打头的），在使用的时候一般配合LocalDate/LocalTime/LocalDateTime使用，比如想把当前日期格式化成yyyy-MM-dd hh:mm:ss的形式:

    1. // String -->LocalDateTime
    2.       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"); // 12小时
    3. 　　　　 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); // 24小时      
    4.       LocalDate localDate = LocalDate.parse("2019-12-07 07:43:53",formatter);
    6.       System.out.println(localDate);
    7.       System.out.println(localTime);
    8.       System.out.println(localDate);

9.新增base64加解密API

10.数组并行（parallel）操作

11.JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）

ALL

  1.  /*
  2.  JDK8新特性
  3.   */
  4.  public class JDK8_features {
  6.      public List<Integer> list = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
  8.      /**
  9.       * 1.Lambda表达式
  10.       */
  11.      @Test
  12.      public void testLambda(){
  13.          list.forEach(System.out::println);
  14.          list.forEach(e -> System.out.println("方式二："+e));
  15.      }
  17.      /**
  18.       * 2.Stream函数式操作流元素集合
  19.       */
  20.      @Test
  21.      public void testStream(){
  22.          List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
  23.          System.out.println("求和："+nums
  24.                  .stream()//转成Stream
  25.                  .filter(team -> team!=null)//过滤
  26.                  .distinct()//去重
  27.                  .mapToInt(num->num*2)//map操作
  28.                  .skip(2)//跳过前2个元素
  29.                  .limit(4)//限制取前4个元素
  30.                  .peek(System.out::println)//流式处理对象函数
  31.                  .sum());//
  32.      }
  34.      /**
  35.       * 3.接口新增：默认方法与静态方法
  36.       *  default 接口默认实现方法是为了让集合类默认实现这些函数式处理，而不用修改现有代码
  37.       *  （List继承于Iterable<T>，接口默认方法不必须实现default forEach方法）
  38.       */
  39.      @Test
  40.      public void testDefaultFunctionInterface(){
  41.          //可以直接使用接口名.静态方法来访问接口中的静态方法
  42.          JDK8Interface1.staticMethod();
  43.          //接口中的默认方法必须通过它的实现类来调用
  44.          new JDK8InterfaceImpl1().defaultMethod();
  45.          //多实现类，默认方法重名时必须复写
  46.          new JDK8InterfaceImpl2().defaultMethod();
  47.      }
  49.      public class JDK8InterfaceImpl1 implements JDK8Interface1 {
  50.          //实现接口后，因为默认方法不是抽象方法，重写/不重写都成！
  51.  //        @Override
  52.  //        public void defaultMethod(){
  53.  //            System.out.println("接口中的默认方法");
  54.  //        }
  55.      }
  57.      public class JDK8InterfaceImpl2 implements JDK8Interface1,JDK8Interface2 {
  58.          //实现接口后，默认方法名相同，必须复写默认方法
  59.          @Override
  60.          public void defaultMethod() {
  61.              //接口的
  62.              JDK8Interface1.super.defaultMethod();
  63.              System.out.println("实现类复写重名默认方法！！！！");
  64.          }
  65.      }
  67.      /**
  68.       * 4.方法引用,与Lambda表达式联合使用
  69.       */
  70.      @Test
  71.      public void testMethodReference(){
  72.          //构造器引用。语法是Class::new，或者更一般的Class< T >::new，要求构造器方法是没有参数；
  73.          final Car car = Car.create( Car::new );
  74.          final List< Car > cars = Arrays.asList( car );
  75.          //静态方法引用。语法是Class::static_method，要求接受一个Class类型的参数；
  76.          cars.forEach( Car::collide );
  77.          //任意对象的方法引用。它的语法是Class::method。无参，所有元素调用；
  78.          cars.forEach( Car::repair );
  79.          //特定对象的方法引用，它的语法是instance::method。有参，在某个对象上调用方法，将列表元素作为参数传入；
  80.          final Car police = Car.create( Car::new );
  81.          cars.forEach( police::follow );
  82.      }
  84.      public static class Car {
  85.          public static Car create( final Supplier< Car > supplier ) {
  86.              return supplier.get();
  87.          }              
  89.          public static void collide( final Car car ) {
  90.              System.out.println( "静态方法引用 " + car.toString() );
  91.          }
  93.          public void repair() {   
  94.              System.out.println( "任意对象的方法引用 " + this.toString() );
  95.          }
  97.          public void follow( final Car car ) {
  98.              System.out.println( "特定对象的方法引用 " + car.toString() );
  99.          }
  100.      }
  102.      /**
  103.       * 5.引入重复注解
  104.       * 1.@Repeatable 
  105.       * 2.可以不用以前的“注解容器”写法，直接写2次相同注解即可
  106.       * 
  107.       * Java 8在编译器层做了优化，相同注解会以集合的方式保存，因此底层的原理并没有变化。
  108.       */
  109.      @Test
  110.      public void RepeatingAnnotations(){
  111.          RepeatingAnnotations.main(null);
  112.      }
  114.      /**
  115.       * 6.类型注解
  116.       * 新增类型注解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER（在Target上）
  117.       * 
  118.       */
  119.      @Test
  120.      public void ElementType(){
  121.          Annotations.main(null);
  122.      }
  124.      /**
  125.       * 7.最新的Date/Time API (JSR 310)
  126.       */
  127.      @Test
  128.      public void DateTime(){
  129.          //1.Clock
  130.          final Clock clock = Clock.systemUTC();
  131.          System.out.println( clock.instant() );
  132.          System.out.println( clock.millis() );
  134.          //2. ISO-8601格式且无时区信息的日期部分
  135.          final LocalDate date = LocalDate.now();
  136.          final LocalDate dateFromClock = LocalDate.now( clock );
  138.          System.out.println( date );
  139.          System.out.println( dateFromClock );
  141.          // ISO-8601格式且无时区信息的时间部分
  142.          final LocalTime time = LocalTime.now();
  143.          final LocalTime timeFromClock = LocalTime.now( clock );
  145.          System.out.println( time );
  146.          System.out.println( timeFromClock );
  148.          // 3.ISO-8601格式无时区信息的日期与时间
  149.          final LocalDateTime datetime = LocalDateTime.now();
  150.          final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
  152.          System.out.println( datetime );
  153.          System.out.println( datetimeFromClock );
  155.          // 4.特定时区的日期/时间，
  156.          final ZonedDateTime zonedDatetime = ZonedDateTime.now();
  157.          final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
  158.          final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );
  160.          System.out.println( zonedDatetime );
  161.          System.out.println( zonedDatetimeFromClock );
  162.          System.out.println( zonedDatetimeFromZone );
  164.          //5.在秒与纳秒级别上的一段时间
  165.          final LocalDateTime from = LocalDateTime.of( 2018, Month.APRIL, 16, 0, 0, 0 );
  166.          final LocalDateTime to = LocalDateTime.of( 2019, Month.APRIL, 16, 23, 59, 59 );
  168.          final Duration duration = Duration.between( from, to );
  169.          System.out.println( "Duration in days: " + duration.toDays() );
  170.          System.out.println( "Duration in hours: " + duration.toHours() );
  171.      }
  173.      /**
  174.       * 8.新增base64加解密API
  175.       */
  176.      @Test
  177.      public void testBase64(){
  178.          final String text = "就是要测试加解密！！abjdkhdkuasu!!@@@@";
  179.          String encoded = Base64.getEncoder()
  180.              .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
  181.          System.out.println("加密后="+ encoded );
  183.          final String decoded = new String( 
  184.              Base64.getDecoder().decode( encoded ),
  185.              StandardCharsets.UTF_8 );
  186.          System.out.println( "解密后="+decoded );
  187.      }
  189.      /**
  190.       * 9.数组并行（parallel）操作
  191.       */
  192.      @Test
  193.      public void testParallel(){
  194.          long[] arrayOfLong = new long [ 20000 ];        
  195.          //1.给数组随机赋值
  196.          Arrays.parallelSetAll( arrayOfLong, 
  197.              index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
  198.          //2.打印出前10个元素
  199.          Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
  200.              i -> System.out.print( i + " " ) );
  201.          System.out.println();
  202.          //3.数组排序
  203.          Arrays.parallelSort( arrayOfLong );     
  204.          //4.打印排序后的前10个元素
  205.          Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
  206.              i -> System.out.print( i + " " ) );
  207.          System.out.println();
  208.      }
  210.      /**
  211.       * 10.JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）元空间
  212.       */
  213.      @Test
  214.      public void testMetaspace(){
  215.          //-XX:MetaspaceSize初始空间大小，达到该值就会触发垃圾收集进行类型卸载，同时GC会对该值进行调整
  216.          //-XX:MaxMetaspaceSize最大空间，默认是没有限制
  217.          //-XX:MinMetaspaceFreeRatio在GC之后，最小的Metaspace剩余空间容量的百分比，减少为分配空间所导致的垃圾收集
  218.          //-XX:MaxMetaspaceFreeRatio在GC之后，最大的Metaspace剩余空间容量的百分比，减少为释放空间所导致的垃圾收集
  219.      }
  221.  }
  222.  引用到的相关类：
  223.  public interface JDK8Interface1 {
  225.      //1.接口中可以定义静态方法了
  226.      public static void staticMethod(){
  227.          System.out.println("接口中的静态方法");
  228.      }
  230.      //2.使用default之后就可以定义普通方法的方法体了
  231.      public default void defaultMethod(){
  232.          System.out.println("接口中的默认方法");
  233.      }
  234.  }
  236.  public interface JDK8Interface2 {
  238.      //接口中可以定义静态方法了
  239.      public static void staticMethod(){
  240.          System.out.println("接口中的静态方法");
  241.      }
  242.      //使用default之后就可以定义普通方法的方法体了
  243.      public default void defaultMethod(){
  244.          System.out.println("接口中的默认方法");
  245.      }
  246.  }
  248.  /*
  249.  JDK8新特性
  250.   */
  251.  public class RepeatingAnnotations {
  252.      @Target( ElementType.TYPE )
  253.      @Retention( RetentionPolicy.RUNTIME )
  254.      public @interface Filters {
  255.          Filter[] value();
  256.      }
  258.      @Target( ElementType.TYPE )
  259.      @Retention( RetentionPolicy.RUNTIME )
  260.      @Repeatable( Filters.class )
  261.      public @interface Filter {
  262.          String value();
  263.          String value2();
  264.      };
  266.      @Filter( value="filter1",value2="111" )
  267.      @Filter( value="filter2", value2="222")
  268.      //@Filters({@Filter(  value="filter1",value2="111" ),@Filter(  value="filter2", value2="222")}).注意：JDK8之前：1.没有@Repeatable2.采用本行“注解容器”写法
  269.      public interface Filterable {        
  270.      }
  272.      public static void main(String[] args) {
  273.          //获取注解后遍历打印值
  274.          for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
  275.              System.out.println( filter.value() +filter.value2());
  276.          }
  277.      }
  278.  }
  280.  /* 
  281.  @Description:新增类型注解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER（在Target上）
  282.   */
  283.  public class Annotations {
  284.      @Retention( RetentionPolicy.RUNTIME )
  285.      @Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
  286.      public @interface NonEmpty {        
  287.      }
  289.      public static class Holder< @NonEmpty T > extends @NonEmpty Object {
  290.          public void method() throws @NonEmpty Exception {           
  291.          }
  292.      }
  294.      public static void main(String[] args) {
  295.          final Holder< String > holder = new @NonEmpty Holder< String >();       
  296.          @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();       
  297.      }
  298.  }