devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中的Stream流

作者：Gausst松鼠会 | 2024-03-26 23:24:52

赞

踩

Java中的Stream流

一、介绍

1. Stream流的作用

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

2. Stream流的使用步骤

①先得到一条Stream流，并把数据放上去；

获取方式方法名说明
单列集合default Stream<E> stream()Collection中的默认方法
双列集合无无法直接使用stream流
数组public static <T> Stream<T> stream(T[] array)Arrays工具类中的静态方法
一堆零散数据public static <T> Stream<T> of(T…values)Stream接口中的静态方法
(1)单列集合：
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.function.Consumer;
  4. import java.util.stream.Stream;
  5.  
  6. public class StreamDemo2 {
  7.     public static void main(String[] args) {
  8.         // 1. 单列集合获取Stream流
  9.         ArrayList<String> list = new ArrayList<>();
  10.         Collections.addAll(list, "a", "b", "c", "d", "e");
  11.         /*// 获取一条流水线，并把集合中的数据放到流水线上
  12.         Stream<String> stream1 = list.stream();
  13.         // 使用终结方法打印一条流水线上的所有数据
  14.         stream1.forEach(new Consumer<String>() {
  15.             @Override
  16.             public void accept(String s) {
  17.                 // s：依次表示流水线上的每一个数据
  18.                 System.out.println(s);
  19.             }
  20.         });*/
  21.  
  22.         // 链式编程
  23.         list.stream().forEach(s -> System.out.println(s));
  24.     }
  25. }

(2)双列集合
  1. import java.util.HashMap;
  2.  
  3. public class StreamDemo3 {
  4.     public static void main(String[] args) {
  5.         // 双列集合
  6.         // 1. 创建双列集合
  7.         HashMap<String, Integer> hm = new HashMap<>();
  8.         // 2. 添加数据
  9.         hm.put("aaa", 111);
  10.         hm.put("bbb", 222);
  11.         hm.put("ccc", 333);
  12.         hm.put("ddd", 444);
  13.         hm.put("eee", 555);
  14.         // 3. 第一种方式 获取stream流
  15.         hm.keySet().stream().forEach(s -> System.out.println(s));
  16.         // 4. 第二种方式 获取stream流
  17.         hm.entrySet().stream().forEach(s -> System.out.println(s));
  18.  
  19.     }
  20. }

(3)数组
  1. import java.util.Arrays;
  2. import java.util.stream.Stream;
  3.  
  4. public class StreamDemo4 {
  5.     public static void main(String[] args) {
  6.         // 数组获取stream流
  7.  
  8.         // 1. 创建数组
  9.         int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  10.  
  11.         String[] arr2 = {"a", "b", "c"};
  12.         // 2. 获取stream流
  13.         Arrays.stream(arr1).forEach(s -> System.out.println(s));
  14.  
  15.         System.out.println("----------------------------------");
  16.  
  17.         Arrays.stream(arr2).forEach(s -> System.out.println(s));
  18.  
  19.         // 注意：
  20.         // Stream接口中静态方法of的细节
  21.         // 方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组
  22.         // 但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当作一个元素，放到stream当中。。
  23.         Stream.of(arr1).forEach(s -> System.out.println(s));  // [I@214c265e
  24.         Stream.of(arr2).forEach(s -> System.out.print(s + " "));  // a b c 
  25.     }
  26. }

(4)一堆零散数据
  1. import java.util.stream.Stream;
  2.  
  3. public class StreamDemo5 {
  4.     public static void main(String[] args) {
  5.         // 一堆零散数据获取stream流
  6.  
  7.         Stream.of(1, 2, 3, 4, 5).forEach(s -> System.out.println(s));
  8.  
  9.         Stream.of("a", "b", "c", "d", "e").forEach(s -> System.out.println(s));
  10.     }
  11. }

②利用中间方法对流水线上的数据进行各种操作；

注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程

注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据

名称说明
Stream<T> filter(Predicate<? super<T> predicate)过滤
Stream<T> limit(long maxSize)获取前几个元素
Stream<T> skip(long n)跳过前几个元素
Stream<T> distinct()元素去重，依赖(hashCode和equals方法)
static<T> Stream<T> concat(Stream a, Stream b)合并a和b两个流为一个流
Stream<R> map(Function<T, R> mapper)转换流中的数据类型
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.stream.Stream;
  4.  
  5.  
  6. public class StreamDemo6 {
  7.     public static void main(String[] args) {
  8.         ArrayList<String> list = new ArrayList<>();
  9.         Collections.addAll(list, "张无忌", "张无忌", "张无忌", "周芷若", "赵敏", "张强", "张三丰");
  10.  
  11.         // 1. fliter 过滤 把以”张“开头的留下，其余数据过滤不要
  12.         /*list.stream().filter(new Predicate<String>() {
  13.             @Override
  14.             public boolean test(String s) {
  15.                 // 如果返回值为true，表示当前数据留下
  16.                 // 如果返回真为false，表示当前数据舍弃不要
  17.                 return s.startsWith("张");
  18.             }
  19.         }).forEach(s -> System.out.println(s));*/
  20.  
  21.         list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
  22.         System.out.println("------------------------------");
  23.         System.out.println(list);  // 注意：修改Stream流中的数据，不会影响原理集合或者数组中的数据
  24.         System.out.println("------------------------------");
  25.  
  26.         /*Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));
  27.         Stream<String> stream2 = stream1.filter(s -> s.length() == 3);
  28.         stream2.forEach(s -> System.out.println(s));
  29.         Stream<String> stream3 = stream1.filter(s -> s.length() == 3);  // java.lang.IllegalStateException*/
  30.  
  31.         // 2. limit 获取前几个元素
  32.         list.stream().limit(3).forEach(s -> System.out.println(s));
  33.         System.out.println("------------------------------");
  34.  
  35.         // 3. skip 跳过前几个元素
  36.         list.stream().skip(3).forEach(s -> System.out.println(s));
  37.         System.out.println("------------------------------");
  38.  
  39.         // 4. distinct 元素去重
  40.         list.stream().distinct().forEach(s -> System.out.println(s));
  41.         System.out.println("------------------------------");
  42.  
  43.         // 5. concat 合并a和b两个流为一个流
  44.         ArrayList<String> list2 = new ArrayList<>();
  45.         Collections.addAll(list2, "周芷若", "赵六");
  46.         Stream.concat(list.stream(), list2.stream()).forEach(s -> System.out.println(s));
  47.         System.out.println("------------------------------");
  48.  
  49.         // 6. map 转换流中的数据类型
  50.         ArrayList<String> list3 = new ArrayList<>();
  51.         Collections.addAll(list3, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35");
  52.         // 只获取里面的年龄并进行打印
  53.         // 当map方法执行完毕后，流上的数据就变成了整数
  54.         // 所以再下面的foreach当中，s一次表示流里面的每一个数据，这个数据现在就是整数了
  55.         /*list3.stream().map(new Function<String, Object>() {
  56.             @Override
  57.             public Object apply(String s) {
  58.                 String[] arr = s.split("-");
  59.                 String ageString = arr[1];
  60.                 int age = Integer.parseInt(ageString);
  61.                 return age;
  62.             }
  63.         }).forEach(s -> System.out.println(s));
  64.         System.out.println("------------------------------");*/
  65.  
  66.         list3.stream()
  67.                 .map(s -> Integer.parseInt(s.split("-")[1]))
  68.                 .forEach(s -> System.out.println(s));
  69.     }
  70. }

③使用终结方法对流水线上的数据进行操作

名称说明
void forEach(Consumer action)遍历
long count()统计
toArray()收集流中的数据，放到数组中
collect(Collecctor collector)收集流中的数据，放到集合中
  1. import java.util.*;
  2. import java.util.function.Function;
  3. import java.util.function.IntFunction;
  4. import java.util.stream.Collectors;
  5.  
  6. public class StreamDemo7 {
  7.     public static void main(String[] args) {
  8.         ArrayList<String> list = new ArrayList<>();
  9.         Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
  10.  
  11.         // 1. forEach 遍历
  12.         // Consumer的泛型：表示流中数据的类型
  13.         // accept方法的形参s：依次表示流里面的每一个数据
  14.         // 方法体：对每一个数据的处理操作（打印）
  15.        /* list.stream().forEach(new Consumer<String>() {
  16.             @Override
  17.             public void accept(String s) {
  18.                 System.out.println(s);
  19.             }
  20.         });*/
  21.  
  22.         list.stream().forEach(s -> System.out.println(s));
  23.         System.out.println("--------------------------");
  24.  
  25.         // 2. count 统计
  26.         long count = list.stream().count();
  27.         System.out.println(count);
  28.         System.out.println("--------------------------");
  29.  
  30.         // 3. toArray 收集流中的数据放到数组中
  31.         Object[] arr1 = list.stream().toArray();
  32.         System.out.println(Arrays.toString(arr1));
  33.         System.out.println("--------------------------");
  34.  
  35.         // IntFunction的泛型：具体类型的数组
  36.         // apply的形参：流中的数据的个数，要跟数组的长度保持一致
  37.         // apply方法的返回值：具体类型的数组
  38.         // 方法体：就是创建数组
  39.  
  40.         // toArray方法的参数的作用：负责创建一个指定类型的数组
  41.         // toArray方法的底层：会依次得到流里面的每一个数据，并把数据放到数组当中
  42.         // toArray方法的返回值：是一个装着流里面所有数据的数组
  43.        /* String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
  44.             @Override
  45.             public String[] apply(int value) {
  46.                 return new String[value];
  47.             }
  48.         });
  49.         System.out.println(Arrays.toString(arr2));
  50.         System.out.println("--------------------------");*/
  51.  
  52.         String[] arr3 = list.stream().toArray(value -> new String[value]);
  53.         System.out.println(Arrays.toString(arr3));
  54.         System.out.println("--------------------------");
  55.  
  56.  
  57.         // 4. 收集到List集合当中
  58.         // 需求：把所有的男性收集起来
  59.         ArrayList<String> list2 = new ArrayList<>();
  60.         Collections.addAll(list2, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20", "张三丰-男-100", "张翠山-男-40", "张良-男-35");
  61.         List<String> newList = list2.stream()
  62.                 .filter(s -> "男".equals(s.split("-")[1]))
  63.                 .collect(Collectors.toList());
  64.         System.out.println(newList);
  65.         System.out.println("--------------------------");
  66.  
  67.         // 4. 收集到Set集合当中
  68.         // 需求：把所有的男性收集起来
  69.         Set<String> newSet = list2.stream().filter(s -> "男".equals(s.split("-")[1]))
  70.                 .collect(Collectors.toSet());  // 会自动去重
  71.         System.out.println(newSet);
  72.         System.out.println("--------------------------");
  73.  
  74.         // 4. 收集到Map集合当中
  75.         // 谁作为键，谁作为值。把所有的男性收集起来
  76.         // 键：姓名 值：年龄
  77.         // 注意点：如果我们要收集数据到Map当中，键是不能重复的
  78.        /* Map<String, Integer> newMap = list2.stream()
  79.                 .filter(s -> "男".equals(s.split("-")[1]))
  80.                 *//*
  81.                 toMap:参数一：键的生成规则。参数二：值的生成规则
  82.                 参数一：Function泛型一：表示流中每一个数据的类型
  83.                                泛型二：表示Map集合中键的数据类型
  84.                        方法apply形参：依次表示流里面的每一个数据
  85.                                方法体：生成键的代码
  86.                                返回值：已经生成的键
  87.                 参数二：Function泛型一：表示流中每一个数据的类型
  88.                                泛型二：表示Map集合中值的数据类型
  89.                        方法apply形参：依次表示流里面的每一个数据
  90.                                方法体：生成值的代码
  91.                                返回值：已经生成的值
  92.                  *//*
  93.                 .collect(Collectors.toMap(new Function<String, String>() {
  94.                                               @Override
  95.                                               public String apply(String s) {
  96.                                                   return s.split("-")[0];  // 姓名
  97.                                               }
  98.                                           },
  99.                         new Function<String, Integer>() {
  100.                             @Override
  101.                             public Integer apply(String s) {
  102.                                 return Integer.parseInt(s.split("-")[2]);
  103.                             }
  104.                         }));
  106.         System.out.println(newMap);
  107.         System.out.println("--------------------------");*/
  108.         // lambda表达式
  109.         Map<String, Integer> map2 = list2.stream()
  110.                 .filter(s -> "男".equals(s.split("-")[1]))
  111.                 .collect(Collectors.toMap(
  112.                         s -> s.split("-")[0]
  113.                         ,
  114.                         s -> Integer.parseInt(s.split("-")[2])
  115.                 ));
  116.         System.out.println(map2);
  117.     }
  118. }

二、案例分析

1. 要求：按照下面的要求完成集合的创建和遍历。

①把所有以“张”开头的元素存储到新集合中；

②把“张”开头的，长度为3的元素再存储到新集合中；

③遍历打印最终结果。

  1. import java.util.ArrayList;
  2.  
  3. public class StreamDemo1 {
  4.     public static void main(String[] args) {
  5.         ArrayList<String> list = new ArrayList<>();
  6.         list.add("张无忌");
  7.         list.add("周芷若");
  8.         list.add("赵敏");
  9.         list.add("张强");
  10.         list.add("张三丰");
  11.  
  12.         list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
  13.         // 张无忌
  14.         // 张三丰
  15.     }
  16. }

2.  数据过滤

        定义一个集合，并添加一些数据1，2，3，4，5，6，7，8，9，10。过滤奇数，只留下偶数，并将结果保存起来。

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4. import java.util.stream.Collectors;
  5.  
  6. public class StreamDemo8 {
  7.     public static void main(String[] args) {
  8.         /*
  9.         定义一个集合，并添加一些数据1，2，3，4，5，6，7，8，9，10。
  10.         过滤奇数，只留下偶数，并将结果保存起来。
  11.         */
  12.  
  13.         // 1. 定义一个集合
  14.         ArrayList<Integer> list = new ArrayList<>();
  15.         // 2. 添加一些数据
  16.         Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  17.         // 3. 过滤奇数，只留下偶数
  18.         // 进行判断，如果是偶数，返回true保留
  19.         List<Integer> newList = list.stream()
  20.                 .filter(n -> n % 2 == 0)
  21.                 .collect(Collectors.toList());
  22.         // 4. 打印集合
  23.         System.out.println(newList);
  24.     }
  25. }

3. 数据操作

        创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄。”zhangsan, 23", "lisi, 24", "wangwu, 25"。保留年龄大于等于24岁的人，并将结果收到到Map集合中，姓名为键，年龄为值。

  1. import java.util.ArrayList;
  2. import java.util.Map;
  3. import java.util.stream.Collectors;
  4.  
  5. public class StreamDemo9 {
  6.     public static void main(String[] args) {
  7.         /*
  8.         创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，
  9.         后面是年龄。”zhangsan, 23", "lisi, 24", "wangwu, 25"。
  10.         保留年龄大于等于24岁的人，并将结果收到到Map集合中，
  11.         姓名为键，年龄为值。
  12.          */
  13.  
  14.         // 1. 创建一个ArrayList集合
  15.         ArrayList<String> list = new ArrayList<>();
  16.         // 2. 添加以下字符串
  17.         list.add("zhangsan, 23");
  18.         list.add("lisi, 24");
  19.         list.add("wangwu, 25");
  20.         // 3. 保留年龄大于等于24岁的人
  21.         Map<String, Integer> map = list.stream()
  22.                 .filter(s -> Integer.parseInt(s.split(", ")[1]) >= 24)
  23.                 .collect(Collectors.toMap(
  24.                         s -> s.split(", ")[0],
  25.                         s -> Integer.parseInt(s.split(", ")[1])));
  26.         System.out.println(map);
  27.     }
  28. }

4. 数据操作

        现有两个ArrayList集合，第一个集合：存储6名男演员的名字和年龄。第二个集合：存储6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如，张三，23。

        要求完成下面的操作：①男演员只要名字为3个字的前两个人；②女演员只要姓杨的，并且不要第一个；③把过滤后的男演员姓名和女演员姓名合并到一起；④将上一步的演员信息封装成Actor对象；⑤将所有的演员对象都保存到List集合中。

备注：演员类Actor，属性只有一个：name，age

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4. import java.util.function.Function;
  5. import java.util.stream.Collectors;
  6. import java.util.stream.Stream;
  7.  
  8. public class StreamDemo10 {
  9.     public static void main(String[] args) {
  10.         /*
  11.         现有两个ArrayList集合，第一个集合：存储6名男演员的名字和年龄。
  12.         第二个集合：存储6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如，张三，23。
  13.         要求完成下面的操作：①男演员只要名字为3个字的前两个人；
  14.         ②女演员只要姓杨的，并且不要第一个；
  15.         ③把过滤后的男演员姓名和女演员姓名合并到一起；
  16.         ④将上一步的演员信息封装成Actor对象；⑤将所有的演员对象都保存到List集合中。
  17.         备注：演员类Actor，属性只有一个：name，age
  18.          */
  19.  
  20.         // 1. 创建两个ArrayList集合
  21.         ArrayList<String> manList = new ArrayList<>();
  22.         ArrayList<String> womenList = new ArrayList<>();
  23.         // 2. 添加数据
  24.         Collections.addAll(manList, "小小蔡, 24", "小小叶, 23", "小小刘, 22", "小吴, 25", "小小谷, 23", "小李, 26");
  25.         Collections.addAll(womenList, "杨小甜, 23", "杨小小, 21", "杨小鞠, 22", "小单, 24", "刘小陈, 22", "小小曲, 23");
  26.         // 3. 男演员只要名字为3个字的前两个人
  27.         Stream<String> stream1 = manList.stream()
  28.                 .filter(s -> s.split(", ")[0].length() == 3)
  29.                 .limit(2);
  30.  
  31.         // 4. 女演员只要姓杨的，并且不要第一个
  32.         Stream<String> stream2 = womenList.stream()
  33.                 .filter(s -> s.split(", ")[0].startsWith("杨"))
  34.                 .skip(1);
  35.  
  36.         // 5. 把过滤后的男演员姓名和女演员姓名合并到一起
  37.         // 6. 将上一步的演员信息封装成Actor对象(类型转换）
  38.         /*Stream.concat(stream1, stream2).map(new Function<String, Actor>() {
  39.             @Override
  40.             public Actor apply(String s) {
  41.                 String name = s.split(", ")[0];
  42.                 int age = Integer.parseInt(s.split(", ")[1]);
  43.                 return new Actor(name, age);
  44.             }
  45.         }).forEach(s -> System.out.println(s));*/
  46.         List<Actor> list = Stream.concat(stream1, stream2)
  47.                 .map(s -> new Actor(s.split(", ")[0], Integer.parseInt(s.split(", ")[1])))
  48.                 .collect(Collectors.toList());
  49.         System.out.println(list);
  50.  
  51.     }
  52. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/320299
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号