Java Stream流指南：优雅处理集合数据

柔光的暖阳◎ 2024-05-28 10:29 94阅读 0赞

#### 文章目录 ####

*  一、为什么要使用stream流呢？
 *  二、如何获取Stream流？
 *  三、Stream流的中间方法
 *  四、Stream流的终结方法
 *  总结

## 一、为什么要使用stream流呢？ ##

想必我们在日常编程中，会经常进行数据的处理，我们先来看看没有stram流时，我们的操作方式，我们想要收集姓赵的学生姓名。

public class StreamDemo {
        
        public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵坤","张良","赵雯");
            ArrayList<String> list1 = new ArrayList<>();
            list.forEach(s -> {
        
                if(s.startsWith("赵")) {
        
                    list1.add(s);
                }
            });
            list1.forEach(s -> System.out.println(s));
        }
    }

![在这里插入图片描述][23bb573d123a4d1ca243f617beb8f984.png]

这是我们在没有接触到Stream流时的操作方法，虽然使用lambda简化写法了，但还是不够优雅。

下面我使用Stream流的方式来操作一下：

public class StreamDemo {
        
        public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵坤","张良","赵雯");
            list.stream().filter(s -> s.startsWith("赵")).forEach(s -> System.out.println(s));
        }
    }

![在这里插入图片描述][3195ecefb6774513a63dadca895e1128.png]  
使用Stream流后的操作是不是比刚开始的操作要优雅许多，大家先不用管这块代码怎么写的，我会在下面一一讲解到。

## 二、如何获取Stream流？ ##

我们可以简单理解Stream流就是一条流水线。  
![在这里插入图片描述][de0581c53735437091e3289221e81bc4.png]

**Stream流的作用：** 结合Lambda表达式，简化集合、数组的操作

**Stream流的使用步骤：**

1.  先得到一条Stream流(流水线)，并把数据放上去
2.  利用Stream流中的API进行各种操作(过滤、转换、统计、打印等)

<table> 
 <thead> 
  <tr> 
   <th>获取方式</th> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>单列集合</td> 
   <td>default Stream stream()</td> 
   <td>Collection中的默认方法</td> 
  </tr> 
  <tr> 
   <td>双列集合</td> 
   <td>无</td> 
   <td>无法直接使用stream流，需要先转为单列集合</td> 
  </tr> 
  <tr> 
   <td>数组</td> 
   <td>publis static Stream stream(T[] array)</td> 
   <td>Arrays工具类中的静态方法</td> 
  </tr> 
  <tr> 
   <td>零散数据</td> 
   <td>public static Stream of(T… values)</td> 
   <td>Stream接口中的静态方法</td> 
  </tr> 
 </tbody> 
</table>

**单列集合：**  
![在这里插入图片描述][5b03b62f5fde421faf5ef0eb008b7405.png]  
我们可以发现单列集合可以直接调用stream方法获取Stream流。  
![在这里插入图片描述][59b9afd85e2b442d8ab89b68f3bebc0f.png]  
我们使用下stream流的forEach方法，顾名思义就是打印方法。  
![在这里插入图片描述][a12297dbecdd47ffbe83a1b477f5201d.png]  
我们可以看到forEach方法的参数是一个函数式接口，所以我们可以使用lambda表达式简化，我们先写一下匿名内部类的写法:

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵坤","张良","赵雯");
            Stream<String> stream = list.stream();
            stream.forEach(new Consumer<String>() {
        
                @Override
                public void accept(String s) {
        
                    System.out.println(s);
                }
            });
        }

然后我们在使用lambda表达式对匿名内部类进行简化：

![在这里插入图片描述][bae03f80092147ee8e91ab785ab64ac3.png]  
**双列集合：**  
双列集合是无法直接获取stream流的，所以我们需要先将双列集合转换为单列集合，再去进行流式操作。  
第一种方式，先将map转为Keyset:

public static void main(String[] args) {
        
            Map<String,Integer> map = new HashMap<>();
            map.put("四级",425);
            map.put("六级",425);
            map.put("考研",436);
            // 1.第一种获取stream流方式
            map.keySet().stream().forEach(s -> {
        
                System.out.println(s + ": " + map.get(s));
            });
        }

第二种方式，转为EntrySet：

// 2.第二种获取stream方式
            map.entrySet().stream().forEach(s -> System.out.println(s));

![在这里插入图片描述][7482bcb3fef64eb78ce8545dcad45227.png]  
**数组：**

public static void main(String[] args) {
        
            int[] arr = {
        2,9,3,74,2,1};
            // 使用Arrays中的stream方法获取stream流
            Arrays.stream(arr).forEach(s -> System.out.println(s));
        }

![在这里插入图片描述][dc7e10d5f78c4f6880b470d88cf2aad8.png]  
**零散数据：**  
零散数据使用Stream.of()方法获取stream流：

public static void main(String[] args) {
        
            Stream.of(1,2,4,3,2,5).forEach(s -> System.out.println(s));
        }

![在这里插入图片描述][ed32870f9ee54b17b9962d22bb08986c.png]  
**需要注意的坑：**  
![在这里插入图片描述][8a63c0b046ea4982873ce29427133085.png]  
我们来看Stream.of()方法的参数是泛型可变参数，那证明可以接受数组数据，我们一起来试一下  
![在这里插入图片描述][4da970be88c04ff3ab234603d0418ab8.png]  
当我们传入的数据是引用数据类型的时候是可以正常操作的，我们再来试试基本数据类型的数组  
![在这里插入图片描述][64ced08fc4294f978babc47cecc404f6.png]  
当我们传入基本数据类型时，发现打印的是地址，当我们使用Stream.of()方法传入基本数据类型的数组获取stream流时，是将整个数据当作一个元素的

## 三、Stream流的中间方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Stream filter(Predicate&lt;? super T&gt; predicate)</td> 
   <td>过滤</td> 
  </tr> 
  <tr> 
   <td>Stream limit(long maxSize)</td> 
   <td>获取前几个元素</td> 
  </tr> 
  <tr> 
   <td>Stream skip(long n)</td> 
   <td>跳过前几个元素</td> 
  </tr> 
  <tr> 
   <td>Stream distinct()</td> 
   <td>元素去重，底层使用hashset去重</td> 
  </tr> 
  <tr> 
   <td>static Stream concat(Stream a,Stream b)</td> 
   <td>合并a和b两个流为一个流</td> 
  </tr> 
  <tr> 
   <td>Stream map(Function&lt;T,R&gt; mapper)</td> 
   <td>转换流中的数据类型</td> 
  </tr> 
 </tbody> 
</table>

**注意点：**

1.  中间方法，返回新的Stream流，原来的Stream流只能使用一次，一般使用链式编程
2.  修改Stream流中的数据，不会影响原来集合中的数据

**filter方法：**  
我们还是以最开始的例子来讲解  
![在这里插入图片描述][e1bac33ca8e4456db119a904a578150c.png]  
我们可以看到filiter方法的参数是一个函数式接口，所以我们可以使用lambda表达式简化写法。

而且我们的stream流只能使用一次。  
![在这里插入图片描述][4c5deec1687a4094a420a2d1f7f2bab0.png]  
当我们第二次去使用stream流时，报了IllegalStateException，意思stream流已经关闭

**limit方法：**  
limit方法代表获取前几个元素

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵坤","张良","赵雯");
            // 获取前三个元素
            list.stream().limit(3).forEach(s -> System.out.println(s));
        }

![在这里插入图片描述][23ae3d5ebae048d6aedd16c9806989dd.png]  
**skip方法：**  
skip方法代表跳过几个元素

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵坤","张良","赵雯");
            // 跳过前两个元素
            list.stream().skip(2).forEach(s -> System.out.println(s));
        }

![在这里插入图片描述][b64e37441fa9421bbd258782e391e770.png]  
**distinct方法：**  
distinct方法代表去除重复元素

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵子龙","张良","赵雯");
            // 去重数据
            list.stream().distinct().forEach(s -> System.out.println(s));
        }

![在这里插入图片描述][d88b8eeaebf94e98acf344e717cebfc2.png]  
我们去看一看distinct底层是如何实现的  
![在这里插入图片描述][0870f168c3dc46ff84ad9b364aaf5d64.png]  
![在这里插入图片描述][7b5f0e6e28b543eb8a1ba47cf2bc63b1.png]  
![在这里插入图片描述][dec1571f56fd48859e59b4d874d85252.png]  
我们可以看到这个方法内容非常的多，我们可以看到这里是使用HashSet进行去重的，所以我们在使用引用数据类型需要重写equals和hashcode方法

**concat方法：**  
Stream.concat()方法代表合并两个流

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","赵子龙","张良","赵雯");
            ArrayList<String> list1 = new ArrayList<>();
            Collections.addAll(list1,"奥利奥","方便面");
            // 合并两个流对象
            Stream.concat(list.stream(),list1.stream()).forEach(s -> System.out.println(s));
        }

![在这里插入图片描述][5d6405dbedb74373b01622ab80e6d5e1.png]  
**map方法：**  
map方法转换流中的数据类型  
![在这里插入图片描述][74094404232b4cc383b4f5d33b85c4b7.png]  
默认转换为Object类型，我们可以根据自己的需要进行修改

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"111","222","333");
            list.stream().map(new Function<String, Integer>() {
        
                @Override
                public Integer apply(String s) {
        
                    return Integer.parseInt(s);
                }
            }).forEach(s -> System.out.println(s));
        }

我们可以使用lambda表达式进行简写  
![在这里插入图片描述][c0fc80b8f40d493ebc744518a18158c1.png]

## 四、Stream流的终结方法 ##

Stream流的终结方法，顾名思义，调用之后就不能再调用Stream流中的其他方法了。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void forEach(Consumer action)</td> 
   <td>遍历</td> 
  </tr> 
  <tr> 
   <td>long count()</td> 
   <td>统计</td> 
  </tr> 
  <tr> 
   <td>toArray()</td> 
   <td>收集流中的数据，放到数组中</td> 
  </tr> 
  <tr> 
   <td>collect(Collector collector)</td> 
   <td>收集流中的数据，放到集合中</td> 
  </tr> 
 </tbody> 
</table>

forEach方法我们这里就不再阐述了，因为我们已经使用的很熟练了，我们来看一下count()方法：  
![在这里插入图片描述][69241d0df2af4e79b5e76509d6be7017.png]  
我们可以看到count()方法返回的是一个long的数值

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","周瑜","张良","赵雯");
            long count = list.stream().count();
            System.out.println(count);
        }

![在这里插入图片描述][f3397b3d09bc4a879d035d15eaa16624.png]  
toArray()方法，将流中的数据放入数组中：  
![在这里插入图片描述][ca24044942b840c2903bda9f5b4692eb.png]  
我们可以看到toArray()方法有两种调用方式，第一种空参，返回Object类型数组

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","周瑜","张良","赵雯");
            Object[] arr = list.stream().toArray();
            System.out.println(Arrays.toString(arr));
        }

![在这里插入图片描述][b47ef4e081084356bc7a2f0d4e066c50.png]  
然后我们来看一下传入指定类型的方法  
![在这里插入图片描述][84d28d44ea3d4f3484b7c24b0c677d1c.png]  
![在这里插入图片描述][2cbbe98b4c234f79a3d9d960538be7d0.png]  
我们可以看到toArray传入的参数是一个函数式接口，当中有一个apply方法，形参为value，我们可以理解为流中数据的个数

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","周瑜","张良","赵雯");
            String[] arr = list.stream().toArray(new IntFunction<String[]>() {
        
                @Override
                public String[] apply(int value) {
        
                    return new String[value];
                }
            });
            System.out.println(Arrays.toString(arr));
        }

我们可以使用lambda表达式进行简写

![在这里插入图片描述][60b86923623c4cdc89def2a603b3323f.png]  
collect方法，收集流中的数据，放到集合当中(List Set Map)。

将流中的数据放到List中：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","周瑜","张良","赵雯");
            // 将流中的数据放到List中
            List<String> lists = list.stream().collect(Collectors.toList());
            System.out.println(lists);
        }

![在这里插入图片描述][9987452f610845459d97a9e915a7f614.png]  
将流中的数据放到Set中：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙","猪大肠","周瑜","张良","赵雯");
            // 将流中的数据放到List中
            Set<String> set = list.stream().collect(Collectors.toSet());
            System.out.println(set);
        }

![在这里插入图片描述][50a6205a43d24e148ea6d37b098d1f01.png]  
那么将流数据放到List和Set有什么区别呢？**放入Set会进行去重操作**

将流中的数据放到Map中：  
我们再将流数据转为Map之前，我们需要弄情况，用什么做key，用什么做value  
![在这里插入图片描述][04b5d67fa1e24aa096c8b9ff01d8bf34.png]  
我们需要指定具体的key和value的规则，我们来看看具体的参数  
![在这里插入图片描述][9283dc98dcef47cfa268dfc72ccb4b8f.png]  
![在这里插入图片描述][84950acf4c2e4d36b5d0fa007a1a48f7.png]  
我们可以发现是函数式接口。  
![在这里插入图片描述][af9c202810664f08879b1272525a7b42.png]  
s就是我们流里面的数据，两个匿名内部类分别返回的是key和value

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙-18","猪大肠-21","周瑜-12","张良-16","赵雯-17");
            Map<String, Integer> map = list.stream().collect(Collectors.toMap(new Function<String, String>() {
        
                @Override
                public String apply(String s) {
        
                    return s.split("-")[0];
                }
            }, new Function<String, Integer>() {
        
                @Override
                public Integer apply(String s) {
        
                    return Integer.parseInt(s.split("-")[1]);
                }
            }));
            System.out.println(map);
        }

![在这里插入图片描述][16ca103a73944f67a867b50734e99fc5.png]  
我们使用lambda表达式进行简化：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"赵子龙-18","猪大肠-21","周瑜-12","张良-16","赵雯-17");
            Map<String, Integer> map = list.stream().collect(Collectors.toMap(s -> s.split("-")[0],s -> Integer.parseInt(s.split("-")[1])));
            System.out.println(map);
        }

![在这里插入图片描述][aedb9bacdb8b4c848ad4fafd6ac67970.png]

## 总结 ##

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

2.Stream流的使用步骤：

*  获取Stream流对象
 *  使用中间方法处理数据
 *  使用终结方法处理数据

3.如何获取Stream流对象

*  单列集合：Collection中默认的stream方法
 *  双列集合：不能直接获取，需要先转为单列集合去获取
 *  数据：Arrays工具类中的stream静态方法
 *  零散数据：Stream接口中的of静态方法

4.常见方法

*  中间方法：filter、limit、skip、distinct、concat、map
 *  终结方法：forEach、count、toArray、collect

[23bb573d123a4d1ca243f617beb8f984.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/2b0aa1be29294955b9b4ab2bdabd58e7.png
[3195ecefb6774513a63dadca895e1128.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/eb2fcea370e649de8c2d659e46e06b5c.png
[de0581c53735437091e3289221e81bc4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/8ba137e106924b84b31b33073658aa7f.png
[5b03b62f5fde421faf5ef0eb008b7405.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/a82c2c10a9704c62b4ebad5ad10a8cba.png
[59b9afd85e2b442d8ab89b68f3bebc0f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/19db33854495451e996577142055e90a.png
[a12297dbecdd47ffbe83a1b477f5201d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/869f4d72464b4d0c89c9d7204cfd7b7b.png
[bae03f80092147ee8e91ab785ab64ac3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/825f108c91f54cfbbfa168c371b476e4.png
[7482bcb3fef64eb78ce8545dcad45227.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/37f5517471fd4d47b794fb3bd1e176d7.png
[dc7e10d5f78c4f6880b470d88cf2aad8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/bd3c1686c76743448bf9656cafb28686.png
[ed32870f9ee54b17b9962d22bb08986c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/0a1c4577e0c04039b06c3c786d59e7b2.png
[8a63c0b046ea4982873ce29427133085.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/29f297e239c84a6a88a057f854a5b544.png
[4da970be88c04ff3ab234603d0418ab8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/3880733c11b24170a74e260bb0b4b7cb.png
[64ced08fc4294f978babc47cecc404f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/0b12c48d37b64316b7da50d0e8c3f84b.png
[e1bac33ca8e4456db119a904a578150c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/faf9a3a21c6545aba9ff200b92fba054.png
[4c5deec1687a4094a420a2d1f7f2bab0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/f28da6abf8e04db7bf6cba8e083fd6c8.png
[23ae3d5ebae048d6aedd16c9806989dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/49280212511e42fbbee8a3851d8acecc.png
[b64e37441fa9421bbd258782e391e770.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/6ece195daf6d4c638565ac35b07ff223.png
[d88b8eeaebf94e98acf344e717cebfc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/9bbea0e017414ee38cb8d5eb87fa797d.png
[0870f168c3dc46ff84ad9b364aaf5d64.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/f7e421c698314504afdff0b0a3b6ebdf.png
[7b5f0e6e28b543eb8a1ba47cf2bc63b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/5d94c45e882b4dc89d14c6b0f37d1ec5.png
[dec1571f56fd48859e59b4d874d85252.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/ed5814d5721b46ccae66b86fbf4701e8.png
[5d6405dbedb74373b01622ab80e6d5e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/e2a2458eb2514d14853a8eeb7f3d9128.png
[74094404232b4cc383b4f5d33b85c4b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/65d9f809381a4fad8389e4c2cefe4573.png
[c0fc80b8f40d493ebc744518a18158c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/23f666feff9d4ee5b06ed1104149dc95.png
[69241d0df2af4e79b5e76509d6be7017.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/d400e2f717b643738fa959b965a34657.png
[f3397b3d09bc4a879d035d15eaa16624.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/292cea78fff64794b16b5193b4a67456.png
[ca24044942b840c2903bda9f5b4692eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/38a5028a92bd4538b8c937d376dc31d3.png
[b47ef4e081084356bc7a2f0d4e066c50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/b19eb3ab1f0a4be6bf910d51dd73d47f.png
[84d28d44ea3d4f3484b7c24b0c677d1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/c97ac36f07234f4f8c103920744faafb.png
[2cbbe98b4c234f79a3d9d960538be7d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/5663b7442f5c488db171e6371356503c.png
[60b86923623c4cdc89def2a603b3323f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/3022daae7fcb45f5b018a5bf0324780c.png
[9987452f610845459d97a9e915a7f614.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/c6dfe272e5cf4c40a249795446292ab9.png
[50a6205a43d24e148ea6d37b098d1f01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/d94a6773e5ad46208e5c16ceb17cb385.png
[04b5d67fa1e24aa096c8b9ff01d8bf34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/bb88c3611aa44eccbc7f447dac8dd381.png
[9283dc98dcef47cfa268dfc72ccb4b8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/35d93c7dffdf400fafca79f65862639c.png
[84950acf4c2e4d36b5d0fa007a1a48f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/24fd033cfc844009bde416002ab860ef.png
[af9c202810664f08879b1272525a7b42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/b53940e55f174f9992e9493f9bbd0504.png
[16ca103a73944f67a867b50734e99fc5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/b808a6f1a4c842f2910834af799d9c89.png
[aedb9bacdb8b4c848ad4fafd6ac67970.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/28/d6eff582a2004e66bab8dfda8eeef5ad.png