1 生成流（Stream）

在 Java 8 中, 集合接口有两个方法来生成流：

• stream() − 为集合创建串行流。
• parallelStream() − 为集合创建并行流。

// stream(): 将strings List进行流化
// filter(): 过滤处理，过滤规则为strings的元素不为空，即为空的从流中被剔除
// collect(): 重新进行collect收集转成List。
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().
  filter(string -> !string.isEmpty()).
  collect(Collectors.toList());

输出：

[abc, bc, efg, abcd, jkl]

Process finished with exit code 0

1.1 forEach方法

Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。

//  forEach类似JAVA之前的for(String $ : strings)。
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        strings.stream().forEach($ -> System.out.println($));

输出：

abc

bc
efg
abcd

jkl

Process finished with exit code 0

1.2 map方法

map 方法用于映射每个元素到对应的结果。

 List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        /***
         * map():相当于元素别名 -> 元素新值，value必须是和List中一致的泛型
         */
        strings.stream()
                .map($ -> $+$)
                .forEach($-> System.out.println($));

输出：

abcabc

bcbc
efgefg
abcdabcd

jkljkl

Process finished with exit code 0

1.3 filter方法

filter 方法用于通过设置的条件过滤出元素。

// stream(): 将strings List进行流化
// filter(): 过滤处理，过滤规则为strings的元素不为空，即为空的从流中被剔除
// collect(): 重新进行collect收集转成List。
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().
  filter(string -> !string.isEmpty()).
  collect(Collectors.toList());

输出：

[abc, bc, efg, abcd, jkl]

Process finished with exit code 0

1.4 limit方法

limit 方法用于获取指定数量的流。

 List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd","", "jkl");
        /***
         * limit(number):相当于for(int i=0;i<number;i++)
         */
        strings.stream()
                .map($ -> $+$)
                .limit(2)
                .forEach($-> System.out.println($));

输出：

abcabc
bcbc

Process finished with exit code 0

1.5 sorted方法

sorted 方法用于对流进行排序。

List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd","", "jkl");
        /***
         * sorted():正序排序
         * sorted(Comparator.reverseOrder()):倒序排序，也可在sorted()里自定义排序方法
         */
        strings.stream().sorted()
                .forEach($-> System.out.println($));
        System.out.println("-----------分割线----------");
        strings.stream().sorted(Comparator.reverseOrder())
                .forEach($-> System.out.println($));

输出：

abc
abcd
bc
efg
jkl
-----------分割线----------
jkl
efg
bc
abcd
abc


Process finished with exit code 0

1.6 Collectors 聚合

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。

 List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd","", "jkl");
 System.out.println(strings.stream()
             .filter(s -> !s.equals(""))
             .collect(toList()));
 System.out.println(strings.stream()
             .collect(joining(",")));

输出：

[abc, bc, efg, abcd, jkl]
abc,bc,efg,abcd,,jkl

Process finished with exit code 0

1.7 统计函数

另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt(x->x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

输出：

列表中最大的数 : 7
列表中最小的数 : 2
所有数之和 : 25
平均数 : 3.5714285714285716

Process finished with exit code 0

1.8 reduce方法

reduce:(T identity,BinaryOperator)/reduce(BinaryOperator)-可以先设置初始值，并将流中元素反复结合起来，得到一个值。

 List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
System.out.println(numbers.stream().limit(3).reduce(0,(x,y)->x+y));

输出：

7

Process finished with exit code 0

2 灵活的运用

2.1 简单的List转Map

List<Integer> nums = Lists.newArrayList(1,2,3,1,10,2,3,10,10);

Map<Integer,Integer> map2 =  nums.stream().distinct().map(num -> {
    return new ImmutablePair<Integer,Integer>(num,1);
}).collect(Collectors.toMap(pair -> pair.left,pair -> pair.right));
System.out.println(map2);

================================
{1=1, 2=1, 3=1, 10=1}

2.2 统计元素出现的次数

List<Integer> nums = Lists.newArrayList(1,2,3,1,10,2,3,10,10);

// 统计nums每个元素出现的次数
Map<Integer,Integer> map = Maps.newHashMap();
nums.stream().forEach(pair->{
    map.compute(
             pair,(key, val) -> val = (val==null ? 1 : val+1)
    );
});
System.out.println(map);
------------------------------------------------
{1=2, 2=2, 3=2, 10=3}

Process finished with exit code 0

2.3 将map转成同等val数量的key元素list

// 将map中的key val转成同等val数量的key
Map<Integer,Integer> map1 = Maps.newHashMap();
map1.put(10,2);
map1.put(3,1);
map1.put(7,2);

List list = map1.entrySet().stream().map(entry -> {
    return IntStream.range(0, entry.getValue()).mapToObj($ -> entry.getKey()).collect(Collectors.toList());
}).flatMap(Collection::stream).collect(toList());
========================================
[3, 7, 7, 10, 10]