JAVA8新特性

一、Lambda表达式

1.方法引用：
若lambda体中的功能已经有方法实现了，如输出内容，如一个对象获取属性，则可以使用方法引用。
注：方法引用参数类型和返回值类型要与函数式接口方法类型一致。
用::操作符分隔方法名与对象或类名，主要有3种格式：

• 对象::实例方法名
• 类::静态方法名
• 类::实例方法名

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

其中，类::实例方法名最为特殊，它要求第一个参数为实例方法的调用者，第二个参数为实例方法的参数。
2.构造器引用
类名::new
此时构造方法的参数应和函数式接口的方法参数一致。
3.数组引用
Type::new
此时，函数式接口方法的参数为数组的长度。

报错：Variable used in lambda expression should be final or effectively final
lambda表达式中使用的外部已定义的变量应该是final或者是有效的final。在Java8之前，匿名类中如果要访问局部变量的话，那个局部变量必须显式的声明为final。而在Java8之后，在匿名类活lambda表达式中访问的局部变量，如果不是final类型的话，编译器自动加上final修饰符。

在lambda表达式中对变量的操作都是基于原变量的副本，不会影响到原变量的值。假定没有要求lambda表达式外部变量为final修饰，那么开发者会误以为外部变量的值能够在lambda表达式中被改变，而这实际是不可能的，所以要求外部变量为final是在编译期以强制手段确保用户不会在lambda表达式中做修改原变量的操作。

ArrayList<String> receivers = new ArrayList<>();
receivers.add("aa");
receivers.stream().forEach(s -> s = "ll");
System.out.println(receivers); // [aa]

二、Stream流

1.java.util.stream.*
2.一个流应该有一个数据源，Stream流的数据源可以是集合、数组等。而Stream流可以在数据在管道中传输时进行一系列流水线式的中间操作。结果是产生一个新的流，而原来的数据源不会发送任何改变。
集合主要是数据，而流主要是计算。
注：Stream不会存储元素。Stream操作是延迟的，它会等到需要结果时才执行。

3.获取一个Stream流的方法
①通过Collection系列集合的stream方法或parallelStream方法获取，前者是顺序流，后者是并行流。
②通过Arrays 的静态方法stream获取流。
③通过Stream类的静态方法of()获取流。
④无限流

4.中间操作
注：没有终止操作前，中间操作不会执行，这就是延迟加载或惰性求值，即终止操作时一次性全部处理所有中间操作。
实战中使用以下方法实际上用的是Stream接口的实现类的方法。
①筛选和切片

Stream<T> filter(Predicate<? super T> predicate); //过滤不符合的元素
Stream<T> limit(long maxSize); //限制结果的数量
Stream<T> skip(long n); //跳过前n个结果，若所有元素仍比n小，则返回空流
Stream<T> distinct(); //去重，通过流内元素的hashcode和equals方法去重

②映射

<R> Stream<R> map(Function<? super T, ? extends R> mapper); //功能与函数式接口功能一致，接收一个T，返回一个R，例如提取员工集合的所有人的工号
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper); //将流中的每一个值变成一个新的流，然后将所有新的流连接成一个流，注意最后结果是一个流，类似集合的addAll方法

③排序

Stream<T> sorted();  //自然排序Comparable
Stream<T> sorted(Comparator<? super T> comparator); //定制排序

5.终止操作
①查找与匹配

boolean allMatch(Predicate<? super T> predicate); //是否所有元素满足条件
boolean anyMatch(Predicate<? super T> predicate); //是否任意一个元素满足条件
boolean noneMatch(Predicate<? super T> predicate); //是否没有元素满足条件
Optional<T> findFirst(); //返回第一个元素
Optional<T> findAny();
long count();  //返回总数量
Optional<T> max(Comparator<? super T> comparator);
Optional<T> min(Comparator<? super T> comparator);

②归约

Optional<T> reduce(BinaryOperator<T> accumulator); 对数据进行反复结合运算
T reduce(T identity, BinaryOperator<T> accumulator);

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

③收集

<R, A> R collect(Collector<? super T, A, R> collector);
stream.collect(Collectors.toList()) //将结果化为一个集合
stream.collect(Collectors.toSet())
stream.collect(Collectors.toCollection(LinkedList::new))
stream.collect(Collectors.counting()) //结果总数
stream.collect(Collectors.averagingInt())
stream.collect(Collectors.groupingBy()) //分组
stream.collect(Collectors.partitioningBy()) //分区，满足条件一个区，不满足条件一个区
stream.collect(Collectors.joining())  //将所有字符串连接起来

分组的使用：

        User user1 = new User();
        User user2 = new User();
        User user3 = new User();
        User user4 = new User();
        List<User> list = new ArrayList<>();
        user1.setId("1");
        user1.setName("zhang");

        user2.setId("2");
        user2.setName("li");

        user3.setId("1");
        user3.setName("zhao");

        user4.setId("3");
        user4.setName("wang");

        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        Map<String, List<User>> collect = list.stream().collect(Collectors.groupingBy(s -> s.getId()));
        System.out.println(collect);

结果：

{1=[User(id=1, name=zhang), User(id=1, name=zhao)], 2=[User(id=2, name=li)], 3=[User(id=3, name=wang)]}

分组可以根据空字符串即""进行分组，但是不能对null进行分组，一旦要分组的值即上面例子的id里有null时会报错：element cannot be mapped to a null key

6.简单遍历

list.forEach(System.out::println)

7.Fork/Join框架
将一个大任务Fork即拆分成一个个小任务，然后将小任务结果Join汇总。
可以多线程处理，所有效率高。
并行流适合处理大量数据，效率更高，速度更快。