ego1st.cn

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

什么是Stream流

Stream 是对集合(Collection)对象功能的增强。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

举个简单的例子：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream()
                               .filter(string -> !string.isEmpty())
                               .collect(Collectors.toList());

上面得到的结果是把strings中不为空的筛选出来；

Stream对数据的处理流程如下所示：

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

如何获得Stream流

在Java8中，有三种方法生成Stream流

通过Collection系列集合提供的stream()和parallelStream()方法获得流
其中通过stream()方法生成的是串行流，通过parallelStream()方法生成的是并行流
```
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Stream<String> stream2 = list.`parallelStream();
```

通过Arrays中的静态方法stream()获得流

Music[] music = new Music[10];
Stream<Music> stream3 = Arrays.stream(music);

通过Stream类中的静态方法of()获得流

Stream<String> stream4 = Stream.of("abc","a","b");

还有两种方法创建无限流

迭代

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

生成

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

讲完了如何获得流，下面我们来讲Stream流的中间操作

Stream流的中间操作

Stream流的中间操作包括：

筛选与切片
映射
排序

首先定义一个Music类

public class Music {
    private String name;
    private String singer;
    private Integer num;
    public Status status;
    
    public enum Status {
        FREE,
        BUSY
    }
    ...
    //get,set,toString,equals,hashCode,构造器省略
}

然后定义一个List<Music>

List<Music> music = Arrays.asList(
        new Music("歌1","手1",1),
        new Music("歌2","手2",20),
        new Music("歌3","手3",30),
        new Music("歌4","手4",40),
        new Music("歌5","手5",50),
        new Music("歌6","手6",60),
        new Music("歌6","手6",70),
        new Music("歌6","手6",60)
);

筛选与切片

filter：接收Lambda，从流中排除某些元素

@Test
public void test1(){
    //内部迭代：迭代操作由Stream API完成
    music.stream()
               .filter((e)->e.getNum()>10)
               .forEach(System.out::println);
}

limit：截断流，使其元素不超过给定数量

@Test
public void test2(){
    //limit操作拿到给定数量的值后，就不再继续执行称为短路操作"
    music.stream()
        .filter((e)->{
                System.out.println("短路!);
                return e.getNum()>10;})
        .limit(2)
        .forEach(System.out::println);
}

skip：跳过元素，返回一个扔掉了前n个元素的流

@Test
public void test3(){
    /// 若流中元素不足n个，则返回一个空流，与limit(n)互补
    music.stream()
            .filter((e)->e.getNum()>10)
            .skip(2)
            .forEach(System.out::println);
}

distinct筛选，通过流生成元素的hashCode()和equals()去除重复元素

@Test
public void test4(){
    music.stream()
            .filter((e)->e.getNum()>10)
            .skip(2)
            .distinct()
            .forEach(System.out::println);

}

映射

map：接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

@Test
public void test5(){
    //把list中的元素转换为大写
     List<String> list = Arrays.asList("aaa","bbb","ccc");
     list.stream()
             .map(s -> s.toUpperCase())
             .forEach(System.out::println);
}

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流

@Test
public void test6(){
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    list.stream()
            .flatMap(StreamLearn2::filterCharater)
            .forEach(System.out::println);

}

public static Stream<Character> filterCharater(String str){
     List<Character> list = new ArrayList<>();

    for (Character ch :
            str.toCharArray()) {
        list.add(ch);
    }
    return list.stream();
}

排序

sorted：自然排序（Comparable）

@Test
public void test7(){
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    list.stream()
            .sorted()
            .forEach(System.out::println);
}

sorted(Comparator com)：定制排序（Comparator）

@Test
public void test8(){
    music.stream()
            .sorted((e1,e2)->{
                if (e1.getName().equals(e2.getName())){
                    return e1.getNum().compareTo(e2.getNum());
                }else {
                    return e1.getName().compareTo(e2.getName());
                }
            })
            .forEach(System.out::println);
}

Stream流的终止操作

Stream流的终止操作包括

查找与匹配
归约
收集

查找与匹配

allMatch：检查是否匹配所有元素，必须全部满足才返回true

@Test
public void test1(){
    boolean b1 = music.stream()
            .allMatch(e->e.getStatus().equals(Music.Status.BUSY));
    System.out.println(b1);
}

anyMatch：检查是否匹配至少一个元素，只要有一个元素满足条件就返回true

@Test
public void test2(){
    boolean b2 = music.stream()
            .anyMatch(e->e.getStatus().equals(Music.Status.BUSY));
    System.out.println(b2);
}

noneMatch：检查是否没有匹配所有元素，全部不满足才返回true

@Test
public void test3(){
    boolean b3 = music.stream()
            .noneMatch(e->e.getStatus().equals(Music.Status.BUSY));
    System.out.println(b3);
}

findFirst：返回第一个元素

@Test
public void test4(){
    Optional<Music> optional = music.stream()
            .sorted((e1, e2) -> e1.getNum().compareTo(e2.getNum()))
            .findFirst();

    System.out.println(optional.get());
}

findAny：返回任意一个元素

@Test
public void test5(){
    Optional<Music> optional = music.stream()
            .filter(e -> e.getStatus().equals(Music.Status.FREE))
            .findAny();

    System.out.println(optional.get());
}

count：返回流元素的总个数

public void test6(){
    long count = music.stream()
            .filter(e -> e.getStatus().equals(Music.Status.FREE))
            .count();

    System.out.println(count);
}

max：返回流中元素的最大值

@Test
public void test7(){
    Optional<Music> max = music.stream()
            .max((e1, e2) -> Integer.compare(e1.getNum(), e2.getNum()));
    System.out.println(max.get());
}

min：返回流中元素的最小值

@Test
public void test8(){
    Optional<Integer> min = music.stream()
            .map(Music::getNum)
            .min(Integer::compare);
    System.out.println(min.get());
}

归约

reduce：可以将流中的元素反复结合起来，得到一个值

Optional<T> reduce(BinaryOperator<T> accumulator)

Optional<Integer> optional = music.stream()
        .map(Music::getNum)
        .reduce(Integer::sum);
System.out.println(optional.get());

可能为null，返回Optional

T reduce(T identity, BinaryOperator<T> accumulator)

Integer reduce = music.stream()
        .map(Music::getNum)
        .reduce(0, (x, y) -> x + y);

起始值为0，返回对应类型

<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);

@Test
public void reduceTest() {
    ArrayList<Integer> newList = new ArrayList<>();

    ArrayList<Integer> accResult_ = Stream.of(2, 3, 4)
            .reduce(newList,
                    (acc, item) -> {
                        acc.add(item);
                        System.out.println("item: " + item);
                        System.out.println("acc+ : " + acc);
                        System.out.println("BiFunction");
                        return acc;
                    }, (acc, item) -> null);
    System.out.println("accResult_: " + accResult_);
}

运行结果：

item: 2
acc+ : [2]
BiFunction
item: 3
acc+ : [2, 3]
BiFunction
item: 4
acc+ : [2, 3, 4]
BiFunction
accResult_: [2, 3, 4]

首先看一下BiFunction的三个泛型类型分别是U、 ? super T、U，参考BiFunction函数式接口apply方法定义可以知道，累加器通过类型为U和? super T的两个输入值计算得到一个U类型的结果返回。也就是说这种reduce方法，提供一个不同于Stream中数据类型的初始值，通过累加器规则迭代计算Stream中的数据，最终得到一个同初始值同类型的结果

收集

collect：将流转化为其他形式。接受一个Collector接口的实现，用于给Stream中元素做汇总的方法

public void collectTest(){
    List<String> collect = music.stream()
            .map(Music::getName)
            .collect(Collectors.toList());

    HashSet<String> collect1 = music.stream()
            .map(Music::getName)
            .collect(Collectors.toCollection(HashSet::new));

    collect.forEach(System.out::println);
    collect1.forEach(System.out::println);
}

运行结果：

歌1
歌2
歌3
歌4
歌5
歌6
歌4
歌5
歌6
歌1
歌2
歌3

groupingBy：分组&多级分组

分组，按照相同的属性进行分组

public void groupTest1(){
    Map<Music.Status, List<Music>> collect = music.stream()
            .collect(Collectors.groupingBy(Music::getStatus));

    System.out.println(collect);
}

运行结果：

{BUSY=[Music{name='歌1', singer='手1', num=1, status=BUSY}, Music{name='歌3', singer='手3', num=30, status=BUSY}, Music{name='歌4', singer='手4', num=40, status=BUSY}], FREE=[Music{name='歌2', singer='手2', num=20, status=FREE}, Music{name='歌5', singer='手5', num=50, status=FREE}, Music{name='歌6', singer='手6', num=60, status=FREE}]}

多级分组，首先按照相同的属性分组，然后再按照条件分，或者还可以按照属性分，嵌套下去

public void groupTest2(){
    Map<Music.Status, Map<String, List<Music>>> collect = music.stream()
        .collect(Collectors.groupingBy(Music::getStatus, 
                Collectors.groupingBy(e -> {
                    if (e.getNum() >= 30) {
                        return "高产";
                    } else {
                        return "低产";
                    }
                })));
    System.out.println(collect);
}

运行结果：

{BUSY={低产=[Music{name='歌1', singer='手1', num=1, status=BUSY}], 高产=[Music{name='歌3', singer='手3', num=30, status=BUSY}, Music{name='歌4', singer='手4', num=40, status=BUSY}]}, FREE={低产=[Music{name='歌2', singer='手2', num=20, status=FREE}], 高产=[Music{name='歌5', singer='手5', num=50, status=FREE}, Music{name='歌6', singer='手6', num=60, status=FREE}]}}

partitioningBy：分区，符合条件的放在一起，不符合条件的放在一起

public void partTest(){
    Map<Boolean, List<Music>> collect = music.stream()
            .collect(Collectors.partitioningBy(e -> e.getNum() > 30));
    System.out.println(collect);
}

运行结果：

{false=[Music{name='歌1', singer='手1', num=1, status=BUSY}, Music{name='歌2', singer='手2', num=20, status=FREE}, Music{name='歌3', singer='手3', num=30, status=BUSY}], true=[Music{name='歌4', singer='手4', num=40, status=BUSY}, Music{name='歌5', singer='手5', num=50, status=FREE}, Music{name='歌6', singer='手6', num=60, status=FREE}]}

join连接，将结果，以什么字符开头，结尾，和分割

public void joinTest(){
    String collect = music.stream()
            .map(Music::getName)
            .collect(Collectors.joining(",", "[", "]"));

    System.out.println(collect);
}

运行结果：

[歌1,歌2,歌3,歌4,歌5,歌6]