JDK8新特性7——收集Stream流中的结果到数组和集合

最新推荐文章于 2024-05-19 20:39:37 发布
最新推荐文章于 2024-05-19 20:39:37 发布
阅读量5.7k 收藏 14
点赞数 3
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43318134/article/details/104442023
版权

目录

 

1. 收集Stream流中的结果到集合

1.1 收集到List集合——toList

1.2 收集到Set集合——toSet

1.3 收集到指定集合

2. 收集集合中的数据到数组中

2.1 转成Object数组——toArray

2.2 转成指定类型的数组——toArray

3. 对流中的数据的操作

3.1 对流中的数据进行聚合计算

3.1.1 获取最大值——Collectors.maxBy

3.1.2 获取最小值——Collectors.minBy

3.1.3 求和——Collectors.summingDouble

3.1.4 求平均值——Collectors.averagingDouble

3.1.5 统计数量——Collectors.counting()

3.2 对流中的数据进行分组

3.2.1 简单的分组——Collectors.groupingBy

3.2.1 多级分组——Collectors.groupingBy

3.3 对流中的数据进行分区——Collectors.partitioningBy

3.4 对流中的数据进行拼接——Collertors.joining

1. 收集Stream流中的结果到集合

        Stream流提供collect方法，其参数需要一个java.util.stream.Collector<T,A,R>接口对象来指定收集到哪种集合中。java.util.stream.Collectors类提供了一些方法，可以作为Collector接口的实例，最常用的就是静态方法toList与toSet

1.1 收集到List集合——toList

例如：

public static void testList(){
	Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
	List<String> list = stream.collect(Collectors.toList());
	System.out.println(list);
}

1.2 收集到Set集合——toSet

例如：

public static void testSet(){
	Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
    Set<String> set = stream.collect(Collectors.toSet());
    System.out.println(set);
}

1.3 收集到指定集合

例如：收集到ArrayList集合中

public static void testArrayList(){
	Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
	ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
	System.out.println(arrayList);
}

2. 收集集合中的数据到数组中

2.1 转成Object数组——toArray

例如：

public static void test2Array(){
	Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
	Object[] array = stream.toArray();
	for(Object o : array){
	    System.out.println(o);
	}
}

该方式转成Object类型的数组，我们操作起来不是很方便

2.2 转成指定类型的数组——toArray

例如：将String流转成String数组 

public static void test2Array1(){
	Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
	String[] array = stream.toArray(String[]::new);
	for(String str : array){
	    System.out.println("元素是：" + str + "  元素长度是：" + str.length());
	}
}

3. 对流中的数据的操作

3.1 对流中的数据进行聚合计算

当我们使用Stream流处理数据后，可以像数据库聚合函数一样，对某个字段进行处理，比如，获取最大值，获取最小值，求总和，平均值，统计数量等。

3.1.1 获取最大值——Collectors.maxBy

例如：

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 23, 88D),
                new Student("王五", 20, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        // 查找分数最大的student
        Optional<Student> optionalStudent = stream.collect(Collectors.maxBy((s1, s2) -> {
            return s1.getScore() - s2.getScore() > 0 ? 1 : -1;
        }));
        Student student = optionalStudent.get();
        System.out.println(student);
    }
}

3.1.2 获取最小值——Collectors.minBy

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 23, 88D),
                new Student("王五", 20, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        // 查找分数最小的student
        Optional<Student> optionalStudent = stream.collect(Collectors.minBy((s1, s2) -> {
            return s1.getScore() - s2.getScore() > 0 ? 1 : -1;
        }));
        Student student = optionalStudent.get();
        System.out.println(student);
    }
}

3.1.3 求和——Collectors.summingDouble

// 求所有分数之和
Double aDouble = stream.collect(Collectors.summingDouble(Student::getScore));

3.1.4 求平均值——Collectors.averagingDouble

// 求分数的平均值
Double aDouble = stream.collect(Collectors.averagingDouble(Student::getScore));
System.out.println(aDouble);

3.1.5 统计数量——Collectors.counting()

// 求流中一共有多少个数据
Long aLong = stream.collect(Collectors.counting());
System.out.println(aLong);

3.2 对流中的数据进行分组

当我们使用Stream流处理数据后，可以根据某个属性将数据分组

3.2.1 简单的分组——Collectors.groupingBy

方法定义：

public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier) {
   return groupingBy(classifier, toList());
}

例1：按年龄分组 

package com.bjc.jdk8.col;

import com.bjc.jdk8.pojo.Student;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 21, 88D),
                new Student("王五", 24, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        // 根据年龄将数据分组
        Map<Integer, List<Student>> collect = stream.collect(Collectors.groupingBy(Student::getAge));
        collect.forEach((k,v)->{
            System.out.println("key:" + k + "  value = " + v);
        });
    }
}

运行结果如图：

例2：按分数区间分组

package com.bjc.jdk8.col;

import com.bjc.jdk8.pojo.Student;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 21, 88D),
                new Student("王五", 24, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        Map<String, List<Student>> map = stream.collect(Collectors.groupingBy(student -> {
            if (student.getScore() > 80) {
                return "优秀";
            } else {
                return "良";
            }
        }));
        map.forEach((k,v) -> {
            System.out.println("k:" + k + "  v:" + v);
        });
    }
}

运行结果：

3.2.1 多级分组——Collectors.groupingBy

使用Collectors.groupingBy的重载函数，方法定义

public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,Collector<? super T, A, D> downstream) {
   return groupingBy(classifier, HashMap::new, downstream);
}

例如：

package com.bjc.jdk8.col;

import com.bjc.jdk8.pojo.Student;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 21, 88D),
                new Student("王五", 24, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        // 先根据年龄分组，在根据分数分组
        Map<Integer, Map<String, List<Student>>> collect = stream.collect(Collectors.groupingBy(Student::getAge, Collectors.groupingBy(s -> {
            if (s.getScore() > 80) {
                return "优秀";
            } else {
                return "一般";
            }
        })));
        collect.forEach((k,v)->{
            System.out.println("age:" + k);
            v.forEach((k1,v1)->{
                System.out.println("\t" + "k1:" + k1 + "  v1:" + v1);
            });
        });
    }
}

运行结果：

3.3 对流中的数据进行分区——Collectors.partitioningBy

Collectors.partitioningBy会根据值是否为true，把集合分割为两个列表，一个true列表，一个false列表。

如图所示：

例如：

package com.bjc.jdk8.col;

import com.bjc.jdk8.pojo.Student;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 21, 88D),
                new Student("王五", 24, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        Map<Boolean, List<Student>> map = stream.collect(Collectors.partitioningBy(s -> {
            return s.getScore() > 80;
        }));
        map.forEach((k,v) -> {
            System.out.println("k:" + k + "  v:" + v);
        });
    }
}

运行结果：

从中我们可以发现，分区其实就是一种特殊发分组。

3.4 对流中的数据进行拼接——Collertors.joining

Collertors.joining会根据指定的连接符，将所有的元素连接成一个字符串。

例如：

package com.bjc.jdk8.col;

import com.bjc.jdk8.pojo.Student;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectTest01 {
    public static void main(String[] args) {
        Stream<Student> stream = Stream.of(
                new Student("张三", 21, 97D),
                new Student("李四", 21, 88D),
                new Student("王五", 24, 62D),
                new Student("赵六", 18, 59D),
                new Student("钱七", 24, 100D)
        );

        String collect = stream.map(Student::getName).collect(Collectors.joining(","));
        System.out.println(collect);
    }
}

运行结果：

武汉小喽啰
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Stream流的收集操作
QQwangjingkai的博客
03-16 1121
前言 提示：这里可以添加本文要记录的大概内容： Stream流的收集操作 提示：以下是本篇文章正文内容，下面案例可供参考 一、如何用Stream流收集？ 对数据使用Stream流的方式操作完毕后,我想把流中的数据收集到集合中,该如何办? 二、使用步骤 Stream流的收集方法 R collect(Collector collector) 但是这个收集方法的参数是一个Collector接口 工具类Collectors提供了具体的收集方式 public static <T> Collector
JDK8新特性——Stream.pdf
08-06
借鉴前人经验，在经过不断实践之后，将Strean流部分方法整理成适合于自身需要的文档，供大家借鉴分享。
java如何利用stream留将list对象中的id单独保存到另一个集合中
weixin_42581003的博客
01-03 1343
可以使用Java 8 Stream API来实现这一功能。例如： List<Person> people = ...; List<Integer> idList = people.stream() .map(Person::getId) .collect(Collectors.toList()); 在这里，people 是一个包含 Person 对象的列表...
Java8Stream（高效处理集合数据）
最新发布
小谷同学的博客
05-19 907
java8stream是处理数据集合，遍历数据集的高级迭代器，有助于提高我们写代码的效率！
Stream流中的收集操作，转化成集合/数组等
Wangdiankun的博客
07-22 4296
1. collect收集器 Stream流中的收集器collect API，是stream流的一个结束/终止操作。 其写法是.collect(collectors.方法) 输出List .collect(collectors.toList()) 输出Set .collect(collectors.toSet()) 输出Map .collect(collectors.toMap(需要设置key，需要设置value，某种规则)) 输出map可以设置某些规则，当然不是必须字段，比如相同key值进行valu
Java 收集Stream流、流转数组、流转集合
七七的博客
08-03 2285
收集stream流 把stream流的数据转回成集合。 stream的作用是把集合转换成一根传送带，借用stream流的强大功能进行的操作。 但是实际开发中数据最终的形式还是应该是集合，最终stream流操作完毕以后还是要转换成集合。 这就是收集Stream流。 stream流是手段。 集合才是目的。 流只能使用一次。 public static void main(String[] args) { List<String> ls = new ArrayList<&
Stream流操作===“集合”===收集方法collect
weixin_44750143的博客
05-29 1060
一:java8中集合有两个方法来生成流 1：stream（） --为集合创建串行流 2：parallelStream() − 为集合创建并行流。 代码举例： List<String> strings = Arrays.asList("sks", "","bc", "eg", "acd","", "jk"); List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(C
jdk7新特性jdk8新特性
01-13
# jdk7新特性 ## try-with-resources 是一种声明了`一种或多种资源的try语句`。资源是指在程序用完了之后必须要关闭的对象。try-with-resources语句保证了每个声明了的`资源在语句结束的时候都会被关闭`。任何实现...
JDK8核心新特性
06-20
JDK8已经发行有几年了，在该版本中推出了不少新特性，其中比较有代表的新特性有：Lambda表达式，Stream流，方法引用。在网上也有很多关于这些新特性的介绍，但个人觉得网上的很多文字对新特性的介绍是不够全面的，...
一文带你入门JDK8新特性——Lambda表达式
08-18
Lambda表达式是JDK8的一个新特性，可以取代大部分的匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。JDK也提供了大量的内置函数式接口供我们使用，使得Lambda表达式...
深入解析Jdk8中Stream流的使用让你脱离for循环
08-25
深入解析Jdk8中Stream流的使用让你脱离for循环 本文主要介绍了Jdk8中Stream流的使用，让开发者脱离传统的for循环。Stream流是Jdk8中引入的一种新式编程方式，能够使开发者更方便、更高效地处理数据。 什么是Stream...
java stream收集列表中对象的集合属性，组成一个大集合
ZhuoShuai2012的专栏
07-11 6608
java stream的用法
java8 Stream 的 Collectors 常用方法总结
快乐的小三菊的博客
11-20 2844
java8 Stream 的 Collectors 常用方法总结
java8新特性:stream流中collect用法
乃乃天外仙
10-27 6222
1.toList List<Integer> collectList = Stream.of(1, 2, 3, 4) .collect(Collectors.toList()); System.out.println("collectList: " + collectList); // 打印结果 // collectList: [1, 2, 3, 4] 2.toSet Set<Integer> collectSet = Stream.of(2, 3, 3, 3)
【Stream流】收集stream流中的结果
qq_41926259的博客
12-29 1613
收集Stream流中的结果 1. 将流中数据收集到集合中 Stream流提供 collect 方法，其参数需要一个 java.util.stream.Collector<T,A, R> 接口对象来指定收集到哪 种集合中。java.util.stream.Collectors 类提供一些方法，可以作为 Collector接口的实例： public static <T> Collector<T, ?, List<T>> toList() ：转换为 List 集合。
Java Stream Collectors的toList()、toSet()、toCollection()和toMap()的使用
m0_60105488的博客
06-21 1054
Stream是Java 8的新特性，基于lambda表达式，是对集合对象功能的增强，它专注于对集合对象进行各种高效、方便聚合操作或者大批量的数据操作，提高了编程效率和代码可读性。Collectors通常在Stream处理后，返回转换成集合类时使用，本文主要介绍Java Stream中Collectors.toList()、Collectors.toSet()、Collectors.toCollection()和Collectors.toMap()的使用，以及相关的示例代码。原文地址：Java Stream
Java8 Stream（5）List集合去重 distinct 和 toSet
Java Spring Elasticsearch
04-29 3105
一、distinct 去重 Stream流的distinct()方法可以轻松实现去重。 String[] codes = {"D", "A", "B", "A", "B","C"}; List<String> codeList = new ArrayList<>(Arrays.asList(codes)) ; //distinct codeList.stream() .distinct() .forEach(System.out::println);
jdk8新特性stream流
09-21
JDK8引入了新的特性Stream流。Stream流允许以声明性方式处理数据集合，可以将其看作是遍历数据集合的一个高级迭代器。通过Stream流，我们可以以简洁的方式完成复杂的数据处理操作，代码也更加清晰可读。 在JDK8中，我们可以通过多种方式获取Stream流： 1. 通过List集合对象调用stream()方法来获取Stream流。 2. 通过数组类的stream()方法来获取Stream流。 3. 通过Stream类的of()方法来获取Stream流。 4. 通过List集合对象调用parallelStream()方法来获取并行流。 使用Stream流有以下好处： 1. 代码以声明性方式书写，更加清晰易懂，能够说明想要完成什么，而不是说明如何完成一个操作。 2. 可以将多个基础操作连接起来，形成复杂的数据处理流水线，从而实现更加高效的数据处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值