Stream 流编程

创建不可变集合

1、不可变集合定义：不可以被修改的集合，不能修改长度和内容

2、创建不可变集合的应用场景：

如果某个数据不能被修改，把它防御的拷贝到不可变集合中是很好的实践
当集合对象被不可信的库调用时，不可变形式是安全的

3、创建不可变集合的书写格式

方法名称	说明
List.of()	创建一个具有指定元素的List集合对象
Set.of()	创建一个具有指定元素的Set集合对象
Map.of()	创建一个具有指定元素的Map集合对象（JDK9提供的方法）

举例：Map.of("张三"，"26","李四","32","王五"，"24");两两配对，前一个是key,后一个是value;而且Map里面的of方法参数是有上限的，最多只能传递20个参数，10个键值对。

注意：这个集合不能添加，不能删除，不能修改

Stream 流

1、Stream 流的作用结合了Lambda 表达式，简化了集合，数组的操作。

2、Stream 流的使用步骤

先得到一条Stream 流（流水线），并把数据放上去
利用Stream 流中的API 进行各种操作
- Stream 流的中间方法 解释：中间方法，返回新的Stream流，原来的Stream 流只能使用一次，建议使用链式编程；修改Stream 流中的数据，不会影响原来集合或数组中的数据。
- Stream流的终结方法 解释：collect中参数可以是Collectors.toList():将结果集转化为List集合；Collectors.toSet():将结果集转化为Set集合；Collectors.toMap(键：：值):将结果集转化为Map集合，其中键是不能重复的，否则会报错

map()和toMap()的区别：

map（）：① 转换，map()方法用于将流中的元素转换成其他形式或类型。它不会改变流的元素数量，只会转换元素的类型或内容。 ② 中间操作，map()是一个中间操作，它会返回一个新的流，流的元素经过了转换，但原始流的元素不变。
toMap(): ① 收集：toMap()用于将流中的元素收集并组织成一个Map。它需要指定如何从流中的元素生成Map的键和值。 ② 终端操作：toMap()是一个终端操作，它会消耗流并生成一个Map，流在操作后结束。

(新篇章)为什么要使用Stream流编写代码

在日常开发中，有很多对象转化、链表去重、分批次服务调用等场景，这些场景用for循环或者if-else实现会让代码冗长、容易出错且效率不高。而Stream 流可以简化我们代码的书写，提升我们的开发效率。

案例引入

在JAVA中，涉及到对数组，Collection 等集合类中的元素进行操作的时候，通常会通过循环的方式进行逐个处理，或者使用Stream 的方式进行处理。

假设我们遇到一个需求：从给定的句子中返回单词长度大于5的单词列表，按长度倒序输出，最多返回3个。

java

public List<String> sortGetTop3LongWords(String sentence) {
    // 先切割句子，获取具体的单词信息
    String[] words = sentence.split(" ");
    List<String> wordList = new ArrayList<>();
    // 循环判断单词的长度，先过滤出符合长度要求的单词
    for (String word : words) {
        if (word.length() > 5) {
            wordList.add(word);
        }
    }
    // 对符合条件的列表按照长度进行排序
    wordList.sort((o1, o2) -> o2.length() - o1.length());
    // 判断list结果长度，如果大于3则截取前三个数据的子list返回
    if (wordList.size() > 3) {
        wordList = wordList.subList(0, 3);
    }
    return wordList;
}

当我们使用了Stream流对上面的逻辑进行处理

java

 public List<String> sortGetTop3LongWords(String sentence) {
        return Arrays.stream(sentence.split(" ")).filter(s -> s.length()>5)
                .sorted(((o1, o2) -> o2.length()-o1.length()))
                .limit(3)
                .collect(Collectors.toList());

    }

Stream 流的初步了解

概括讲，可以将Stream流操作分为3种类型：

创建Stream
Stream 中间处理
终止处理

alt text

每个Stream管道操作都包含若干方法，先列举一下各个API的方法：

开始管道

主要负责新建一个Stream流，或者基于现有的数组、List、Set、Map等集合类型对象创建出新的Stream流。

中间管道

API	功能说明
filter()	按照条件过滤符合要求的元素，返回新的stream流
map()	将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流
flatMap()	将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为一个或者多个新类型的元素，返回新的stream流
limit()	仅保留集合前面指定个数的元素，返回新的stream流
skip()	将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流
concat()	将两个流的数据合并起来为一个新的流，返回新的stream流
distinct()	对Stream中所有元素进行去重，返回新的stream流
sorted()	对stream中所有的元素按照指定规则进行排序，返回新的stream流
peek()	对stream流中的每个元素进行逐个遍历处理，返回处理后的stream流

终止管道

顾名思义，通过终止管道操作之后，Stream流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。

API	功能说明
count()	返回stream处理后最终的元素个数
max()	返回stream处理后的元素最大值
min()	返回stream处理后的元素最小值
findFirst()	找到第一个符合条件的元素时则终止流处理
findAny()	找到任何一个符合条件的元素时则退出流处理，这个对于串行流时与findFirst相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑
anyMatch()	返回一个boolean值，类似于isContains(),用于判断是否有符合条件的元素
allMatch()	返回一个boolean值，用于判断是否所有元素都符合条件
noneMatch()	返回一个boolean值，用于判断是否所有元素都不符合条件
collect()	将流转换为指定的类型，通过Collectors进行指定
toArray()	将流转换为数组
iterator()	将流转换为Iterator对象
foreach()	无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑
sorted()	对stream中所有的元素按照指定规则进行排序，返回新的stream流

Stream 方法的使用

map 和 flatMap 的使用

map 与 flatMap 都是用于转换已有的元素为其他元素，区别点在于：

map 必须是一对一的，即每一个元素都只能转换为一个新的元素
flatMap 可以是一对多的，即每个元素都可以转换为一个或者多个新的元素

下面两张图形象的说明了两者之间的区别：

map 图： alt text

flatMap 图： alt text

map 用例：有一个字符串ID列表，现在需要将其转为别的对象列表。

java

/**
 * map的用途：一换一
 */
List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");
        // 使用流操作
List<NormalOfferModel> results = ids.stream()
        .map(id -> {
            NormalOfferModel model = new NormalOfferModel();
            model.setCate1LevelId(id);
            return model;
        })
        .collect(Collectors.toList());
System.out.println(results);

执行之后，会发现每一个元素都被转换为对应新的元素，但是前后总元素个数是一致的：

java

[
NormalOfferModel{cate1LevelId='205', imgUrl='null', linkUrl='null', ohterurl='null'},
NormalOfferModel{cate1LevelId='105', imgUrl='null', linkUrl='null', ohterurl='null'},
NormalOfferModel{cate1LevelId='308', imgUrl='null', linkUrl='null', ohterurl='null'}, 
NormalOfferModel{cate1LevelId='469', imgUrl='null', linkUrl='null', ohterurl='null'}, 
NormalOfferModel{cate1LevelId='627', imgUrl='null', linkUrl='null', ohterurl='null'},
NormalOfferModel{cate1LevelId='193', imgUrl='null', linkUrl='null', ohterurl='null'}, 
NormalOfferModel{cate1LevelId='111', imgUrl='null', linkUrl='null', ohterurl='null'}
    ]

flatMap 用处：flatMap是将字符串数据流每个元素进行流化操作，再将这些流放到一起，形成一个字符串流

java


list.add(new String[]{"1","2,3","4,5,6"})
list.add(new String[]{"7,8","9"})

List<String> billIds = list.stream()
  .map(bill -> bill.getBillId().split(","))
  .flatMap(Arrays::stream)
  .collect(Collectors.toList());

//billIds输出为
//1,2,3,4,5,6,7,8,9

peek和foreach方法

peek和foreach，都可以用于对元素进行遍历然后逐个处理

但根据前面的介绍，peek属于中间方法，而foreach属于终止方法。这也就意味着peek只能作为管道中途的一个处理步骤，而没法直接执行得到结果，其后面必须还要有其它终止操作的时候才会被执行；而foreach作为无返回值的终止方法，则可以直接执行相关操作。

java

public void testPeekAndforeach() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 演示点1：仅peek操作，最终不会执行
    System.out.println("----before peek----");
    sentences.stream().peek(sentence -> System.out.println(sentence));
    System.out.println("----after peek----");
    // 演示点2：仅foreach操作，最终会执行
    System.out.println("----before foreach----");
    sentences.stream().forEach(sentence -> System.out.println(sentence));
    System.out.println("----after foreach----");
    // 演示点3：peek操作后面增加终止操作，peek会执行
    System.out.println("----before peek and count----");
    sentences.stream().peek(sentence -> System.out.println(sentence)).count();
    System.out.println("----after peek and count----");
}

输出结果可以看出，peek独自调用时并没有被执行、但peek后面加上终止操作之后便可以被执行，而foreach可以直接被执行：

java

----before peek----
----after peek----
----before foreach----
hello world
Jia Gou Wu Dao
----after foreach----
----before peek and count----
hello world
Jia Gou Wu Dao
----after peek and count----

简单结果终止流

按照前面介绍的，终止方法里面像count、max、min、findAny、findFirst、anyMatch、allMatch、noneMatch等方法，均属于这里说的简单结果终止方法。所谓简单，指的是其结果形式是数字、布尔值或者Optional对象值等。

java

public void testSimpleStopOptions() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    // 统计stream操作后剩余的元素个数
    System.out.println(ids.stream().filter(s -> s.length() > 2).count());
    // 判断是否有元素值等于205
    System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
    // findFirst操作
    ids.stream().filter(s -> s.length() > 2)
            .findFirst()
            .ifPresent(s -> System.out.println("findFirst:" + s));
}

java

6
true
findFirst:205

一旦一个Steam 被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错。

结束收集终止方法

因为Stream主要用于对集合数据的处理场景，所以除了上面几种获取简单结果的终止方法之外，更多的场景是获取一个集合类的结果对象，比如List、Set或者HashMap等。

这里就需要collect方法出场了，它可以支持生成如下类型的结果数据：

一个集合类，比如List,Set 或者HashMap 等
StringBuilder 对象，支持将多个字符串进行拼接并输出拼接后结果
一个可以记录个数或者计算总和的对象（数据批量运算统计）

生成集合对象

java

   List<Person> persons = Arrays.asList(new Person(1,"zhang"),new Person(2,"qian"),new Person(3,"sun"));
        // 将collect成List
        List<Person> personList = persons.stream().filter(s -> s.getId() == 2).collect(Collectors.toList());
        System.out.println("personList"+personList);
        // 将collect成Set
        Set<Person> personSet = persons.stream().filter(s -> s.getName().length() >= 4).collect(Collectors.toSet());
        System.out.println("personSet"+personSet);
        // 将collect成Map
        /* 
        这行代码使用 collect 方法将过滤后的 Stream<Person> 转换为一个 Map<Integer, Person>，其中 Collectors.toMap 方法接受三个参数：
        Person::getId:这是键的生成规则。表示使用 Person 实例中的 id 属性作为 Map 的键（Integer 类型）。
        Function.identity():这是值的生成规则。表示使用 Person 实例本身作为 Map 中的值（Person 类型）。
        (k1, k2) -> k2:这是键值冲突时的合并函数。k1 和 k2 分别表示两个 Person 实例。当 Person::getId 返回相同的键值时，就会发生键冲突，这时该函数会决定如何处理冲突。
        具体操作是：在键冲突的情况下，保留 k2（即第二个 Person 实例）作为新值，而忽略 k1（第一个 Person 实例）。
        */
        Map<Integer,Person> personMap = persons.stream().filter(s -> s.getName().length() >= 4).collect(Collectors.toMap(Person::getId, Function.identity(),(k1,k2)->k2));
        System.out.println("personMap"+personMap);

结果

java

personList[Person{id=2, name='qian'}]
personSet[Person{id=2, name='qian'}, Person{id=1, name='zhang'}]
personMap{1=Person{id=1, name='zhang'}, 2=Person{id=2, name='qian'}}

生成拼接字符串

将一个List或者数组中的值拼接到一个字符串里并以逗号分隔开，这个场景相信大家都不陌生吧？如果通过for循环和StringBuilder去循环拼接，还得考虑下最后一个逗号如何处理的问题，很繁琐:

java

public void testForJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    StringBuilder builder = new StringBuilder();
    for (String id : ids) {
        builder.append(id).append(',');
    }
    // 去掉末尾多拼接的逗号
    builder.deleteCharAt(builder.length() - 1);
    System.out.println("拼接后：" + builder.toString());
}

但是现在有了Stream，使用collect可以轻而易举的实现

java

public void testForJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    String result = ids.stream().collect(Collectors.joining(","));
    System.out.println("拼接后：" + result);
}

批量数学运算

还有一种场景，实际使用的时候可能会比较少，就是使用collect生成数字数据的总和信息，也可以了解下实现方式：

java

public void testNumberCalculate() {
    List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
    // 计算平均值
    Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
    System.out.println("平均值：" + average);
    // 数据统计信息
    IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
    System.out.println("数据统计信息：" + summary);
}

上面的例子中，使用collect方法来对list中元素值进行数学运算，结果如下：

java

平均值：30.0
总和：IntSummaryStatistics{count=5, sum=150, min=10, average=30.000000, max=50}

并行Stream

parallelStream的机制说明

使用并行流，可以有效利用计算机的多CPU硬件，提升逻辑的执行速度。并行流通过将一整个stream划分为多个片段，然后对各个分片流并行执行处理逻辑，最后将各个分片流的执行结果汇总为一个整体流。

alt text

可以通过parallelStream的源码发现parallel Stream底层是将任务进行了切分，最终将任务传递给了jdk8自带的“全局”ForkJoinPool线程池。在Fork-Join中，比如一个拥有4个线程的ForkJoinPool线程池，有一个任务队列，一个大的任务切分出的子任务会提交到线程池的任务队列中，4个线程从任务队列中获取任务执行，哪个线程执行的任务快，哪个线程执行的任务就多，只有队列中没有任务线程才是空闲的，这就是工作窃取。

可以通过下图更好的理解这种“分而治之”的思想：

alt text

约束与限制

1.parallelStream()中foreach()操作必须保证是线程安全的；

很多人在用惯了流式处理之后，很多for循环都会直接使用流式foreach(),实际上这样不一定是合理的，如果只是简单的for循环，确实没有必要使用流式处理，因为流式底层封装了很多流式处理的复杂逻辑，从性能上来讲不占优。

2.parallelStream()中foreach()不要直接使用默认的线程池；

java

ForkJoinPool customerPool = new ForkJoinPool(n);
customerPool.submit(
     () -> customerList.parallelStream().具体操作
)

3.parallelStream()使用的时候尽量避免耗时操作；

如果遇到耗时的操作，或者大量IO的操作，或者有线程sleep的操作一定要避免使用并行流。

Stream 流总结

优势

1.代码更简洁。偏声明式的编码风格，更容易体现出代码的逻辑意图。

2.逻辑间解耦。一个stream中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可。

3.并行流场景效率会比迭代器逐个循环更高。

4.函数式接口，延迟执行的特性，中间管道操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行，可以避免一些中间不必要的操作消耗。

劣势

debug不方便

Stream 流编程 ​

创建不可变集合 ​

Stream 流 ​

(新篇章)为什么要使用Stream流编写代码 ​

Stream 流的初步了解 ​

开始管道 ​

中间管道 ​

终止管道 ​

Stream 方法的使用 ​

map 和 flatMap 的使用 ​

peek和foreach方法 ​

简单结果终止流 ​

结束收集终止方法 ​

批量数学运算 ​

并行Stream ​

parallelStream的机制说明 ​

约束与限制 ​

Stream 流总结 ​

优势 ​

劣势 ​

Stream 流编程

创建不可变集合

Stream 流

(新篇章)为什么要使用Stream流编写代码

Stream 流的初步了解

开始管道

中间管道

终止管道

Stream 方法的使用

map 和 flatMap 的使用

peek和foreach方法

简单结果终止流

结束收集终止方法

批量数学运算

并行Stream

parallelStream的机制说明

约束与限制

Stream 流总结

优势

劣势