java8 新特性

1 Lambda表达式

• lambda 是一个匿名函数，

lambda 表达式基本语法： java8中引入了一个新的操作符：-> lambda 操作符。

结构分为两部分：

• 左侧：lambda表达式的参数列表
• 右侧：Lambda表达式中需要执行的功能， lambda体

语法格式

• 语法格式一： 无参数，无返回值
  • () -> {}， 例如： Runnable
• 语法格式二： 一个参数，无返回值， 小括号可以省略不写
  • (x) -> {}, 例如： Consumer，
• 语法格式三：有两个以上参数，有返回值， 如果只有一条语句， return和大括号可以省略不写
  • (x, y) -> {return }, 例如：Comparator
• 语法格式六：lambda的参数列表的数据类型可以省略， 因为JVM编译器通过上下文推断出，数据类型，即“类型推断”。

上联：左右遇一括号省,

下联：左侧推断类型省

横批： 能省则省

lambda表达式需要函数式接口支持。

2 函数式接口

函数式接口： 接口中只有一个抽象方法的接口， 可以使用 @FunctionalInterface 修饰。

2.1 java核心函数式接口

• Consumer<T>: 消费型接口

  • void accept(T t); :accept:

  //Consumer<T> 消费型接口
  @Test
  public void test1() {
     happy(1000, x -> System.out.println("吃饭花了" + x + "元"));
  }
  public void happy(double money, Consumer<Double> consumer) {
     consumer.accept(money);
  }
  

• Supplier<T>： 供给型接口

  • T get();

      @Test
      public void test2() {
          List<Integer> list = getNumberlist(10, () -> (int) (Math.random() * 100));
          list.forEach(System.out::println);
      }
      //需求：产生指定一些整数， 并放入集合中
      public List<Integer> getNumberlist(int num, Supplier<Integer> supplier) {
          List<Integer> list = new ArrayList<>();
  
          for (int i = 0; i < num; i++) {
              list.add(supplier.get());
          }
          return list;
      }
  

• Function<T, R> : 函数型接口

  • R apply(T t);

      //Function<T,R>  函数型接口
      @Test
      public void test3() {
          System.out.println(getLength("ddd", x -> x.length()));
      }
      public Integer getLength(String str, Function<String, Integer> function) {
          return function.apply(str);
      }
  

• Predicate<T>: 断言型接口

  • boolean test(T t)

      @Test
      public void test4() {
          List<String> list = Arrays.asList("aaa", "bbb", "aa");
          List<String> filterList = filter(list, x -> x.length() > 2);
          filterList.forEach(System.out::println);
      }
      public List<String> filter(List<String> list, Predicate<String> predicate) {
          List<String> list1 = new ArrayList<>();
          for (String s : list) {
              if (predicate.test(s)) {
                  list1.add(s);
              }
          }
          return list1;
      }
  

2.2 java 其他函数式接口

函数式接口通过一个单一的功能来表现。例如，带有单个compareTo方法的比较接口，被用于比较的场合。Java 8 开始定义了大量的函数式接口来广泛地用于lambda表达式。

BiFunction<Integer, Integer, Employee> bf1 = (x, y) -> new Employee(x, y);  //返回第三个参数
BiPredicate<String, String> bp = (x, y) -> x.equals(y);  //返回 boolean

3 :black_nib:引用

3.1 方法引用

:notebook:语法格式

• 对象:: 实例方法名:

Consumer<String> con = (x) -> System.out.println(x);
Consumer<String> consumer = System.out::print;

• 类::静态方法名

Supplier<Double> supplier = Math::random;

• 类:: 实例方法名

BiPredicate<String, String> bp = (x, y) -> x.equals(y);
BiPredicate<String, String> bp1 = String::equals;

• lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致。
• 若 lambda 参数列表中的第一参数是实例方法的调用者， 而第二个参数是实例方法的参数时,可以使用 ClassName::method

3.2 构造器引用

格式：

• ClassName::new

实例：

• 无参数的构造器引用

//lambda
Supplier<Employee> sup = () -> new Employee();
//构造器引用
Supplier<Employee> sup2 = Employee::new;

• 一个参数的构造器引用

//lambda
Function<Integer, Employee> function = x -> new Employee(x);
function.apply(111);
// 有1个参数的构造器引用
Function<Integer, Employee> function1 = Employee::new;
function1.apply(101);  // return new Employee(101)

• 有2个参数的构造器引用

BiFunction<Integer, Integer, Employee> bf1 = (x, y) -> new Employee(x, y);
// 有2个参数的构造器引用
BiFunction<Integer, Integer, Employee> bf = Employee::new;
bf.apply(10, 1000);  //return new Employee(10, 1000);

注意： 需要调用的构造器参数列表要与函数式接口中抽象方法的参数列表保持一致。

3.3 数组引用

语法格式：

• Type::new

//lambda
Function<Integer, String[]> function = (x) -> new String[x];
String[] apply = function.apply(10);

//数组引用
Function<Integer, String[]> function1 = String[]::new;
String apply1 = function1.apply(10);  //new String[10]

4. :artificial_satellite:Stream API

Stream API (java.util.stream.*)

4.1 创建 Stream 流

1. 通过 Collection 的 stream(串行) 方法或者 parallelStream(并行) 方法创建集合流

Stream<String> stream = list.stream();
Stream<String> stringStream = list.parallelStream();

2. 通过 Arrays 的静态方法 stream 获取数组流

Employee[] employees = new Employee[10];
Stream<Employee> stream1 = Arrays.stream(employees);

3. 通过 Stream 类的静态方法of获取流

Stream<String> stream = Stream.of("aa", "bb", "cc");

4. 创建无限流

   1. 迭代

      Stream<Integer> stream = Stream.iterate(0, x -> x + 2);
      

   2. 生成

      Stream<Double> stream2 = Stream.generate(() -> Math.random());
      

4.2 中间操作

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

筛选与切片

映射

map 和 flatMap 类似于 List 的 add方法和 addAll 方法

排序

Comparator<String> comparator = (x,y) ->  x.length() - y.length();
        list.stream()
                .sorted(comparator)
                .forEach(System.out::println);

4.3 终止操作

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

查找和匹配

• Optional

Optional<Employee> op = employees.stream()
                .sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary()))
                .findFirst(); //有可能为空就返回 Optional
System.out.println(op.get());

规约

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
Integer sum = list.stream().reduce(0, (x, y) -> x + y);

map 和 reduce 的连接通常称为 map-reduce 模式, 因 Google 用它来进行网络搜索而出名。

收集

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

        //转化为 List
        List<String> list = employees.stream().map(Employee::getUsername).collect(Collectors.toList());
        //转化为 Set
        Set<Double> set = employees.stream().map(Employee::getSalary).collect(Collectors.toSet());
        //转化为 HashSet
        HashSet<String> set1 = employees.stream().map(Employee::getUsername).collect(Collectors.toCollection(HashSet::new));
        //转化为 LinkedBlockingQueue
        LinkedBlockingQueue<Employee> queue = employees.stream().collect(Collectors.toCollection(LinkedBlockingQueue::new));
        //元素总数
        Long sum = employees.stream().collect(Collectors.counting());
        //工资平均值
        Double avg = employees.stream().collect(Collectors.averagingDouble(Employee::getSalary));
        //总和
        Double sum1 = employees.stream().collect(Collectors.summingDouble(Employee::getSalary));
        //最大值
        Optional<Employee> max = employees.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        //最小值
        Optional<Employee> min = employees.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        //分组
        Map<Employee.Status, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(map);
        //字符串拼接
        String str = employees.stream().map(Employee::getUsername).collect(Collectors.joining(","));
        System.out.println(str);
        //多级分组
        Map<Employee.Status, Map<String, List<Employee>>> map1 = employees.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(x -> x.getAge() > 30 ? "青年" : "少年")));
        System.out.println(map1);
        //分区
        Map<Boolean, List<Employee>> map2 = employees.stream().collect(Collectors.partitioningBy(x -> x.getAge() > 33));
        //一次得到最大值，最小值，平均值...
        DoubleSummaryStatistics summary = employees.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(summary.getMax());

5 :musical_note:并行流和串行流

并行流就是把一个内容分成多个数据块， 并用不同的线程分别处理每个数据块的流。

java8 中将并行进行了优化， 我们可以很容易的对数据进行并行操作。``Stream API可以声明性地通过parallel()与sequential()` 在并行流与顺序流之间进行切换。

5.1 fork/join 框架

Fork/Join 框架： 就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总 。（类似于分治算法）

[图片上传失败...(image-119780-1583213642769)]

和线程池区别

采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上。在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态。而在fork/join框架实现中,如果
某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。这种方式减少了线程的等待时间,提高了性能 。

fork/join 使用例子

public class ForkJoinCalcalue extends RecursiveTask<Long> {
    private long start;
    private long end;

    private static final long THRESHOLD = 10000;

    public ForkJoinCalcalue(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 mid = start + ((end - start) >> 1);
            ForkJoinCalcalue left = new ForkJoinCalcalue(start, mid);
            //拆分子任务，同时压入线程队列
            left.fork();
            ForkJoinCalcalue right = new ForkJoinCalcalue(mid + 1, end);
            right.fork();
            //合并
            return left.join() + right.join();
        }
    }
}

//调用
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinCalcalue(0, 100000000000L);
Long sum = pool.invoke(task);

在java8后，对其进行了简化，java8的并行流底层就是 fork/join, 简化代码：

OptionalLong sum = LongStream.rangeClosed(0, 100000000000L)
                .parallel()
                .reduce(Long::sum);

6 Optional 类

Optional<T> 类(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  

7 默认方法和静态方法

Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。

接口默认方法的” 类优先” 原则

若一个接口中定义了一个默认方法，而另外一个父类或接口中
又定义了一个同名的方法时。

• 选择父类中的方法。如果一个父类提供了具体的实现，那么
  接口中具有相同名称和参数的默认方法会被忽略。
• 接口冲突。如果一个父接口提供一个默认方法，而另一个接
  口也提供了一个具有相同名称和参数列表的方法（不管方法
  是否是默认方法）， 那么必须覆盖该方法来解决冲突

关于作者： ziftness
github: https://github.com/zfitness
博客: https://zfitness.github.io/