JDK8 新特性之Stream流方法详解

青旅半醒 2024-03-27 08:59 105阅读 0赞

**目录**

一：集合处理数据的弊端

二：Stream流式思想概述

小结 ：

三：获取Stream流的两种方式

方式1 : 根据Collection获取流

方式2 : Stream中的静态方法of获取流

小结

四：Stream常用方法和注意事项

Stream常用方法

Stream注意事项(重要)

Stream流的forEach方法

Stream流的count方法

Stream流的fifilter方法

Stream流的limit方法

Stream流的skip方法

Stream流的map方法

Stream流的sorted方法

Stream流的distinct方法

Stream流的match方法

Stream流的fifind方法

Stream流的max和min方法

Stream流的reduce方法

Stream流的map和reduce组合使用

Stream流的mapToInt

Stream流的concat方法

四：Stream综合案例

传统方式

Stream方式

--------------------

## **一：集合处理数据的弊端** ##

当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。我们来体验集合操作数据的弊端，需求如下：

一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
    需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据

代码如下：

public static void main(String[] args) {
    // 一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
    // 需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
    // 1.拿到所有姓张的
    ArrayList<String> zhangList = new ArrayList<>(); // {"张无忌", "张强", "张三丰"}
    for (String name : list) {
    if (name.startsWith("张")) {
    zhangList.add(name);
    }
    }
    // 2.拿到名字长度为3个字的
    ArrayList<String> threeList = new ArrayList<>(); // {"张无忌", "张三丰"}
    for (String name : zhangList) {
    if (name.length() == 3) {
    threeList.add(name);
    }
    }
    // 3.打印这些数据
    for (String name : threeList) {
    System.out.println(name);
    }
    }

**循环遍历的弊端**

这段代码中含有三个循环，每一个作用不同：

1.  首先筛选所有姓张的人；

2.  然后筛选名字有三个字的人；

3.  最后进行对结果进行打印输出。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？ **不是。** 循环 是做事情的方式，而不是目的。每个需求都要循环一次，还要搞一个新集合来装数据，如果希望再次遍历，只能再使用另一个循环从头开始。

那 Stream 能给我们带来怎样更加优雅的写法呢？

下面来看一下借助 Java 8 的 Stream API ，修改后的代码：

public class Demo03StreamFilter {
    public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    list.stream()
    .filter(s -> s.startsWith("张"))
    .filter(s -> s.length() == 3)
    .forEach(System.out::println);
    }
    }

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义： **获取流、过滤姓张、过滤长度为** **3** **、逐一打印** 。我们真正要做的事情内容被更好地体现在代码中。

## 二：**Stream****流式思想概述**  ##

**注意：** **Stream** **和** **IO** **流** **(InputStream/OutputStream)** **没有任何关系，请暂时忘记对传统** **IO** **流的固有印象！**

Stream 流式思想类似于工厂车间的 “ **生产流水线** ” ， Stream 流不是一种数据结构，不保存数据，而是对数据进行加工处理。Stream 可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

![cc354b15c2ed4e5b9d90a9c145df4fa3.png][]

![bc89db620c8942108a9c594f57325929.png][]

![916a53de3e224a79ba116d416a2b703c.png][]

Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。

#### **小结** ： ####

首先我们了解了集合操作数据的弊端 , 每次都需要循环遍历 , 还要创建新集合 , 很麻烦 ，Stream是流式思想 , 相当于工厂的流水线 , 对集合中的数据进行加工处理

## 三：**获取****Stream****流的两种方式**  ##

java.util.stream.Stream<T>  是 JDK 8 新加入的流接口。

获取一个流非常简单，有以下几种常用的方式：

*  所有的 Collection 集合都可以通过 stream 默认方法获取流； 
 *  Stream 接口的静态方法 of 可以获取数组对应的流。

#### **方式****1 :** **根据****Collection****获取流**  ####

首先，  java.util.Collection  接口中加入了 default 方法  stream  用来获取流，所以其所有实现类均可获取流。

public interface Collection {
    default Stream<E> stream()
    }

import java.util.*;
    import java.util.stream.Stream;
    public class Demo04GetStream {
    public static void main(String[] args) {
    // 集合获取流
    // Collection接口中的方法: default Stream<E> stream() 获取流
    List<String> list = new ArrayList<>();
    // ...
    Stream<String> stream1 = list.stream();
    Set<String> set = new HashSet<>();
    // ...
    Stream<String> stream2 = set.stream();
    Vector<String> vector = new Vector<>();
    // ...
    Stream<String> stream3 = vector.stream();
    }
    }

java.util.Map  接口不是  Collection  的子接口，所以获取对应的流需要分 key 、 value 或 entry 等情况：

import java.util.HashMap;
    import java.util.Map;
    import java.util.stream.Stream;
    public class Demo05GetStream {
    public static void main(String[] args) {
    // Map获取流
    Map<String, String> map = new HashMap<>();
    // ...
    Stream<String> keyStream = map.keySet().stream();
    Stream<String> valueStream = map.values().stream();
    Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
    }
    }

#### **方式****2 : Stream****中的静态方法****of****获取流**  ####

由于数组对象不可能添加默认方法，所以  Stream  接口中提供了静态方法  of  ，使用很简单：

import java.util.stream.Stream;
    public class Demo06GetStream {
    public static void main(String[] args) {
    // Stream中的静态方法: static Stream of(T... values)
    Stream<String> stream6 = Stream.of("aa", "bb", "cc");
    String[] arr = {"aa", "bb", "cc"};
    Stream<String> stream7 = Stream.of(arr);
    Integer[] arr2 = {11, 22, 33};
    Stream<Integer> stream8 = Stream.of(arr2);
    // 注意:基本数据类型的数组不行，它会将整个数组看做一个元素进行操作
    int[] arr3 = {11, 22, 33};
    Stream<int[]> stream9 = Stream.of(arr3);
    }
    }

备注：  of  方法的参数其实是一个可变参数，所以支持数组

#### **小结**  ####

**学习了两种获取流的方式** **:**

1.  通过 Collection 接口中的默认方法 Stream stream()

2.  通过 Stream 接口中的静态 of 方法

## 四：**Stream****常用方法和注意事项** ##

> #### **Stream****常用方法**  ####

Stream 流模型的操作很丰富，这里介绍一些常用的 API 。这些方法可以被分成两种：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>方法名 </strong></span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>方法作用 </strong></span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#ff0000;"><strong>返回值类</strong></span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>方法种类</strong></span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">&nbsp;count</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">统计个数 </span> 
    </div> </td> 
   <td><span style="color:#333333;">long</span></td> 
   <td><span style="color:#333333;">终结</span></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">&nbsp;forEach </span> 
    </div> </td> 
   <td><span style="color:#333333;">逐一处理</span></td> 
   <td><span style="color:#333333;">void</span></td> 
   <td><span style="color:#333333;">终结</span></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">&nbsp;fifilter </span> 
    </div> </td> 
   <td><span style="color:#333333;">过滤</span></td> 
   <td> 
    <div> 
     <span style="color:#333333;">Stream</span> 
    </div> </td> 
   <td><span style="color:#333333;">函数拼接</span></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">&nbsp;limit </span> 
    </div> </td> 
   <td><span style="color:#333333;">取用前几个</span></td> 
   <td><span style="color:#333333;">Stream</span></td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数拼接</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">skip </span> 
    </div> </td> 
   <td><span style="color:#333333;">跳过前几个</span></td> 
   <td><span style="color:#333333;">Stream</span></td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数拼接</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">map </span> 
    </div> </td> 
   <td><span style="color:#333333;">映射</span></td> 
   <td><span style="color:#333333;">Stream</span></td> 
   <td><span style="color:#333333;">函数拼接</span></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">concat </span> 
    </div> </td> 
   <td><span style="color:#333333;">组合</span></td> 
   <td><span style="color:#333333;">Stream</span></td> 
   <td><span style="color:#333333;">函数拼接</span></td> 
  </tr> 
 </tbody> 
</table>

*  **终结方法**：返回值类型不再是 Stream 类型的方法，不再支持链式调用。本小节中，终结方法包括 count 和 forEach 方法。 
 *  **非终结方法**：返回值类型仍然是 Stream 类型的方法，支持链式调用。（除了终结方法外，其余方法均为非终结方法。）

> ### **Stream****注意事项****(****重要****)** ###

1. Stream 只能操作一次

2. Stream 方法返回的是新的流

3. Stream 不调用终结方法，中间的操作不会执行

public class Demo03StreamNotice {
        public static void main(String[] args) {
            Stream<String> stream = Stream.of("aa", "bb", "cc");
            // 1. Stream只能操作一次
            // long count = stream.count();
            // long count2 = stream.count();
    
            // 2. Stream方法返回的是新的流
            // Stream<String> limit = stream.limit(1);
            // System.out.println("stream" + stream);
            // System.out.println("limit" + limit);
    
            // 3. Stream不调用终结方法，中间的操作不会执行
            stream.filter((s) -> {
                System.out.println(s);
                return true;
            }).count();
        }
    }

> ### **Stream****流的****forEach****方法** ###

forEach  用来遍历流中的数据

void forEach(Consumer<? super T> action);

该方法接收一个  Consumer  接口函数，会将每一个流元素交给该函数进行处理。例如：

@Test
        public void testForEach() {
            List<String> one = new ArrayList<>();
            Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
    
            /*// 得到流
            // 调用流中的方法
            one.stream().forEach((String str) -> {
                System.out.println(str);
            });
    
            // Lambda可以省略
            one.stream().forEach(str -> System.out.println(str));*/
    
            // Lambda可以转成方法引用
            one.stream().forEach(System.out::println);
    
        }

> ### **Stream****流的****count****方法** ###

Stream 流提供  count  方法来统计其中的元素个数：

long count();

该方法返回一个 long 值代表元素个数。基本使用：

@Test
        public void testCount() {
            List<String> one = new ArrayList<>();
            Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
    
            long count = one.stream().count();
            System.out.println(count);
        }

> ### **Stream****流的****fifilter****方法** ###

fifilter 用于过滤数据，返回符合过滤条件的数据

![276fbb7ab08049a1825ecfb37c045555.png][]

可以通过 filter 方法将一个流转换成另一个子集流。方法声明：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个  Predicate  函数式接口参数（可以是一个 Lambda 或方法引用）作为筛选条件。

Stream 流中的  filter  方法基本使用的代码如：

@Test
        public void testFilter() {
            List<String> one = new ArrayList<>();
            Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
    
            // 得到名字长度为3个字的人(过滤)
            // filter(Predicate<? super T> predicate)
            /*one.stream().filter((String s) -> {
                return s.length() == 3;
            }).forEach(System.out::println);*/
    
            // one.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        }

> ### **Stream****流的****limit****方法**  ###

![ea3cbd24b5fc419289b1ed5395eb209d.png][]

limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个 long 型，如果集合当前长度大于参数则进行截取。否则不进行操作。基本使用：

@Test
        public void testLimit() {
            List<String> one = new ArrayList<>();
            Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
    
            // 获取前3个数据
            one.stream()
                    .limit(3)
                    .forEach(System.out::println);
        }

> ### **Stream****流的****skip****方法**  ###

![2c7edef37b6d448eabcce02a4634ec8d.png][]

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于 n ，则跳过前 n 个；否则将会得到一个长度为 0 的空流。基本使用：

@Test
        public void testSkip() {
            List<String> one = new ArrayList<>();
            Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
    
            // 跳过前两个数据
            one.stream()
                    .skip(2)
                    .forEach(System.out::println);
        }

> ### **Stream****流的****map****方法**  ###

![d51aaf8e99dd4b0fbd6791a60a24aede.png][]

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个  Function  函数式接口参数，可以将当前流中的 T 类型数据转换为另一种 R 类型的流。

Stream 流中的  map  方法基本使用的代码如：

@Test
        public void testMap() {
            Stream<String> original = Stream.of("11", "22", "33");
    
            // Map可以将一种类型的流转换成另一种类型的流
            // 将Stream流中的字符串转成Integer
            /*Stream<Integer> stream = original.map((String s) -> {
                return Integer.parseInt(s);
            });*/
            // original.map(s -> Integer.parseInt(s)).forEach(System.out::println);
    
            original.map(Integer::parseInt).forEach(System.out::println);
        }

这段代码中，  map  方法的参数通过方法引用，将字符串类型转换成为了 int 类型（并自动装箱为  Integer  类对象）。

> ### **Stream****流的****sorted****方法** ###

如果需要将数据排序，可以使用  sorted  方法。方法签名：

Stream<T> sorted();
    Stream<T> sorted(Comparator<? super T> comparator);

**基本使用**

Stream 流中的  sorted  方法基本使用的代码如：

@Test
        public void testSorted() {
            // sorted(): 根据元素的自然顺序排序
            // sorted(Comparator<? super T> comparator): 根据比较器指定的规则排序
            Stream<Integer> stream = Stream.of(33, 22, 11, 55);
    
            // stream.sorted().forEach(System.out::println);
            /*stream.sorted((Integer i1, Integer i2) -> {
                return i2 - i1;
            }).forEach(System.out::println);*/
    
            stream.sorted((i1, i2) -> i2 - i1).forEach(System.out::println);
        }

这段代码中，  sorted  方法根据元素的自然顺序排序，也可以指定比较器排序。

> ### **Stream****流的****distinct****方法** ###

![ec504b626b4a4de1942856a54eca83eb.png][]

如果需要去除重复数据，可以使用 distinct 方法。方法签名：

Stream<T> distinct();

**基本使用**

Stream 流中的  distinct  方法基本使用的代码如：

@Test
        public void testDistinct() {
            Stream<Integer> stream = Stream.of(22, 33, 22, 11, 33);
    
            stream.distinct().forEach(System.out::println);
    
            Stream<String> stream1 = Stream.of("aa", "bb", "aa", "bb", "cc");
            stream1.distinct().forEach(System.out::println);
    
        }

如果是自定义类型如何是否也能去除重复的数据呢？

@Test
    public void testDistinct2() {
    Stream.of(
    new Person("刘德华", 58),
    new Person("张学友", 56),
    new Person("张学友", 56),
    new Person("黎明", 52))
    .distinct()
    .forEach(System.out::println);
    }

public class Person {
    private String name;
    private int age;
    // 省略其他
    }

自定义类型是根据对象的 hashCode 和 equals 来去除重复元素的。

// distinct对自定义对象去除重复
        @Test
        public void testDistinct2() {
            Stream<Person> stream = Stream.of(
                    new Person("貂蝉", 18),
                    new Person("杨玉环", 20),
                    new Person("杨玉环", 20),
                    new Person("西施", 16),
                    new Person("西施", 16),
                    new Person("王昭君", 25)
            );
    
            stream.distinct().forEach(System.out::println);
        }

重写对象的hashCode和equals即可

@Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            Person person = (Person) o;
    
            if (age != person.age) return false;
            return name != null ? name.equals(person.name) : person.name == null;
        }
    
        @Override
        public int hashCode() {
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }

> ### **Stream****流的****match****方法**  ###

如果需要判断数据是否匹配指定的条件，可以使用 Match 相关方法。方法签名：

boolean allMatch(Predicate<? super T> predicate);
    boolean anyMatch(Predicate<? super T> predicate);
    boolean noneMatch(Predicate<? super T> predicate);

**基本使用**

Stream 流中的  Match  相关方法基本使用的代码如：

@Test
        public void testMatch() {
            Stream<Integer> stream = Stream.of(5, 3, 6, 1);
    
            // boolean b = stream.allMatch(i -> i > 0); // allMatch: 匹配所有元素,所有元素都需要满足条件
            // boolean b = stream.anyMatch(i -> i > 5); // anyMatch: 匹配某个元素,只要有其中一个元素满足条件即可
            boolean b = stream.noneMatch(i -> i < 0); // noneMatch: 匹配所有元素,所有元素都不满足条件
            System.out.println(b);
        }

> ### **Stream****流的****fifind****方法** ###

![589bae70bdba4a9e8c437821f86394d3.png][]

如果需要找到某些数据，可以使用 find 相关方法。方法签名：

Optional<T> findFirst();
    Optional<T> findAny();

**基本使用**

Stream 流中的  find  相关方法基本使用的代码如：

@Test
        public void testFind() {
            Stream<Integer> stream = Stream.of(33, 11, 22, 5);
            Optional<Integer> first = stream.findFirst();
            // Optional<Integer> first = stream.findAny();
            System.out.println(first.get());
        }

> ### **Stream****流的****max****和****min****方法** ###

![e681be7a6f39428ca57e4d3dc4211eb5.png][]

如果需要获取最大和最小值，可以使用  max  和  min  方法。方法签名：

Optional<T> max(Comparator<? super T> comparator);
    Optional<T> min(Comparator<? super T> comparator);

**基本使用**

Stream 流中的  max  和  min  相关方法基本使用的代码如：

@Test
        public void testMax_Min() {
            // 获取最大值
            // 1, 3, 5, 6
            Optional<Integer> max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);
            System.out.println("最大值: " + max.get());
    
            // 获取最小值
            // 1, 3, 5, 6
            Optional<Integer> min = Stream.of(5, 3, 6, 1).min((o1, o2) -> o1 - o2);
            System.out.println("最小值: " + min.get());
        }

> ### **Stream****流的****reduce****方法** ###

![9065de6e0adf45b5b498a0dd0dd78577.png][]

如果需要将所有数据归纳得到一个数据，可以使用  reduce  方法。方法签名：

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

**基本使用**

Stream 流中的  reduce  相关方法基本使用的代码如：

@Test
        public void testReduce() {
            // T reduce(T identity, BinaryOperator<T> accumulator);
            // T identity: 默认值
            // BinaryOperator<T> accumulator: 对数据进行处理的方式
            // reduce如何执行?
            // 第一次, 将默认值赋值给x, 取出集合第一元素赋值给y
            // 第二次, 将上一次返回的结果赋值x, 取出集合第二元素赋值给y
            // 第三次, 将上一次返回的结果赋值x, 取出集合第三元素赋值给y
            // 第四次, 将上一次返回的结果赋值x, 取出集合第四元素赋值给y
            int reduce = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
                System.out.println("x = " + x + ", y = " + y);
                return x + y;
            });
            System.out.println("reduce = " + reduce); // 21
    
            // 获取最大值
            Integer max = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
                return x > y ? x : y;
            });
            System.out.println("max = " + max);
        }

![5d628fa637354846875cd6e2a7a5398c.png][]

> ### **Stream****流的****map****和****reduce****组合使用**  ###

@Test
        public void testMapReduce() {
            // 求出所有年龄的总和
            // 1.得到所有的年龄
            // 2.让年龄相加
            Integer totalAge = Stream.of(
                    new Person("刘德华", 58),
                    new Person("张学友", 56),
                    new Person("郭富城", 54),
                    new Person("黎明", 52))
                    .map((p) -> p.getAge()).reduce(0, Integer::sum);
    
            System.out.println("totalAge = " + totalAge);
    
    
            // 找出最大年龄
            // 1.得到所有的年龄
            // 2.获取最大的年龄
            Integer maxAge = Stream.of(
                    new Person("刘德华", 58),
                    new Person("张学友", 56),
                    new Person("郭富城", 54),
                    new Person("黎明", 52))
                    .map(p -> p.getAge())
                    .reduce(0, Math::max);
            System.out.println("maxAge = " + maxAge);
    
            // 统计 a 出现的次数
            //                          1    0     0    1    0    1
            Integer count = Stream.of("a", "c", "b", "a", "b", "a")
                    .map(s -> {
                        if (s == "a") {
                            return 1;
                        } else {
                            return 0;
                        }
                    })
                    .reduce(0, Integer::sum);
            System.out.println("count = " + count);
        }

> ### **Stream****流的****mapToInt** ###

如果需要将 Stream 中的 Integer 类型数据转成 int 类型，可以使用  mapToInt  方法。方法签名：

IntStream mapToInt(ToIntFunction<? super T> mapper);

![05904fd22ae344b7b9df873fadf5d8ed.png][]

**基本使用**

Stream 流中的  mapToInt  相关方法基本使用的代码如：

@Test
        public void testNumericStream() {
            // Integer占用的内存比int多,在Stream流操作中会自动装箱和拆箱
            Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
            // 把大于3的打印出来
            // stream.filter(n -> n > 3).forEach(System.out::println);
    
            // IntStream mapToInt(ToIntFunction<? super T> mapper);
            // IntStream: 内部操作的是int类型的数据,就可以节省内存,减少自动装箱和拆箱
            /*IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt((Integer n) -> {
                return n.intValue();
            });*/
    
            IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
            intStream.filter(n -> n > 3).forEach(System.out::println);
        }

> ### **Stream****流的****concat****方法** ###

如果有两个流，希望合并成为一个流，那么可以使用  Stream  接口的静态方法  concat  ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与  java.lang.String  当中的  concat  方法是不同的。

该方法的基本使用代码如：

@Test
        public void testContact() {
            Stream<String> streamA = Stream.of("张三");
            Stream<String> streamB = Stream.of("李四");
    
            // 合并成一个流
            Stream<String> newStream = Stream.concat(streamA, streamB);
            // 注意:合并流之后,不能操作之前的流啦.
            // streamA.forEach(System.out::println);
    
            newStream.forEach(System.out::println);
        }

### 四：**Stream****综合案例** ###

现在有两个  ArrayList  集合存储队伍当中的多个成员姓名，要求使用传统的 for 循环（或增强 for 循环） **依次** 进行以下若干操作步骤：

1.  第一个队伍只要名字为 3 个字的成员姓名；

2.  第一个队伍筛选之后只要前 3 个人；

3.  第二个队伍只要姓张的成员姓名；

4.  第二个队伍筛选之后不要前 2 个人；

5.  将两个队伍合并为一个队伍；

6.  根据姓名创建  Person  对象；

7.  打印整个队伍的 Person 对象信息。

两个队伍（集合）的代码如下：

而  Person  类的代码为：

public class Person {
    private String name;
    public Person() {}
    public Person(String name) {
    this.name = name;
    }
    @Override
    public String toString() {
    return "Person{name='" + name + "'}";
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    }

#### **传统方式**  ####

使用 for 循环  ,  示例代码 :

public class DemoArrayListNames {
    public static void main(String[] args) {
    List<String> one = List.of("迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子", "洪七
    公");
    List<String> two = List.of("古力娜扎", "张无忌", "张三丰", "赵丽颖", "张二狗", "张天爱",
    "张三");
    // 第一个队伍只要名字为3个字的成员姓名；
    List<String> oneA = new ArrayList<>();
    for (String name : one) {
    if (name.length() == 3) {
    oneA.add(name);
    }
    }
    // 第一个队伍筛选之后只要前3个人；
    List<String> oneB = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
    oneB.add(oneA.get(i));
    }
    // 第二个队伍只要姓张的成员姓名；
    List<String> twoA = new ArrayList<>();
    for (String name : two) {
    if (name.startsWith("张")) {
    twoA.add(name);
    }
    }
    // 第二个队伍筛选之后不要前2个人；
    List<String> twoB = new ArrayList<>();
    for (int i = 2; i < twoA.size(); i++) {
    twoB.add(twoA.get(i));
    }
    // 将两个队伍合并为一个队伍；
    List<String> totalNames = new ArrayList<>();
    totalNames.addAll(oneB);
    totalNames.addAll(twoB);
    // 根据姓名创建Person对象；
    List<Person> totalPersonList = new ArrayList<>();
    for (String name : totalNames) {
    totalPersonList.add(new Person(name));
    }
    // 打印整个队伍的Person对象信息。
    for (Person person : totalPersonList) {
    System.out.println(person);
    }
    }
    }

运行结果为：

Person{name='宋远桥'}
    Person{name='苏星河'}
    Person{name='洪七公'}
    Person{name='张二狗'}
    Person{name='张天爱'}
    Person{name='张三'}

#### **Stream****方式**  ####

等效的 Stream 流式处理代码为：

public class DemoStreamNames {
    public static void main(String[] args) {
    List<String> one = List.of("迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子", "洪七
    公");
    List<String> two = List.of("古力娜扎", "张无忌", "张三丰", "赵丽颖", "张二狗", "张天爱",
    "张三");
    // 第一个队伍只要名字为3个字的成员姓名；
    // 第一个队伍筛选之后只要前3个人；
    Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
    // 第二个队伍只要姓张的成员姓名；
    // 第二个队伍筛选之后不要前2个人；
    Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);
    // 将两个队伍合并为一个队伍；
    // 根据姓名创建Person对象；
    // 打印整个队伍的Person对象信息。
    Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
    }
    }

运行效果完全一样：

Person{name='宋远桥'}
    Person{name='苏星河'}
    Person{name='洪七公'}
    Person{name='张二狗'}
    Person{name='张天爱'}
    Person{name='张三'}

[cc354b15c2ed4e5b9d90a9c145df4fa3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1cfac44886644a4398d03b3dae0669eb.png
[bc89db620c8942108a9c594f57325929.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9c0ea8ffd65546a9a98bc4639138653a.png
[916a53de3e224a79ba116d416a2b703c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8b4075af17024c8fbec3c3b828ad2084.png
[276fbb7ab08049a1825ecfb37c045555.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0354672c0e254fe7ad25bad32981d359.png
[ea3cbd24b5fc419289b1ed5395eb209d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8d40480435f642bea79e7fd7b9d8c887.png
[2c7edef37b6d448eabcce02a4634ec8d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f030edb718ac448d93925e3b879a9b2f.png
[d51aaf8e99dd4b0fbd6791a60a24aede.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/09788fa5de2a4968a1336c656ab36080.png
[ec504b626b4a4de1942856a54eca83eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/675c1a2c740c4fa195f37d4df1dacbf7.png
[589bae70bdba4a9e8c437821f86394d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/46333a01eca94e8c85a2809efb793249.png
[e681be7a6f39428ca57e4d3dc4211eb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b4585bfa18184c2d8f3ac0fb9279074a.png
[9065de6e0adf45b5b498a0dd0dd78577.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f853bcfbb3bb4745801a595160c27e0e.png
[5d628fa637354846875cd6e2a7a5398c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1c1a4db15c16458889e0ab795b216996.png
[05904fd22ae344b7b9df873fadf5d8ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4fdb2fae77f9437ab02d8aa1869c8c77.png