Stream流操作===“集合”===收集方法collect

一:java8中集合有两个方法来生成流
1：stream（） --为集合创建串行流
2：parallelStream() − 为集合创建并行流。
代码举例：

List<String> strings = Arrays.asList("sks", "","bc", "eg", "acd","", "jk");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

打印结果：

[sks, bc, eg, acd, jk]

代码解析：
1: 将集合对象转化为流对象
2：使用filter过滤出来符合条件的子集合
3：使用Stream流的收集方法collect负责收集流，将collect(Collectors.toList()收集为List。
二：collect是什么？

collect是Stream中强大的终端操作,使用其几乎能得到你想要的任意数据的聚合

三：collect中的方法：

1.1求值
Collectors.maxBy和Collectors.minBy，来计算流中的最大或最小值。参数为Comparator。

Optional<A> max = Stream.of(new A(4),new A(2),new A(8)).collect(maxBy(comparing(A::getNum)));
Optional<A> min = Stream.of(new A(4),new A(2),new A(8)).collect(minBy(comparing(A::getNum)));
max.ifPresent(a->System.out.println(a.getNum()));
min.ifPresent(a->System.out.println(a.getNum()));

Collectors.summingInt
。求和，输出int 。还有summingLong和SummingDouble方法。

int sum = Stream.of(new A(4),new A(2),new A(8)).collect(summingInt(A::getNum));<!--输出14-->

Collectors.averagingInt 求平均值。还有averagingLong和averagingDouble。

Double ave = Stream.of(new A(4),new A(2),new A(8)).collect(averagingInt(A::getNum));

summarizingInt方法返回的值中包含了最大值，最小值，和，平均值，数量。还有summarizingLong和summarizingDouble。

  IntSummaryStatistics iss = Stream.of(new A(4),new A(2),new A(8)).collect(summarizingInt(A::getNum));

1.2连接字符串
joining工厂方法返回的收集器会把对流中每一个对象应用toString方法得到的所有字符串连接成一个字符串。joining参数为分隔符。

List<String> list = Arrays.asList("hello","world","stream");
String s = list.stream().collect(joining(", "));

      reducing方法，可以有初始值，转换函数，累加函数。

List<A> list = Arrays.asList(new A(5),new A(2),new A(3));
int i = list.stream().collect(reducing(0, A::getNum,(a,b)->a+b));

2.分组
Collectors.groupingBy可以用于分组。返回Map类型。参数为function。还有个重载方法参数为Function和Collector，Collector参数就是对前面分完组的内容进行操作。

List<A> list = Arrays.asList(new A("tom",22),new A("james",22),new A("jack",3));
Map<String, List<A>> map1 = list.stream().collect(groupingBy(A::getName));

  多级分组：

List<A> list = Arrays.asList(new A("tom",22),new A("tom",15),new A("jack",3));
Map<String, Map<String,List<A>>> map2 = list.stream().collect(
        groupingBy(A::getName,groupingBy(a->{if(a.getAge()<18)return "child";
                            else return "adult";})));

  判断每个分组有多少数量：

List<A> list = Arrays.asList(new A("tom",22),new A("tom",15),new A("jack",3));
Map<String, Long> map2 = list.stream().collect(
        groupingBy(A::getName,counting()));

  得到每个分组年龄最大的那个人：

List<A> list = Arrays.asList(new A("tom",22),new A("tom",15),new A("jack",3));
Map<String, Optional<A>> map2 = list.stream().collect(
        groupingBy(A::getName,maxBy(comparing(A::getAge))));

Collectors.collectingAndThen 方法可以把结果转换为另一种类型。参数为collector和function。

    List<A> list = Arrays.asList(new A("tom",22),new A("tom",15),new A("jack",3));
    Map<String, A> map2 = list.stream().collect(
            groupingBy(A::getName,collectingAndThen(maxBy(comparing(A::getAge)), Optional::get)));
  mapping方法参数为function和Collector。

    List<A> list = Arrays.asList(new A("tom",22),new A("tom",15),new A("jack",3));
    Map<String, HashSet<Integer>> map2 = list.stream().collect(
            groupingBy(A::getName,mapping(A::getAge, toCollection(HashSet::new))));
  Collectors返回集合的方法有toList(),toSet(),toMap(),toConcurrentMap()方法。

3.分区
分区就是分组的特殊情况，分区的键值为boolean类型。参数为predicate。还有一个重载方法参数为predicate和Collector。

List<A> list = Arrays.asList(new A("tom",22),new A("tom",15),new A("jack",3));
Map<Boolean,List<A>> map2 = list.stream().collect(partitioningBy(a->a.getAge()>18));

 分区的好处在于保留了true和false的两套列表。

4.Collector接口
Collector接口：

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
    Set<Characteristics> characteristics();
}

T为收集对象的泛型，A是累加器的类型，

累加器是在收集过程中用于累积部分结果的对象。 R是返回对象的类型。

supplier方法定义累加器类型。
accmulator方法把元素添加到累加器。
combiner方法合并两个结果容器。
finisher方法把累加器转为结果容器。
characteristics方法定义收集器行为，比如流是否可以并行归约，以及可以使用那些优化。

5.并行流

    可以用parallelStream方法把集合转为并行流。并行流就是把内容分为几个数据块然后用不同的线程去执行这些数据块。这样就可以使用多核处理器的所有内核。

parallel()方法可以把流转为并行流。sequential()方法可以把并行流转为顺序流。

 使用并行流的建议：
1.并行流不一定比顺序流快，需要检查流的性能。
2.最好不要装箱拆箱，可以的话使用IntStream这样的流。
3.有些操作并行流就会比顺序流慢，比如findFirst等等需要元素顺序的。
4.考虑流的操作在流水线的总计算成本 ，N为元素总数，Q为元素在流水线中的处理成本，Q越大用并行流的效率可能更高。

5. 小的数据量不要用并行流。
6.考虑流背后的数据结构是否易于分解。数组就比较好分解，链表就不好分解，range方法产生的流比较好分解，iterate不好分解。