java8-stream流操作实例

发表于 | 分类于 | 阅读次数:
字数统计: 1.6k | 阅读时长 ≈ 7

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

CSDN博客地址：https://blog.csdn.net/qq_35893033/article/details/128485642

博客地址：芒果-橙

场景数据，案例使用

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
     * 造数据
     *
     * @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 = 小赵;小钱;小孙;小钱
1
2
3
4
5
6
7
8
/**
     * 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 = [小赵, 小钱, 小孙, 小钱]
1
2
3
4
5
6
7
8
9
10
11
12
/**
     * 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]
1
2
3
4
5
6
7
8
9
10
11
/**
     * 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”:”小孙”}]
1
2
3
4
5
6
7
8
9
/**
     * 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
1
2
3
4
5
6
7
8
/**
     * 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”:”小孙”}
1
2
3
4
5
6
7
8
9
/**
     * 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”:”小钱”}
1
2
3
4
5
6
7
8
9
10
/**
     * 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
1
2
3
4
5
6
7
8
/**
     * 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
1
2
3
4
5
6
7
8
/**
     * 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
1
2
3
4
5
6
7
8
/**
 * 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}
  • 备注：注意看输出的小钱，是后设置的数据
1
2
3
4
5
6
7
8
9
10
11
/**
 * 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”:”小赵”}]}
1
2
3
4
5
6
7
8
9
/**
     * 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
1
2
3
4
5
6
7
8
9
10
11
12
/**
     * 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));
    }
------ 本文结束感谢您的阅读 ------

本文标题:java8-stream流操作实例

文章作者:MangoCheng

发布时间:2023年01月01日 - 08:27:28

最后更新:2023年03月04日 - 08:39:02

原始链接:http://mangocheng.com/posts/c54426d4.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。