JAVA--流（Stream）的使用

一、概念

JDK8新特性，简单方便的对集合和数组进行处理。

Stream（流）是一个来自数据源的元素队列

• 数据源：流的来源，指的是集合或数组

• 元素队列：元素是特定类型的对象，形成一个队列

• Stream 并不会存储元素，而是根据需要进行处理，如filter、map、skip等

• Stream流有以下两个操作，都提供了相关的 API 方法

  • 延迟操作：对 Stream 进行一系列的中间操作，但不会被马上执行，等待终结操作才会一次性被执行
  • 终结操作：终结操作后，则一系列的延迟操作被执行，并产生相应的结果，流就被关闭了

1 2 3

+--------------------+ +------+ +------+ +---+ +-------+ | stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect| +--------------------+ +------+ +------+ +---+ +-------+

二、特点

• Stream API 旨在让编码更高效率、干净、简洁

• 提供了一种函数式编程的方式来操作集合

  • API 方法 + Lambda表达式、方法引用

三、操作步骤

第一：定义数据源（集合、数组）

第二：把数据源转换为流（Stream）

• 集合对象

  • 顺序流：集合对象.stream()
  • 并行流：集合对象.parallelStream()

• 数组对象

  • Arrays.stream(数组)
  • Stream.of(元素集合|数组)

• 创建无限流

  • 迭代：Stream.iterate(final T seed,final UnaryOperator<T> f)
  • 生成：Stream.generate(Supplier<T> s)

第三：操作（API）

• 进行一个或多个中间操作;
• 使用终止操作产生一个结果,Stream 就不会再被使用了。

四、获取流

1、集合对象

在java.util.Collection接口中，加入了默认方法stream()用于获取流，因此所有实现类都可以通过此方法获取流。

语法一：顺序流

Stream<数据类型> 流对象 = 集合对象.stream() ;

语法二：并行流

Stream<数据类型> 流对象 = 集合对象.parallelStream() ;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// 第一：定义数据源（集合、数组） List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);// 第二：把数组或集合转换为流对象 // 1）获取顺序流 Stream<Integer> stream1 = list.stream();// 2）获取并行流 Stream<Integer> stream2 = list.parallelStream();// 其它集合，获取流对象 // 1、Set集合 Set<String> c2 = new HashSet() ; Stream<String> s2 = c2.stream() ;// 2、Map合集 Map<Integer,String> c3 = new HashMap<>() ; // 2.1、键的集合 Stream<Integer> s3 = c3.keySet().stream(); // 2.2、值的集合 Stream<String> s4 = c3.values().stream(); // 2.3、键值对的集合 Set<Map.Entry<Integer, String>> entries = c3.entrySet(); Stream<Map.Entry<Integer, String>> s5 = entries.stream();

2、数组对象

在java.util.stream.Stream<T>中，提供了静态方法of可以获取数组对应的流。

语法一：

Stream<数据类型> 流对象 = Arrays.stream(元素集合|数组) ;

语法二：

Stream<数据类型> 流对象 = Stream.of(元素集合|数组) ;

1 2 3 4 5 6 7 8 9 10

String[] arr = {"aa","bb","cc"} ;// 1.使用 Arrays 获取流对象 Stream<String> stream1 = Arrays.stream(arr) ;// 2.使用 Stream 获取流对象 Stream<String> stream2 = Stream.of(arr);// 3.通过元素集合，获取流对象 Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5);

3、创建无限流

迭代

public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)

生成

public static<T> Stream<T> generate(Supplier<T> s)

1 2 3 4 5 6 7 8 9 10 11 12

// 1.获取流对象，流对象的元素从0开始，每迭代一次加2 - T apply(T t); Stream stream = Stream.iterate(0,t -> t + 2);// 2.获取流的前面 10 个元素 - limit方法对流进行截取，截取前面 N 个元素 stream.limit(10).forEach(System.out::println);// 生成一个产生10以内随机数的流对象 - T get(); Stream stream = Stream.generate(()->new Random().nextInt(10));// 获取流的前面 10 个元素 - limit方法对流进行截取，截取前面 N 个元素 stream.limit(10).forEach(System.out::println);

五、常用API方法

在JDK中，提供了非常丰富的API方法，主要分为以下两类：

1、延迟方法

返回值类型仍然为Stream接口自身类型的方法，因此支持链式调用，如：

1）筛选与切片

• filter：过滤满足条件的元素
• limit(N)：获取 Stream 中前面的N个元素
• skip(N)：跳过 Stream 中前面的N个元素
• distinct：去重

2）映射

• map：把一个 T 类型转换（映射）为一个 R 类型的流
• mapToDouble：把一个 T 类型的流 转换为 另一个 Double 类型流
• mapToInt：把一个 T 类型的流 转换为 另一个 int 类型流
• mapToLong：把一个 T 类型的流 转换为 另一个 Long 类型流
• flatMap：将流中的每个元素转换为另一个流，然后将这些流合并成一个流

3）排序

• sorted

• sorted(Comparator comparator)

• 组合：concat：把两个流合并为一个流 - Stream.concat(stream1, stream2);

2、终结方法

返回值类型不再是Stream接口自身类型的方法。如：

1）遍历

forEach：逐一处理

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

• 该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
• Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据。

2）匹配与查找

• allMatch：检查是否匹配所有元素
• anyMatch：检查是否至少匹配一个元素
• noneMath：检查是否没有匹配所有元素

3）查找

• findFirst：返回第一个元素
• findAny：返回当前流中的任意元素

4）统计

• count：返回流中元素的总数
• max：返回流中最大值
• min：返回流中最小值

5）归约

归约是指将流中的元素按照指定的规则逐个进行操作，最终将它们归约（或者合并）为一个最终结果的过程。

归约操作可以是求和、求积、找出最大值或最小值等。

1 2 3 4 5

// 返回 T T reduce(T identity, BinaryOperator<T> accumulator);// 返回 Optional<T> Optional<T> reduce(BinaryOperator<T> accumulator);

6）收集

收集器（Collector）是一种用于将流中的元素收集到一个结果容器中，以便后续的处理和操作。

collect(Collectors.xxx)

6.1）收集 Stream 流中的数据到集合中

toList、toSet、toCollection

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// 第一：定义数据源，并获取对应的流对象 Stream<String> stream = Stream.of("AA","BB","AA","CC") ;// 第二：操作 - 收集流中的数据 // 1.收集流中的数据到List集合中 List<String> list = stream.collect(Collectors.toList());// 2.收集流中的数据到Set集合中 Set<String> set = stream.collect(Collectors.toSet());// 3.收集流中的数据到指定的集合（ArrayList）中 ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));// 4.收集流中的数据到指定的集合（HashSet）中 HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));

6.2）收集 Stream 流中的数据到数组中

• Object[] toArray();
  • 使用无参，收集到数组,返回值为 Object[]（Object类型将不好操作）
• <A> A[] toArray(IntFunction<A[]> generator);
  • 使用有参，可以指定将数据收集到指定类型数组,方便后续对数组的操作

1 2 3 4 5 6 7

// 第一：定义数据源，并获取对应的流对象 List<String> list = Arrays.asList("AA", "BB", "AA", "CC");// 第二：操作 - 收集流中的数据 Object[] objects = list.stream().toArray();String[] strings = list.stream().toArray(String[]::new);

6.3）聚合操作

类似于数据库的聚合函数。

• 最大值： Collectors.maxBy();
• 最小值： Collectors.minBy();
• 总和
  • Collectors.summingInt();
  • Collectors.summingDouble();
  • Collectors.summingLong();
• 平均值
  • Collectors.averagingInt();
  • Collectors.averagingDouble();
  • Collectors.averagingLong();
• 总个数：Collectors.counting();

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// 第一：定义数据源，并获取对应的流对象 List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);// 第二：操作 - 收集流中的数据 // 1.最大值 Optional<Integer> maxOptional1 = list.stream().collect(Collectors.maxBy((o1, o2) -> o1 - o2)); System.out.println("最大值："+maxOptional1.get());// Stream流的max方法也可以实现 Optional<Integer> maxOptional2 = list.stream().max((o1, o2) -> o1 - o2); System.out.println("最大值："+maxOptional2.get());// 2.最小值 Optional<Integer> minOptional1 = list.stream().collect(Collectors.minBy((o1, o2) -> o1 - o2)); System.out.println("最小值："+minOptional1.get());// Stream流的min方法也可以实现 Optional<Integer> minOptional2 = list.stream().min((o1, o2) -> o1 - o2); System.out.println("最小值："+minOptional2.get());// 3.总数 Integer sum1 = list.stream().collect(Collectors.summingInt(d -> d)); System.out.println("总数："+sum1);Integer sum2 = list.stream().reduce(0, (a, b) -> a + b); System.out.println("总数："+sum2);// 4.平均值 Double avg = list.stream().collect(Collectors.averagingInt(d -> d)); System.out.println("平均数："+avg);// 5.统计数量 Long count = list.stream().collect(Collectors.counting()); System.out.println("数量为："+count);

6.4）数据分组操作

类似SQL Server中的group by，根据需要可以根据某个属性来将数据进行分组。

• 接收一个 Function 参数

1	groupingBy(Function<? super T, ? extends K> classifier)

• 多级分组操作，接收两个参数：
  • Function 参数
  • Collector多级分组

1	groupingBy(Function<? super T, ? extends K> classifier,Collector<? super T, A, D> downstream)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 第一：定义数据源，并获取对应的流对象 Student s1 = new Student("张三","男",18,55) ; Student s2 = new Student("李四","女",28,63) ; Student s3 = new Student("王五","男",38,50) ; Student s4 = new Student("赵六","女",48,99) ; List<Student> list = Arrays.asList(s1,s2,s3,s4);// 第二：操作 - 收集流中的数据 // 1.根据性别分组 Map<String, List<Student>> map = list.stream().collect(Collectors.groupingBy(s -> s.getSex()));// key:分组字段，value:分组结果 map.forEach((key,value)->{System.out.println(key+":"+value); });// 2.根据分数分组 list.stream().collect(Collectors.groupingBy(stu-> {if (stu.getScore() >= 60) {return "及格";}return "不及格"; })).forEach((key,value)-> System.out.println(key+"："+value));

6.5）数据分区操作

将集合其分解成两个子集合。我们通过使用 Collectors.partitioningBy() ，根据返回值是否为 true，把集合分为两个列表，一个 true 列表，一个 false 列表。

分组和分区的区别就在：分组可以有多个组。分区只会有两个区（true 和 false）

• .一个参数

  1	partitioningBy(Predicate<? super T> predicate)

• 两个参数（多级分区）

  1	partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// 第一：定义数据源，并获取对应的流对象 Student s1 = new Student("张三","男",18,55) ; Student s2 = new Student("李四","女",28,63) ; Student s3 = new Student("王五","男",38,50) ; Student s4 = new Student("赵六","女",48,99) ; List<Student> list = Arrays.asList(s1,s2,s3,s4);// 第二：操作 - 分区操作 Map<Boolean, List<Student>> map = list.stream().collect(Collectors.partitioningBy(s -> s.getScore() >= 60) );map.forEach((k,v)->{System.out.println(k + ":"+v); });

6.6）数据拼接操作

• 无参数

  1 2	// 等价于 joining(""); Collectors.joining()

• 一个参数

  1	Collectors.joining(CharSequence delimiter)

• 三个参数（前缀 + 后缀）

  1	Collectors.joining(CharSequence delimiter, CharSequence prefix,CharSequence suffix)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// 第一：定义数据源，并获取对应的流对象 Student s1 = new Student("张三","男",18,55) ; Student s2 = new Student("李四","女",28,63) ; Student s3 = new Student("王五","男",38,50) ; Student s4 = new Student("赵六","女",48,99) ; List<Student> list = Arrays.asList(s1,s2,s3,s4);// 第二：操作 - 拼接操作 // 1.无参:join() String str1 = list.stream().map(s -> s.getName()).collect(Collectors.joining()); System.out.println(str1);// 2.一个参数:joining(CharSequence delimiter) String str2 = list.stream().map(s -> s.getName()).collect(Collectors.joining(",")); System.out.println(str2);// 3.三个参数:joining(CharSequence delimiter, CharSequence prefix,CharSequence suffix) String str3 = list.stream().map(s -> s.getName()).collect(Collectors.joining(",","[","]")); System.out.println(str3);