Java8 Stream 系列（二）Stream应当注意的点

发表于 | | 阅读次数

上一篇文章写了流的基本知识，大约知道了流是用来处理序列集合的武功秘籍。
集合关注的是数据存储本身，流关注的数据计算和处理。本篇文章来说明一下适用流时应当注意的几点

##0x00 流不修改数据源
很多人认为流会直接操作源数据，有意识或者无意识的认为流中对数据的修改，可以在源序列集合中体现，甚至将源对象直接返回给调用处，然后想了半天为什么流操作为什么没有起作用，java8的流太难用了。
下面是一段验证代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class StreamTest1 {
    @Test
    public void testNotChange() {
        System.out.println(sourceNotChange());
    }
    public List<String> sourceNotChange() {
        List<String> names = Arrays.asList("zing","wang","zhen","max");
        System.out.println("\nthe source data-------------------");
        System.out.println(names);
        System.out.println("\nthe stream data-------------------");
        names.stream().map(i->{i = i+"_2 "; return i;}).forEach(System.out::print);
        System.out.println("\n");
        return names;
    }
}

运行结果

可以看到，如果将names直接return的话，数据是没有任何修改的。如果想将修改之后的对象返回，需要重新创建对象，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class StreamTest2 {
    @Test
    public void testNewObj() {
        System.out.println(changeToNewObj());
    }
    public List<String> changeToNewObj() {
        List<String> names = Arrays.asList("zing", "wang", "zhen", "max");
        System.out.println("\nthe source data-------------------");
        System.out.println(names);
        System.out.println("\nthe stream data-------------------");
        List<String> newNames = names.stream().map(i -> { i = i + "_2 "; return i; }).collect(Collectors.toList());
        System.out.println(newNames);
        System.out.println("\n");
        return newNames;
    }
}

运行结果

1x00 Stream对象只能使用一次

文章《Java8 Stream系列（一）从入坑到沉迷》已经验证
这里列出来提醒下，示例代码如下：

1
2
3
Stream<Integer> trans = Stream.of(11, 9, 2);
trans.forEach(i -> System.out.println(i));
trans.reduce(0, Integer::sum);

2x00 流是惰性的

流只有在终止操作（Terminal operation）的时候才会进行计算
看API的朋友应该知道，有些方法返回的是Stream对象，如
IntStream API

有些操作无返回，或者是是非Stream的返回。

IntStream API

一般来说，除了初始创建流的，返回流对象的大部分是业务中间操作，业务中间操作（intermediate operations）只会暂是保留，不会执行，只有遇到求值终止操作（terminal operation） 时，才会一起执行。
下面两段代码，展示了流的惰性的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class StreamTest3 {
    @Test
    public void testNewObj() {
        IntStream.range(1, 10)
                .limit(5)
                .filter(i -> i > 0)
                .sorted()
                .skip(1)
                .map(i -> {
                    System.out.println("正在处理" + i);
                    return i;
                });
    }
}

运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class StreamTest3 {
    @Test
    public void testNewObj() {
        IntStream.range(1, 10)
                .limit(5)
                .filter(i -> i > 0)
                .sorted()
                .skip(1)
                .map(i -> {
                    System.out.println("正在处理" + i);
                    return i;
                })
                .forEach(i->{});
    }
}

运行结果

3x00 无限流

以上代码大部分是基于数组或List，所以都是有限流，下面演示一下无限流

1
2
3
4
5
6
7
public class StreamTest4 {
    @Test
    public void infintyStream(){
        Stream.iterate(1,i->i++)
                .forEach(num->System.out.println(String.valueOf(num)));
    }
}

运行结果，停不下来了！！！

无限流会造成程序无限运行，根本听不下来，应该规避无限流，只需要在iterate之后添加一个 limit() 即可

1
2
3
4
5
6
7
8
public class StreamTest5 {
    @Test
    public void infintyStream(){
        Stream.iterate(1,i->i++)
                .limit(18)
                .forEach(num->System.out.println(String.valueOf(num)));
    }
}

陷阱：下面也是一个无限流，请思考一下，为什么明明没有输出了，流却没有停下来

1
2
3
4
5
6
7
8
9
public class StreamTest6 {
    @Test
    public void infintyStream(){
        Stream.iterate(1, i -> (i + 1) % 2)
                .distinct()
                .limit(10)
                .forEach(num -> System.out.println(String.valueOf(num)));
    }
}

##4x00 流具有短路操作的特性
流具有短路运算的特性，和&&，||一样，当逻辑条件达到操作目标，则流不会继续迭代元素，继续操作， 举个栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
public class StreamTest2 {
    @Test
    public void shortCircuitingStream(){
        List<String> datas = Arrays.asList("aaa","bb","CCCC","aaa bb CCCC","bb CCCC","bbb");
        datas.stream()
                .mapToInt(String::length)
                .filter(i->i==3)
                .findFirst()
                .ifPresent(System.out::println);
    }
}

上图打印的结果是3

我们更改一下方法引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class StreamTest2 {
    @Test
    public void shortCircuitingStream(){
        List<String> datas = Arrays.asList("aaa","bb","CCCC","aaa bb CCCC","bb CCCC","bbb");
        datas.stream()
                .mapToInt(i->{
                    System.out.println(i);
                    return i.length();
                })
                .filter(i->i==3)
                .findFirst()
                .ifPresent(System.out::println);
    }
}

并没有打印其他元素

结果很明显，没有打印其他的元素。也就是说，流的中间操作只是存储对元素的操作，并不会对元素进行迭代。

在终止操作之后，流会以短路的方式，对元素进行计算与修改。

我是分割线

5x00 流的特性：

5x01 本质是函数式的， Stream不存储值

函数式的描述性语言，
如过滤：filter，限制：limit，循环：forEach，遍历：map等，描述地非常清晰；

流也不会对值进行存储，只有在遇到终止操作的时候，才会对数据系列进行一次性操作。上文已经说过中间操作不会对数据进行操作，直到遇到终止操作。

5x02 内部迭代和外部迭代

for和for Each是外部迭代，外部迭代会将序列中的元素一一取出，再对数据进行显式操作。
for循环大家一定不陌生，这里就不代码举例了

流是内部迭代，在java中，除了留，其他的迭代全部是外部迭代。
流表面看似每个操作都会对数据进行一次循环，实际上并不是，流在内部迭代的时候，会尽量优化执行，并不是每次操作都会触发对数据序列的遍历

5x03 Stream针对数据的处理和计算

Stream和Iterator的的共同点是只能使用一次，不同点是：Stream是不存储值的，因为Stream针对数据的处理和计算，所以当流中需要创建存储的对象的时候，应该考虑一下，到底应不应该使用流。因为流不是万能的，也不一定是效率最高的。

前篇 学习Java8中的Stream （一）

by:Zing
转载请注明出处：https://micorochio.github.io/2018/02/16/the-stream-in-java8-02/