java8-stream流操作实例：collect、join、map、sort、findFirst、max、findAny、match、group分组、collectingAndThen去重

芒果-橙

已于 2023-03-04 15:39:46 修改

阅读量3.3k

点赞数 2

分类专栏：后端文章标签： java jdk8 stream java8

于 2023-01-01 08:51:09 首次发布

本文链接：https://blog.csdn.net/qq_35893033/article/details/128485642

版权

后端专栏收录该内容

14 篇文章

订阅专栏

前言

jdk8 新特性：stream流操作
包含：collect-收集转化、join-字符串连接、map-映射、sort-排序、findFirst-筛选第一个、max/min-获取最大/小的一个值、findAny-查找任意一个值、anyMatch/allMatch-任意匹配/全部匹配、toMap-转化为Map集合、groupingBy-分组、collectingAndThen-去重
使用方法、场景示例
博客地址：芒果橙的个人博客【http://mangocheng.com】

文章目录

场景数据，案例使用

/**
     * 造数据
     *
     * @return
     */
    public static List<Person> generatePerson() {
        List<Person> people = new ArrayList<>(8);
        Person p1 = new Person("小赵", 23);
        Person p2 = new Person("小钱", 12);
        Person p3 = new Person("小孙", 5);
        Person p4 = new Person("小钱", 25);

        people.add(p1);
        people.add(p2);
        people.add(p3);
        people.add(p4);
        return people;
    }

/**
 * 造数据2
 *
 * @return
 */
public static List<Person> generatePerson2() {
        List<Person> people = new ArrayList<>(8);
        Person p1 = new Person("小赵", 23);
        Person p2 = new Person("小钱", 12);
        Person p3 = new Person("小孙", 5);
        Person p4 = new Person("小钱", 25);
        Person p5 = new Person("小钱", 25);

        people.add(p1);
        people.add(p2);
        people.add(p3);
        people.add(p4);
        people.add(p5);
        return people;
        }


/**
     * 实体
     */
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    static class Person {
        String name;
        int age;
    }

join–字符串连接

场景：汇总所有人员的姓名，在页面中统一展示
使用：join将所有人员的姓名拼接成一个字段，以分号“;"作为连接符
输出：name = 小赵;小钱;小孙;小钱

/**
     * join -- 字符串连接
     */
    public static void joinProcess() {
        List<Person> list = generatePerson();
        String names = list.stream().map(Person::getName).collect(Collectors.joining(";"));
        System.out.println("name = " + names);
    }

map–映射处理

场景1：汇总所有人员的姓名，在页面中依次展示，不合并
使用：map依次获取人员的姓名，组成一个新的集合
输出：nameList = [小赵, 小钱, 小孙, 小钱]

/**
     * map -- 映射处理
     */
    // 显示定义函数 
    public static void mapProcess() {
        List<Person> list = generatePerson();
        Function<Person, String> function = Person::getName;
        List<String> nameList = list.stream().map(function).collect(Collectors.toList());
        System.out.println("nameList = " + nameList.toString());
    }
    // 参数直接使用函数
    List<String> nameList2 = list.stream().map(Person::getName).collect(Collectors.toList());

场景2：汇总所有人员的姓名和年龄，格式（姓名-年龄），在页面中依次展示
使用：map中进行人员姓名和年龄的拼接，组成一个新的组合
输出：nameAgeList = [小赵-23, 小钱-12, 小孙-5, 小钱-25]

/**
     * map -- 映射处理2
     */
    public static void mapProcess2() {
        List<Person> list = generatePerson();
        List<String> nameAgeList = list.stream().map(person -> {
            String nameAge = person.getName() + "-" + person.getAge();
            return nameAge;
        }).collect(Collectors.toList());
        System.out.println("nameAgeList = " + nameAgeList.toString());
    }

sort–排序

场景：将人员按年龄的大小排序输出，在页面显示人员姓名及年龄
使用：sort根据年龄进行排序
输出：people.age old ==> young[{“age”:25,“name”:“小钱”},{“age”:23,“name”:“小赵”},{“age”:12,“name”:“小钱”},{“age”:5,“name”:“小孙”}]

/**
     * sort -- 排序
     */
    public static void sortProcess() {
        List<Person> list = generatePerson();
        Function<Person, Integer> function = Person::getAge;
        List<Person> people = list.stream().sorted(Comparator.comparing(function).reversed()).collect(Collectors.toList());
        System.out.println("people.age old ==> young" + JSON.toJSONString(people));
    }

count–统计

场景：统计人员中叫“小钱”的有几个
使用：count对象中姓名为小钱的数量
输出：统计：2

/**
     * count -- 统计
     */
    public static void countProcess() {
        List<Person> list = generatePerson();
        int c = (int) list.stream().filter(item -> Objects.equals(item.getName(), "小钱")).count();
        System.out.println("统计：" + c);
    }

findFirst–筛选第一个

场景：找到人员中年龄最小的人，在页面显示该人员信息
使用：先排序，然后获取第一个
输出：person = {“age”:5,“name”:“小孙”}

/**
     * findFirst -- 筛选第一个
     */
    public static void findFirstProcess() {
        List<Person> list = generatePerson();
//        Person person = list.stream().findFirst().get();
        Person person = list.stream().sorted(Comparator.comparing(Person::getAge)).findFirst().get();
        System.out.println("person = " + JSON.toJSONString(person));
    }

max/min–获取最大/小的一个值（某些情况可以替代sort+findFirst，例如上个例子）

场景：找到人员中年龄最大的人，在页面显示该人员信息
使用：max获取最大值
输出：person2={“age”:25,“name”:“小钱”}

/**
     * max/min -- 获取最大/小的一个值，某些情况可以替代sort+findFirst
     */
    public static void maxProcess() {
        List<Person> list = generatePerson();
//        Person p1 = list.stream().sorted(Comparator.comparing(Person::getAge).reversed()).findFirst().get();
//        System.out.println("person1=" + JSON.toJSONString(p1));
        Person p2 = list.stream().max(Comparator.comparing(Person::getAge)).get();
        System.out.println("person2=" + JSON.toJSONString(p2));
    }

findAny–查找任意一个值

场景：确认这群人中有没有叫“小赵”的
使用：findAny判断，满足一个即可
输出：exist=true

/**
     * findAny
     */
    public static void findAnyProcess() {
        List<Person> list = generatePerson();
        boolean exist = list.stream().filter(item -> Objects.equals("小赵", item.getName())).findAny().isPresent();
        System.out.println("exist=" + exist);
    }

anyMatch/allMatch–任意匹配、全部匹配（（在某些情况可以替代findAny，比如上面那个例子）

场景1：确认这群人中有没有叫“小赵”的
使用：anyMatch判断，满足一个即可
输出：exist=true

/**
     * anyMatch
     */
    public static void anyMatchProcess() {
        List<Person> list = generatePerson();
        boolean exist = list.stream().anyMatch(item -> Objects.equals("小赵", item.getName()));
        System.out.println("exist=" + exist);
    }

场景2：这群人是不是都叫“小赵”
使用：allMatch判断，全部满足才行
输出：exist=false

/**
 * allMatch
 */
    public static void allMatchProcess() {
        List<Person> list = generatePerson();
        boolean exist = list.stream().allMatch(item -> Objects.equals("小赵", item.getName()));
        System.out.println("exist=" + exist);
    }

toMap–转化为Map集合

场景：把List转化为Map
使用：toMap转化
输出：map = {“小孙”:5,“小钱”:25,“小赵”:23}
备注：注意看输出的小钱，是后设置的数据

/**
 * toMap -- 转化map
 */
public static void toMapProcess() {
        List<Person> people = generatePerson();
        Function<Person, String> nameFunction = Person::getName;
        Function<Person, Integer> ageFunction = Person::getAge;
        // 如果有相同的key，则取后一个key的值
        Map<String, Integer> map = people.stream().collect(Collectors.toMap(nameFunction, ageFunction, (v1, v2) -> v2));
        System.out.println("map = " + JSON.toJSONString(map));
        }

groupingBy–分组

场景：将这群人相同名字的分成一组
使用：groupingBy分组
输出：peopleMap = {“小孙”:[{“age”:5,“name”:“小孙”}],“小钱”:[{“age”:12,“name”:“小钱”},{“age”:25,“name”:“小钱”}],“小赵”:[{“age”:23,“name”:“小赵”}]}

/**
     * groupingBy -- 分组
     */
    public static void groupingByProcess() {
        List<Person> people = generatePerson();
        Function<Person, String> nameFunction = Person::getName;
        Map<String, List<Person>> peopleMap = people.stream().collect(Collectors.groupingBy(nameFunction));
        System.out.println("peopleMap = " + JSON.toJSONString(peopleMap));
    }

collectingAndThen–去重

场景：将这群人中相同名字、相同年龄的多余人员去掉，仅保留一个
使用：在收集的过程中再进行过滤的操作
输出：去重：[{“age”:5,“name”:“小孙”},{“age”:23,“name”:“小赵”},{“age”:12,“name”:“小钱”},{“age”:25,“name”:“小钱”}]
备注：使用的场景数据是generatePerson2

/**
     * Collectors.collectingAndThen -- 去重
     */
    public static void duplicateRemovalProcess() {

        List<Person> list = generatePerson2();
        List<Person> people = list.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
                        new TreeSet<>(Comparator.comparing(o -> o.getName() + ";" + o.getAge()))), ArrayList::new));

        System.out.println("去重：" + JSON.toJSONString(people));
    }