Java8、Collectors方法大全

最新推荐文章于 2024-09-19 16:46:49 发布
最新推荐文章于 2024-09-19 16:46:49 发布
阅读量1.4k 收藏 10
点赞数 2
分类专栏： Java进阶知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33375499/article/details/115151701
版权

Collectors方法大全

一、所用示例类

1. Student

public class Student {
    // ID
    private String id;
    // 姓名
    private String name;
    // 总分
    private int totalScore;
    // 是否本地人
    private boolean local;
    // 年级
    private GradeType gradeType;

    public Student(String id, String name, int totalScore, boolean local, GradeType gradeType) {
        this.id = id;
        this.name = name;
        this.totalScore = totalScore;
        this.local = local;
        this.gradeType = gradeType;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(int totalScore) {
        this.totalScore = totalScore;
    }

    public boolean isLocal() {
        return local;
    }

    public void setLocal(boolean local) {
        this.local = local;
    }

    public GradeType getGradeType() {
        return gradeType;
    }

    public void setGradeType(GradeType gradeType) {
        this.gradeType = gradeType;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", totalScore=" + totalScore +
                ", local=" + local +
                ", gradeType=" + gradeType +
                '}';
    }
}

2. GradeType

/**
 * 年级类型 枚举
 */
public enum GradeType {
    ONE_GRADE, // 一年级
    TWO_GRADE,  // 二年级
    THREE_GRADE; // 三年级
}

3. CollectorsTest

public class CollectorsTest {
    private static final List<Student> students = new ArrayList<>(16);

    static {
        students.add(new Student("001", "刘一", 721, true, GradeType.THREE_GRADE));
        students.add(new Student("002", "陈二", 637, true, GradeType.THREE_GRADE));
        students.add(new Student("003", "朱三", 637, true, GradeType.THREE_GRADE));
        students.add(new Student("004", "李四", 531, true, GradeType.TWO_GRADE));
        students.add(new Student("005", "王五", 483, false, GradeType.THREE_GRADE));
        students.add(new Student("006", "赵六", 367, true, GradeType.THREE_GRADE));
        students.add(new Student("007", "孙七", 499, false, GradeType.ONE_GRADE));
        students.add(new Student("008", "向八", 520, false, GradeType.ONE_GRADE));
        students.add(new Student("009", "向八", 520, false, GradeType.ONE_GRADE));
    }
}

二、Collectors方法及使用

1. Collectors.toCollection()

/**
 * Collectors.toCollection()
 * 返回一个Collector收集器，它按遇见顺序将输入元素累积到一个新的Collection收集器中。Collection收集器由提供的工厂创建。
 * 输出：[刘一, 陈二, 朱三, 李四, 王五, 赵六, 孙七, 向八, 向八]
 */
System.out.println(
        students.stream()
                .map(Student::getName)
                .collect((Collector<? super String, Object, LinkedList<Object>>) Collectors.toCollection(LinkedList::new))
);

2. Collectors.toList() / Collectors.toSet()

/**
 * Collectors.toList()  /  Collectors.toSet()
 * 返回一个Collector收集器，它将输入元素累积到一个新的List/Set中。
 * 输出：[刘一, 陈二, 朱三, 李四, 王五, 赵六, 孙七, 向八, 向八]
 */
System.out.println(
        students.stream()
                .map(Student::getName)
                .collect(Collectors.toList())
);

3. Collectors.toMap(Function, Function) / Collectors.toConcurrentMap(Function, Function)

/**
 * Collectors.toMap(Function, Function)  /  Collectors.toConcurrentMap(Function, Function)
 * 返回一个Collector收集器，它将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
 * 输出：{001=刘一, 002=陈二, 003=朱三, 004=李四, 005=王五, 006=赵六, 007=孙七, 008=向八, 009=向八}
 */
System.out.println(
        students.stream()
                .collect(Collectors.toMap(Student::getId, Student::getName))
);

4. Collectors.toMap(Function, Function, BinaryOperator) / Collectors.toConcurrentMap(Function, Function, BinaryOperator)

/**
 * Collectors.toMap(Function, Function, BinaryOperator)  /  Collectors.toConcurrentMap(Function, Function, BinaryOperator)
 * 返回一个并发的Collector收集器，它将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
 * 如果映射的键包含重复项(根据Object#equals(Object))，则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。
 * 输出：{THREE_GRADE=5, ONE_GRADE=3, TWO_GRADE=1}
 */
System.out.println(
        students.stream()
                .collect(Collectors.toMap(
                        Student::getGradeType,
                        val -> 1,
                        (a, b) -> a + b))
);

5. Collectors.collectingAndThen(Collector, Function)

/**
 * Collectors.collectingAndThen(Collector, Function)
 * collectingAndThen方法调整Collector收集器以执行其它的结束转换。
 * 例如，可以调整toList()收集器，以始终生成一个不可变的列表
 * 输出：[001, 002, 003, 004, 005, 006, 007, 008, 009]
 */
List<String> ids = CollectorsTest.students.stream()
        .map(Student::getId)
        .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
System.out.println(ids);

6. Collectors.joining() / joining(delimiter) / joining(delimiter, prefix, suffix)

/**
 * Collectors.joining()
 * joining()方法返回一个Collector收集器，它按遇见顺序将输入元素连接成String。
 * 输出：001002003004005006007008009
 *
 * joining(delimiter)
 * joining(delimiter)方法返回一个Collector收集器，它以遇见顺序连接由指定分隔符分隔的输入元素。
 * 输出：001,002,003,004,005,006,007,008,009
 *
 * joining(delimiter, prefix, suffix)
 * joining(delimiter, prefix, suffix)方法返回一个Collector收集器，它以遇见顺序将由指定分隔符分隔的输入元素与指定的前缀和后缀连接起来。
 * 输出：ids[001,002,003,004,005,006,007,008,009]
 */
System.out.println(
        CollectorsTest.students.stream()
                .map(Student::getId)
                .collect(Collectors.joining(",", "ids[", "]"))
);

7. Collectors.mapping(Function, Collector)

/**
 * Collectors.mapping(Function, Collector)
 * mapping方法通过在累积之前将映射函数应用于每个输入元素，将Collector收集器接受U类型的元素调整为一个接受T类型的元素。
 * 输出：[001, 002, 003, 004, 005, 006, 007, 008, 009]
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.mapping(Student::getId, Collectors.toList()))
);

8. Collectors.maxBy(Comparator) / Collectors.minBy(Comparator)

/**
 * Collectors.maxBy(Comparator)      /       Collectors.minBy(Comparator)
 * maxBy方法返回一个Collector收集器，它根据给定的Comparator比较器生成 最大/最小 元素，描述为Optional<T>。
 * 输出：Optional[001]      /       Optional[006]
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.maxBy(Comparator.comparingInt(Student::getTotalScore)))
                .map(Student::getId)
);

9. Collectors.counting()

/**
 * Collectors.counting()
 * counting方法返回一个Collector收集器接受T类型的元素，用于计算输入元素的数量。如果没有元素，则结果为0。
 * 输出：9
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.counting())
);

10. Collectors.groupingBy(Function) / groupingByConcurrent(Function)

/**
 * Collectors.groupingBy(Function)   /   groupingByConcurrent(Function)
 * groupingBy(Function)方法返回一个Collector收集器对T类型的输入元素执行"group by"操作，
 * 根据分类函数对元素进行分组，并将结果返回到Map。
 * 结果：Map<K, List<T>>
 * 输出：Map<K, List<T>>
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.groupingBy(Student::getGradeType))
);

11. Collectors.groupingBy(Function, Collector) / groupingByConcurrent(Function, Collector)

/**
 * Collectors.groupingBy(Function, Collector)     /      groupingByConcurrent(Function, Collector)
 * groupingBy(Function)方法返回一个Collector收集器对T类型的输入元素执行"group by"操作，
 * 根据分类函数对元素进行分组，然后使用指定的下游Collector收集器对与给定键关联的值执行缩减操作。
 * 输出：{THREE_GRADE=5, ONE_GRADE=3, TWO_GRADE=1}
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.groupingBy(Student::getGradeType, Collectors.counting()))
);

12. Collectors.groupingBy(Function, Supplier, Collector) / groupingByConcurrent(Function, Supplier, Collector)

/**
 * Collectors.groupingBy(Function, Supplier, Collector)     /     groupingByConcurrent(Function, Supplier, Collector)
 * groupingBy(Function, Supplier, Collector)方法返回一个Collector收集器，
 * 对T类型的输入元素执行级联"group by"操作，根据分类函数对元素进行分组，
 * 然后使用指定的下游Collector收集器对与给定键关联的值执行缩减操作。
 * 收集器生成的Map是使用提供的工厂函数Supplier创建的。
 * 输出：{ONE_GRADE=3, TWO_GRADE=1, THREE_GRADE=5}
 */
TreeMap<GradeType, Long> collect = CollectorsTest.students.stream()
        .collect(Collectors.groupingBy(
                Student::getGradeType,
                TreeMap::new,
                Collectors.counting()));
System.out.println(collect);

13. Collectors.summingDouble(ToDoubleFunction) / Collectors.summingInt(ToIntFunction) / Collectors.summingLong(ToLongFunction)

/**
 * Collectors.summingDouble(ToDoubleFunction)
 * Collectors.summingInt(ToIntFunction)
 * Collectors.summingLong(ToLongFunction)
 * 返回一个Collector收集器，它生成应用于输入元素的double/int/long值函数的总和。如果没有元素，则结果为0。
 * 输出：4915.0
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.summingDouble(Student::getTotalScore))
);

14. Collectors.averagingDouble(ToDoubleFunction) / Collectors.averagingInt(ToIntFunction) / Collectors.averagingLong(ToLongFunction)

/**
 * Collectors.averagingDouble(ToDoubleFunction)
 * Collectors.averagingInt(ToIntFunction)
 * Collectors.averagingLong(ToLongFunction)
 * averagingDouble方法返回一个Collector收集器，它生成应用于输入元素的double/int/long值函数的算术平均值。如果没有元素，则结果为0。
 * 输出：546.1111111111111
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.averagingDouble(Student::getTotalScore))
);

15. Collectors.partitioningBy(Predicate)

/**
 * Collectors.partitioningBy(Predicate)
 * partitioningBy(Predicate)方法返回一个Collector收集器，它根据Predicate对输入元素进行分区，并将它们组织成Map<Boolean, List<T>>
 * 输出：Map<Boolean, List<T>>
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.partitioningBy(Student::isLocal))
);

16. Collectors.partitioningBy(Predicate, Collector)

/**
 * Collectors.partitioningBy(Predicate, Collector)
 * partitioningBy(Predicate, Collector)方法返回一个Collector收集器，它根据Predicate对输入元素进行分区，
 * 根据另一个Collector收集器减少每个分区中的值，并将它们组织成Map<Boolean, D>，其值是下游减少的结果。
 * 输出：{false=4, true=5}
 */
System.out.println(
        CollectorsTest.students.stream()
                .collect(Collectors.partitioningBy(Student::isLocal, Collectors.counting()))
);

三、完整代码

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class CollectorsTest {
    private static final List<Student> students = new ArrayList<>(16);

    static {
        students.add(new Student("001", "刘一", 721, true, GradeType.THREE_GRADE));
        students.add(new Student("002", "陈二", 637, true, GradeType.THREE_GRADE));
        students.add(new Student("003", "朱三", 637, true, GradeType.THREE_GRADE));
        students.add(new Student("004", "李四", 531, true, GradeType.TWO_GRADE));
        students.add(new Student("005", "王五", 483, false, GradeType.THREE_GRADE));
        students.add(new Student("006", "赵六", 367, true, GradeType.THREE_GRADE));
        students.add(new Student("007", "孙七", 499, false, GradeType.ONE_GRADE));
        students.add(new Student("008", "向八", 520, false, GradeType.ONE_GRADE));
        students.add(new Student("009", "向八", 520, false, GradeType.ONE_GRADE));
    }

    public static void main(String[] args) {
        /**
         * Collectors.toCollection()
         * 返回一个Collector收集器，它按遇见顺序将输入元素累积到一个新的Collection收集器中。Collection收集器由提供的工厂创建。
         * 输出：[刘一, 陈二, 朱三, 李四, 王五, 赵六, 孙七, 向八, 向八]
         */
        System.out.println(
                students.stream()
                        .map(Student::getName)
                        .collect((Collector<? super String, Object, LinkedList<Object>>) Collectors.toCollection(LinkedList::new))
        );

        /**
         * Collectors.toList()  /  Collectors.toSet()
         * 返回一个Collector收集器，它将输入元素累积到一个新的List/Set中。
         * 输出：[刘一, 陈二, 朱三, 李四, 王五, 赵六, 孙七, 向八, 向八]
         */
        System.out.println(
                students.stream()
                        .map(Student::getName)
                        .collect(Collectors.toList())
        );

        /**
         * Collectors.toMap(Function, Function)  /  Collectors.toConcurrentMap(Function, Function)
         * 返回一个Collector收集器，它将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
         * 输出：{001=刘一, 002=陈二, 003=朱三, 004=李四, 005=王五, 006=赵六, 007=孙七, 008=向八, 009=向八}
         */
        System.out.println(
                students.stream()
                        .collect(Collectors.toMap(Student::getId, Student::getName))
        );

        /**
         * Collectors.toMap(Function, Function, BinaryOperator)  /  Collectors.toConcurrentMap(Function, Function, BinaryOperator)
         * 返回一个并发的Collector收集器，它将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
         * 如果映射的键包含重复项(根据Object#equals(Object))，则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。
         * 输出：{THREE_GRADE=5, ONE_GRADE=3, TWO_GRADE=1}
         */
        System.out.println(
                students.stream()
                        .collect(Collectors.toMap(
                                Student::getGradeType,
                                val -> 1,
                                (a, b) -> a + b))
        );

        /**
         * Collectors.collectingAndThen(Collector, Function)
         * collectingAndThen方法调整Collector收集器以执行其它的结束转换。
         * 例如，可以调整toList()收集器，以始终生成一个不可变的列表
         * 输出：[001, 002, 003, 004, 005, 006, 007, 008, 009]
         */
        List<String> ids = CollectorsTest.students.stream()
                .map(Student::getId)
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        System.out.println(ids);

        /**
         * Collectors.joining()
         * joining()方法返回一个Collector收集器，它按遇见顺序将输入元素连接成String。
         * 输出：001002003004005006007008009
         *
         * joining(delimiter)
         * joining(delimiter)方法返回一个Collector收集器，它以遇见顺序连接由指定分隔符分隔的输入元素。
         * 输出：001,002,003,004,005,006,007,008,009
         *
         * joining(delimiter, prefix, suffix)
         * joining(delimiter, prefix, suffix)方法返回一个Collector收集器，它以遇见顺序将由指定分隔符分隔的输入元素与指定的前缀和后缀连接起来。
         * 输出：ids[001,002,003,004,005,006,007,008,009]
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .map(Student::getId)
                        .collect(Collectors.joining(",", "ids[", "]"))
        );

        /**
         * Collectors.mapping(Function, Collector)
         * mapping方法通过在累积之前将映射函数应用于每个输入元素，将Collector收集器接受U类型的元素调整为一个接受T类型的元素。
         * 输出：[001, 002, 003, 004, 005, 006, 007, 008, 009]
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.mapping(Student::getId, Collectors.toList()))
        );

        /**
         * Collectors.maxBy(Comparator)      /       Collectors.minBy(Comparator)
         * maxBy方法返回一个Collector收集器，它根据给定的Comparator比较器生成 最大/最小 元素，描述为Optional<T>。
         * 输出：Optional[001]      /       Optional[006]
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.maxBy(Comparator.comparingInt(Student::getTotalScore)))
                        .map(Student::getId)
        );

        /**
         * Collectors.counting()
         * counting方法返回一个Collector收集器接受T类型的元素，用于计算输入元素的数量。如果没有元素，则结果为0。
         * 输出：9
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.counting())
        );

        /**
         * Collectors.groupingBy(Function)   /   groupingByConcurrent(Function)
         * groupingBy(Function)方法返回一个Collector收集器对T类型的输入元素执行"group by"操作，
         * 根据分类函数对元素进行分组，并将结果返回到Map。
         * 结果：Map<K, List<T>>
         * 输出：Map<K, List<T>>
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.groupingBy(Student::getGradeType))
        );

        /**
         * Collectors.groupingBy(Function, Collector)     /      groupingByConcurrent(Function, Collector)
         * groupingBy(Function)方法返回一个Collector收集器对T类型的输入元素执行"group by"操作，
         * 根据分类函数对元素进行分组，然后使用指定的下游Collector收集器对与给定键关联的值执行缩减操作。
         * 输出：{THREE_GRADE=5, ONE_GRADE=3, TWO_GRADE=1}
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.groupingBy(Student::getGradeType, Collectors.counting()))
        );

        /**
         * Collectors.groupingBy(Function, Supplier, Collector)     /     groupingByConcurrent(Function, Supplier, Collector)
         * groupingBy(Function, Supplier, Collector)方法返回一个Collector收集器，
         * 对T类型的输入元素执行级联"group by"操作，根据分类函数对元素进行分组，
         * 然后使用指定的下游Collector收集器对与给定键关联的值执行缩减操作。
         * 收集器生成的Map是使用提供的工厂函数Supplier创建的。
         * 输出：{ONE_GRADE=3, TWO_GRADE=1, THREE_GRADE=5}
         */
        TreeMap<GradeType, Long> collect = CollectorsTest.students.stream()
                .collect(Collectors.groupingBy(
                        Student::getGradeType,
                        TreeMap::new,
                        Collectors.counting()));
        System.out.println(collect);

        /**
         * Collectors.summingDouble(ToDoubleFunction)
         * Collectors.summingInt(ToIntFunction)
         * Collectors.summingLong(ToLongFunction)
         * 返回一个Collector收集器，它生成应用于输入元素的double/int/long值函数的总和。如果没有元素，则结果为0。
         * 输出：4915.0
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.summingDouble(Student::getTotalScore))
        );

        /**
         * Collectors.averagingDouble(ToDoubleFunction)
         * Collectors.averagingInt(ToIntFunction)
         * Collectors.averagingLong(ToLongFunction)
         * averagingDouble方法返回一个Collector收集器，它生成应用于输入元素的double/int/long值函数的算术平均值。如果没有元素，则结果为0。
         * 输出：546.1111111111111
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.averagingDouble(Student::getTotalScore))
        );

        /**
         * Collectors.partitioningBy(Predicate)
         * partitioningBy(Predicate)方法返回一个Collector收集器，它根据Predicate对输入元素进行分区，并将它们组织成Map<Boolean, List<T>>
         * 输出：Map<Boolean, List<T>>
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.partitioningBy(Student::isLocal))
        );

        /**
         * Collectors.partitioningBy(Predicate, Collector)
         * partitioningBy(Predicate, Collector)方法返回一个Collector收集器，它根据Predicate对输入元素进行分区，
         * 根据另一个Collector收集器减少每个分区中的值，并将它们组织成Map<Boolean, D>，其值是下游减少的结果。
         * 输出：{false=4, true=5}
         */
        System.out.println(
                CollectorsTest.students.stream()
                        .collect(Collectors.partitioningBy(Student::isLocal, Collectors.counting()))
        );
    }
}

参照链接

https://blog.csdn.net/sl1992/article/details/98900343

普通人zzz~
关注
专栏目录
Java8 collectors类
大鹏小站的博客
02-17 565
先看下collectors类的结构，里面有collector接口的实现 CollectorImpl以及自己定义的一些静态方法 构造对象 @Data @AllArgsConstructor static class Achievement{ private String name; private double score; priv...
深入理解 Java 8 中的 Collectors.averagingInt() 方法
09-15
在 Java 8 引入的 Stream API 中，Collectors.averagingInt() 方法是处理数值型数据集合时的一个非常有用的工具。它允许开发者计算流中整数属性的平均值，这在数据分析和处理中是一个常见的需求。本文将详细探讨 ...
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"
Java Collectors工具类
最新发布
weixin_47363690的博客
09-19 554
Collectors是 Java 8 引入的一个工具类，用于提供各种常见的Collector实现。这些Collector可以用于将流中的元素收集到各种目标容器中，如ListSetMap等。下面是一些Collectors工具类中常用的静态方法及其用法示例。
Java8中Collectors详解
scofen的博客
03-10 2625
文章目录 1.averagingDouble 2.collectingAndThen 3.counting 4.groupingBy 4.1groupingBy(Function) 4.2groupingBy(Function, Collector) 4.3groupingBy(Function, Supplier, Collector) 5.groupingByConcurrent 5.1gro...
介绍 Java 8 Collectors 类
neweastsun的专栏
04-21 6220
介绍 Java 8 Collectors 类 本文我们探讨Java 8 Collectors 类，其一般用于流处理中的最后一步。 Stream.collect() 方法 Stream.collect() 是java 8 stream api中的终止方法。它实现对流实例中保存的数据元素执行可变的折叠操作(将元素重新包装至特定的数据结构中，并应用一些额外逻辑将它们连接起来，等等)。此操作的策略由Col...
Java8 -- Collectors
M_Joes_17的博客
09-21 513
Collectors API 1.toList() public List&lt;User&gt; toList(List&lt;User&gt; users) { return users.stream().filter(c -&gt; c.getAge() &gt; 25L).collect(Collectors.toList()); } 2.toSet() ...
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
Java 8 Stream Collectors 功能与操作方法详解 Java 8 Stream Collectors 是 Java 8 中的一个重要功能，位于 java.util.stream 包下。它提供了一系列的静态方法供我们使用，通常情况下我们可以静态导入即可使用。...
Java8 Stream Collectors收集器使用方法解析
08-18
Java8 Stream Collectors收集器使用方法解析 Java8 Stream Collectors收集器是Java8中Stream API的一种重要组件， Collectors是 Stream API 中的收集器接口，提供了许多实用的方法来处理Stream流数据。以下是Java8 ...
深入探讨 Java 8 Stream API 的 Collectors.minBy() 方法
09-15
在 Java 8 引入的 Stream API 中，java.util.stream.Collectors.minBy() 方法是一个强大的工具，用于在集合操作中找到流中按照指定比较器最小的元素。与 maxBy() 方法相对应，minBy() 提供了一种声明式的方式来确定...
深入探索 Java 8 Stream API 的 Collectors.maxBy() 方法
09-15
在 Java 8 引入的 Stream API 中，Collectors 类提供了多种强大的工具，用于处理集合数据。其中，Collectors.maxBy() 方法尤其引人注目，因为它允许开发者以声明式的方式轻松找到流中的最大元素。本文将深入探讨 ...
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);.
Collectors详解
安晴晚风的博客
07-13 986
Collectors 是Java 8及更高版本中引入的一个工具类，它提供了许多静态方法，这些方法返回实现了 Collector 接口的实例。Collector 接口定义了如何将流（Stream）中的元素累积成一个结果容器，这个结果容器可以是任何最终结果类型，例如一个集合、一个值或者一个映射。
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 collectors_java8 Collectors
weixin_39957461的博客
02-25 91
记录一下 java8 Collectors 收集器使用详解。1.Collectors.toList()List result =givenList.stream().collect(toList());2.Collectors.toSet()Set result =givenList.stream().collect(toSet());3.Collectors.toMap()toMap(Funct...
Java 8 - 收集器Collectors
热门推荐
小工匠
03-11 1万+
文章目录Pre简介 Pre 我们前面学到了，流可以用类似于数据库的操作帮助你处理集合。 它们支持两种类型的操作： 中间操作（如 filter 或 map ） 终端操作（如 count 、 findFirst 、 forEach 和 reduce ） 中间操作可以链接起来，将一个流转换为另一个流。这些操作不会消耗流，其目的是建立一个流水线。 与此相反，终端操作会消耗流，以产生一个最终结果，例如返回流中的最大元素。它们通常可以通过优化流水线来缩短计算时间。 前面使用过了collect 终端操作了
java8 collectors类_java8之collectors
weixin_28706541的博客
02-25 312
java8中提供了对集合进行转化，然后进行归集的的操作。这就不得不提Collectors这个类了，真的很强大，我们看示例吧。KeyAndValue a1 = newKeyAndValue().setName("kevin").setValue("lee");KeyAndValue a2 = newKeyAndValue().setName("kevin").setValue("lee");KeyA...
java8中Collectors的学习
winteriscomming的博客
12-20 374
Collectors
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值