java8 Collectors 常用方法

已于 2023-06-05 14:16:21 修改
阅读量2.2k 收藏 4
点赞数 1
分类专栏： java 文章标签： java
于 2019-12-23 16:03:44 首次发布
原文链接：https://www.eyesmoons.com/article/131
版权

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

  • 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
  • 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
  • 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

  • 和以前的Collection操作不同， Stream操作还有两个基础的特征：

  • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

生成流

在 Java 8 中, 集合接口有两个方法来生成流：

  • stream() − 为集合创建串行流。

  • parallelStream() − 为集合创建并行流。

forEach

Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

map

map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filter

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.stream().filter(string -> string.isEmpty()).count();

limit

limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

sorted

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);

Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
 
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

统计

另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
 
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
 
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

例子

package com.example.demo;

import java.util.Arrays;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Random;
import java.util.stream.Collectors;

import org.junit.Before;
import org.junit.Test;

public class TestCollectors {
	List<User> users;
	
	@Before
    public void init() {
        users = Arrays.asList(new User(1, "jack", 18),
                new User(2, "james", 30),
                new User(3, "jhon", 20),
                new User(4, "joge", 18),
        		new User(5, "polo", 21),
        		new User(6, "william", 21));

    }
	
	/**
	 * 描述: 单字段分组
	 * @author shengyu 
	 * @date:2019年12月20日 上午10:40:43
	 */
    @Test
    public void groupingBy() {
    	System.out.println("按照年龄分组");
    	System.out.println("--------------------");
        users.stream().collect(Collectors.groupingBy(User::getAge)).forEach((key, value) -> {
            System.out.println("key：" + key + "  value：" + value);
        });
    }
    
    /**
     * 描述: 分组后取最大/小值
     * @author shengyu 
     * @date:2019年12月20日 上午10:40:30
     */
    @Test
    public void groupingByMax() {

        //分组后取最大值
        Map<Integer, Optional<User>> collect = users.stream().collect(Collectors.groupingBy(User::getAge, Collectors.maxBy(Comparator.comparing(User::getId))));

        //分组后取最小值
        Map<Integer, Optional<User>> collect2 = users.stream().collect(Collectors.groupingBy(User::getAge, Collectors.minBy(Comparator.comparing(User::getId))));

        System.out.println("分组后取id最大值");
        System.out.println("-----------------------------");
        collect.forEach((key, value) -> {
            System.out.println("key：" + key + "    " + "value : " + value);
        });

        System.out.println("");

        System.out.println("分组后取id最小值");
        System.out.println("-----------------------------");
        collect2.forEach((key, value) -> {
            System.out.println("key " + key + "    " + "value : " + value);
        });
    }

    /**
     * 描述: 分组后映射为新的对象
     * @author shengyu 
     * @date:2019年12月20日 上午10:41:35
     */
    @Test
    public void mapping() {
        Map<Integer, List<String>> collect = users.stream().collect(Collectors.groupingBy(User::getAge, Collectors.mapping( item ->{
            //当然你这里也可以构建一个新的对象，进行返回
            return item.getName();
        }, Collectors.toList())));

        System.out.println("分组后转换为list");
        System.out.println("--------------------");
        collect.forEach((key, value) -> {
            System.out.println(key + "：" + value);
        });
    }
    

    /**
     * 单字段进行排序
     */
    @Test
    public void sort() {
        //倒序
        System.out.println("年龄倒序");
        users.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println("--------------------");
        System.out.println("年龄升序");

        //升序
        users.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList()).forEach(System.out::println);
    }
    

    /**
    * 排序 、多条件排序。注意：排序的字段不能为空
    */
   @Test
   public void comparator() {
       /**
        * 手动控制排序（复杂业务的时候，可以采用该种方法）
        * 1、年龄倒序
        * 2、id 升序
        */
       Comparator<User> usersComparator = Comparator.comparing(User::getAge, (o1, o2) -> {
           //  倒序
           return o2.compareTo(o1);
       }).thenComparing(User::getId, (o1, o2) -> {
           // 升序
           return o1.compareTo(o2);
       });
       List<User> collect = users.stream().sorted(usersComparator).collect(Collectors.toList());

       collect.forEach(System.out::println);

       System.out.println("----------------------------------");

       /**
        *
        * 第二种倒排方法
        * Comparator.reverseOrder 倒序
        * Comparator.naturalOrder 升序
        *
        * 1、年龄倒序
        * 2、id 倒序
        */
       Comparator<User> usersComparator2 = Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getId,Comparator.reverseOrder());
       List<User> collect2 = users.stream().sorted(usersComparator2).collect(Collectors.toList());

       collect2.forEach(System.out::println);
   }
   
   @Test
   public void TestStr(){
	   // 计算空字符串
       List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
       List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
       List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
       Random random = new Random();
       
       System.out.println("列表: " +strings);
       
       long count = strings.stream().filter(string->string.isEmpty()).count();
       System.out.println("空字符串数量为: " + count);
  
       count = strings.stream().filter(string -> string.length() == 3).count();
       System.out.println("字符串长度为 3 的数量为: " + count);
       
       List<String> filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
       System.out.println("筛选后的列表: " + filtered);
       
       String mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(","));
       System.out.println("合并字符串: " + mergedString);
  
       List<Integer> squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
       System.out.println("Squares List: " + squaresList);
       System.out.println("列表: " +integers);
  
       IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
       
       System.out.println("列表中最大的数 : " + stats.getMax());
       System.out.println("列表中最小的数 : " + stats.getMin());
       System.out.println("所有数之和 : " + stats.getSum());
       System.out.println("平均数 : " + stats.getAverage());
       System.out.println("随机数: ");
       random.ints().limit(10).sorted().forEach(System.out::println);
  
       // 并行处理
       count = strings.parallelStream().filter(string -> string.isEmpty()).count();
       System.out.println("空字符串的数量为: " + count);
   }

}

User.java

package com.example.demo;

public class User {
	private int id;
	private String name;
	private int age;
	
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Users [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

eyesmoons
关注
专栏目录
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
主要介绍了Java 8 Stream Collectors 功能与操作方法,结合实例形式详细分析了Java 8 Stream Collectors 功能、操作方法及相关注意事项,需要的朋友可以参考下
JAVA8之collect总结(给自己)
热门推荐
张肖的博客
07-18 3万+
一,collect是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式(称为收集器) 二,预定义收集器包括将流元素归约和汇总到一个值.如下 工厂方法 返回类型 用于 toList List 把流中所有元素收集到List中 示例:List menus=Menu.getMenus.stre
Java Collectors工具类
最新发布
weixin_47363690的博客
09-19 554
Collectors是 Java 8 引入的一个工具类，用于提供各种常见的Collector实现。这些Collector可以用于将流中的元素收集到各种目标容器中，如ListSetMap等。下面是一些Collectors工具类中常用的静态方法及其用法示例。
Collectors 中的各种方法
赵丙双的博客
06-04 2170
Collectors 中提供了很多好用的 Collector 实现，大大提高了我们的生产力，比如，将元素放入 Collection，一些聚合、汇总、分组操作。 转集合：toCollection、toList、toSet toCollection() 可以转成任意的 Collection 实现类 toList 转成 ArrayList toSet 转成 HashSet public static void main(String[] args) { String[] arr = {"a", "b"
Java8、Collectors方法大全
雨后是冰雹
03-23 1434
Collectors方法大全一、所用示例类1. Student2. GradeType3. CollectorsTest二、Collectors方法及使用1. Collectors.toCollection()2. Collectors.toList() / Collectors.toSet()3. Collectors.toMap(Function, Function) / Collectors.toConcurrentMap(Function, Function)4. Collectors.to
Java 8 Stream 的终极技巧——Collectors 操作
码农小胖哥
01-02 2309
1. 前言 昨天在 Collection 移除元素操作[1] 相关的文章中提到了 Collectors 。相信很多同学对这个比较感兴趣，那我们今天就来研究一下 Collectors 。 2. Collectors 的作用 Collectors 是 Java 8 加入的操作类，位于 java.util.stream 包下。它会根据不同的策略将元素收集归纳起来，比如最简单常用的是将元素装入...
Java 8 Stream API 的 Collectors 类深度解析
09-15
Collectors 类是 Java 8 Stream API 中的一个强大工具，它提供了丰富的方法来处理集合数据。通过本文的详细介绍和示例代码，你应该能够理解 Collectors 类的作用，并能够在实际开发中灵活运用它来处理集合数据。无论...
Java8 Lambda Stream collect Collectors 常用详细实例
L_Cheng_H的博客
11-24 899
返回List集合: toList() 用于将元素累积到List集合中。它将创建一个新List集合(在不更改当前集合的情况下)。 List<Integer> integerList = Arrays.asList(1,2,3,4,5,6); integerList.stream().map(x -> x*x).collect(Collectors.toList()); 返回Set集合: toSet() 用于将元素累积到Set集合中。会删除重复元素。 List<Intege
Java8 函数式编程常用方法总结
Mosiclone的博客
05-22 341
class Student{ private String name; private int grade; //get set .. } List<Student> list = new ArrayList<>(); Predicate 判定 public interface Predicate<T>{ // lamda表达式匿名函数修改的test boolean test(T t); // 可以和其他判定条件进行逻辑运算 （还
玩转 Java8 Stream 流，常用方法，详细用法大合集
m0_74931226的博客
11-13 482
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。特点：不是数据结构，不会保存数据。不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
java流式编程（十三）Collectors中部分常用方法原理解析
码易的博客
06-06 195
前言 前面已经分析了Collectors.groupingBy()、Collectors.toMap()的实现原理，接下来介绍Collectors中的其他方法。 文章目录前言1、joining()2、joining(CharSequence delimiter, prefix, suffix)3、mapping(mapper, downstream)4、collectingAndThen(downstream, finisher)5、minBy(comparator)6、summingInt(ma..
Collectors常用方法
Mr. Wu's blog
04-19 460
/** * @author W * @date 2022/4/18 */ public class StreamTest { /** * 返回List集合 * toList */ @Test public void stream1(){ List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6); System.out.println(integers);.
Java 8 - 收集器Collectors
小工匠
03-11 1万+
文章目录Pre简介 Pre 我们前面学到了，流可以用类似于数据库的操作帮助你处理集合。 它们支持两种类型的操作： 中间操作（如 filter 或 map ） 终端操作（如 count 、 findFirst 、 forEach 和 reduce ） 中间操作可以链接起来，将一个流转换为另一个流。这些操作不会消耗流，其目的是建立一个流水线。 与此相反，终端操作会消耗流，以产生一个最终结果，例如返回流中的最大元素。它们通常可以通过优化流水线来缩短计算时间。 前面使用过了collect 终端操作了
Java8 Stream Collectors
zym_1321的博客
06-11 251
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。返回列表、字符串、或产生统计结果的收集器 实例如下： static class Student { private String address; private String name; private Integer age; public Stude...
Java8新特性之Collectors（收集器）
qq_43754643的博客
11-29 583
话不多说，代码附上 package com.lsy; import java.util.*; import java.util.concurrent.CopyOnWriteArrayList; import java.util.function.Function; import java.util.stream.Collectors; /** * @author lsy * @deprecated java 8 新特性 Collector */ public class demo {
java8 collect()_java8 stream流 collect
weixin_39605347的博客
02-18 138
流的收集器非常有用。可用于将流元素归约和汇总为一个值，元素分组，元素分区。1.归约与汇总静态导入java.util.stream.Collectors.*。1.1求值Collectors.maxBy和Collectors.minBy，来计算流中的最大或最小值。参数为Comparator。Optional max = Stream.of(new A(4),new A(2),new A(8)).co...
Java8新特性：收集器collect
记录，记录，记录
05-02 264
一：collect 功能：将流中的数据按照传递的方法进行收集，例如收集成List，Set，Map等等。 collect接口情况： <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, B...
Java8新特性之Collectors
DRFish
09-25 3万+
在第二天，你已经学习了Stream API能够让你以声明式的方式帮助你处理集合。我们看到collect是一个将管道流的结果集到一个list中的结束操作。collect是一个将数据流缩减为一个值的归约操作。这个值可以是集合、映射，或者一个值对象。
Java8中Collectors详解
Life is for sharing的博客
08-09 2万+
文章目录1.averagingDouble2.collectingAndThen3.counting4.groupingBy4.1groupingBy(Function)4.2groupingBy(Function, Collector)4.3groupingBy(Function, Supplier, Collector)5.groupingByConcurrent5.1groupingByCo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值