java 8之stream流
Java 8中添加了一个新的功能称为Stream流，可以通过使用一种声明的方式处理数据。Stream 流使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
1. 什么是流
如果把集合作为流的数据源,创建流时不会导致数据流动; 如果流的终止操作需要值时,流就会从集合中获取值; 流只使用一次。流的中心思想就是延迟计算,流直到需要时才计算值。
Stream可以由数组或集合创建，对流的操作分为两种：
- 中间操作，每次返回一个新的流，可以有多个。
- 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。
2. Stream总览
直接上思维导图，清晰明了。
xmind文件下载
3.Stream详解
3.1 Stream的分类
可以创建普通的Stream流和特定的Stream流。
/**
* stream的分类
*/
// 普通流
List<String> list1 = Arrays.asList("1", "2", "3");
Stream<String> stream1 = list1.stream();
List<Integer> list2 = Arrays.asList(1, 2, 3);
Stream<Integer> stream2 = list2.stream();
// 特化流
IntStream stream3 = IntStream.of(1, 2, 3);
stream3.forEach(System.out::println);
也可以创建stream和 parallelStream，stream是顺序流，由主线程按顺序对流执行操作，而 parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。并且只有当数据量比较大时，我们使用并行流才具备优势。
// 串行
Stream<String> stream4 = Stream.of("1", "2", "3");
// 并行
// 1.
Stream<String> parallelStream1 = list1.parallelStream();
parallelStream1.forEach(System.out::print);
// 2.
Stream<String> parallelStream2 = list1.stream().parallel();
两者的主要区别：
3.2 Stream的创建
通过使用 java.util.Collection.stream() 方法用集合创建流，使用 java.util.Arrays.stream(T[]array)方法用数组创建流。
List<String> list = Arrays.asList("1", "2", "3");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
int[] array={1, 2, 3};
IntStream stream = Arrays.stream(array);
通过使用 Stream的静态方法：of()、iterate()、generate()
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate((int)Math.random(), (x) -> x + 1).limit(4);
stream2.forEach(System.out::println);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);
通过使用Stream的builder()方法创建构建器，通过构建器创建stream流。
Stream.Builder<String> builder = Stream.builder();
builder.add("1");
builder.add("2");
builder.add("3");
Stream<String> stream4 = builder.build();
stream4.forEach(System.out::print);
3.3 Stream的使用
使用stream流之前，我们先来理解一个概念：Optional类。
3.3.1 Optional类
Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。因此，Optional 类的引入很好的解决空指针异常。
ofNullable方法
//为指定的值创建Optional对象，不管所传入的值为null不为null，创建的时候都不会报错
Optional<String> Optional1 = Optional.ofNullable(null);
Optional<String> Optional2 = Optional.ofNullable("picacho");
ifPresent方法
String str = "picacho";
Optional<String> optional = Optional.ofNullable(str);
// 如果值不是为空的，那么就可以直接在这个里面来进行处理
optional.ifPresent(s -> System.out.println(str+"hello"));
orElse方法
Optional<Object> empty = Optional.empty();
System.out.println(empty.orElse("hello"));
3.3.2 遍历/匹配（foreach/find/match）
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
// 遍历输出符合条件的元素
list.stream().filter(x -> x > 3).forEach(System.out::println);
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 3).findFirst();
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 3).findAny();
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x < 2);
System.out.println("匹配第一个值：" + findFirst.get());
System.out.println("匹配任意一个值：" + findAny.get());
System.out.println("是否存在大于6的值：" + anyMatch);
3.3.3 过滤（filter）
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("zhangsan", 8, 3000));
personList.add(new Person("lisi", 18, 5000));
personList.add(new Person("wangwu", 28, 7000));
personList.add(new Person("sunliu", 38, 9000));
// 筛选出年龄大于18
List<Person> personList1 = personList.stream().filter(x -> x.getAge() > 18).collect(Collectors.toList());
personList1.forEach(System.out::println);
3.3.4 聚合（max/min/count）
List<String> list = Arrays.asList("123", "1234", "12345", "12");
Comparator<? super String> comparator = Comparator.comparing(String::length);
Optional<String> max = list.stream().max(comparator);
System.out.println(max.get());
Optional<String> min = list.stream().min(comparator);
System.out.println(min.get());
long count = list.stream().filter(x -> x.length() > 3).count();
System.out.println(count);
3.3.5 映射（map/flatMap）
map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
// 将姓名大写
List<String> list1 = personList.stream().map(person -> person.getName().toUpperCase())
.collect(Collectors.toList());
System.out.println(list1);
// 工资涨1000
List<Person> list2 = personList.stream().map(person -> {
person.setAccount(person.getAccount() + 1000);
return person;
}).collect(Collectors.toList());
System.out.println(list2);
// 将两个字符数组合并称一个新的字符数组
String[] arr = {"z, h, a, n, g", "s, a, n"};
List<String> collect = Arrays.stream(arr).flatMap(x -> {
String[] array = x.split(",");
Stream<String> streamTmp = Arrays.stream(array);
return streamTmp;
}).collect(Collectors.toList());
System.out.println(collect);
3.3.6 collect
Collectors提供了一系列用于数据统计的静态方法：
计数： count
平均值： averagingInt、 averagingLong、 averagingDouble
最值： maxBy、 minBy
求和： summingInt、 summingLong、 summingDouble
//统计员工人数
Long count1 = personList.stream().collect(Collectors.counting());
//求平均工资
Double average = personList.stream().collect(Collectors.averagingDouble(Person::getAccount));
//求最高工资
Optional<Integer> max1 = personList.stream().map(Person::getAccount).collect(Collectors.maxBy(Integer::compare));
//求工资之和
Integer sum = personList.stream().collect(Collectors.summingInt(Person::getAccount));
//一次性统计所有信息
DoubleSummaryStatistics collect1 = personList.stream().collect(Collectors.summarizingDouble(Person::getAccount));
System.out.println("统计员工人数:"+count);
System.out.println("求平均工资:"+average);
System.out.println("求最高工资:"+max);
System.out.println("求工资之和:"+sum);
System.out.println("一次性统计所有信息:"+collect1);
3.3.7 收集（toList/toSet/toMap）
// 取出大于18岁的员工转为map
Map<String, Person> collect3 = personList.stream().filter(x -> x.getAge() > 18).collect(Collectors.toMap(Person::getName, y -> y));
System.out.println(collect3);
3.3.8 规约（reduce）
归约，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
List<Integer> list3 = Arrays.asList(1, 2, 3, 4);
//求和
Optional<Integer> reduce = list3.stream().reduce((x,y) -> x + y);
System.out.println("求和:"+reduce.get());
//求最大值
Optional<Integer> reduce3 = list3.stream().reduce((x,y) -> x > y ? x : y);
System.out.println("求最大值:"+reduce3.get());
3.3.9 连接（joining()）
joining可以将stream中的元素用特定的连接符（默认直接连接）连接成一个字符串。
String names = personList.stream().map(person -> person.getName()).collect(Collectors.joining("-"));
System.out.println(names);
3.3.10 分组（partitioningBy/groupingBy）
分区：将stream按条件分为两个 Map。
分组：将集合分为多个Map。
List<Person> personList3 = new ArrayList<Person>();
personList3.add(new Person("zhangsan", 18, 3000));
personList3.add(new Person("lisi", 18, 5000));
personList3.add(new Person("wangwu", 28, 7000));
personList3.add(new Person("sunliu", 38, 9000));
// 将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> part = personList3.stream().collect(Collectors.partitioningBy(x -> x.getAccount() > 8000));
// 将员工先按年龄分组，再按工资分组
Map<Integer, Map<String, List<Person>>> group = personList3.stream().collect(Collectors.groupingBy(Person::getAge, Collectors.groupingBy(Person::getName)));
System.out.println("员工按薪资是否大于8000分组情况：" + part);
System.out.println("员工按性别、地区：" + group);
3.3.11 排序（sorted）
// 按工资升序排序（自然排序）
List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getAccount)).map(Person::getName)
.collect(Collectors.toList());
// 按工资倒序排序
List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getAccount).reversed())
.map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄升序排序
List<String> newList3 = personList.stream()
.sorted(Comparator.comparing(Person::getAccount).thenComparing(Person::getAge)).map(Person::getName)
.collect(Collectors.toList());
// 先按工资再按年龄自定义排序（降序）
List<String> newList4 = personList.stream().sorted((p1, p2) -> {
if (p1.getAccount() == p2.getAccount()) {
return p2.getAge() - p1.getAge();
} else {
return p2.getAccount() - p1.getAccount();
}
}).map(Person::getName).collect(Collectors.toList());
System.out.println("按工资升序排序：" + newList);
System.out.println("按工资降序排序：" + newList2);
System.out.println("先按工资再按年龄升序排序：" + newList3);
System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
3.3.12 提取/组合（concat()\distinct()\limit()\skip()）
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream11 = Stream.of(arr1);
Stream<String> stream12 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> newList11 = Stream.concat(stream11, stream12).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> collect11 = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip：跳过前n个数据
List<Integer> collect12 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("流合并：" + newList11);
System.out.println("limit：" + collect11);
System.out.println("skip：" + collect12);
Sream流还有很多更高级的用法，需要多看API，多练习来掌握该类的使用。在项目中使用该类可以使得代码更加精炼和美观。