JDK8中List的steam()一些常用用法和测试案例

风再起时_k

已于 2023-11-17 11:06:19 修改

阅读量290

点赞数

文章标签： list java jdk

于 2023-11-02 15:23:05 首次发布

本文链接：https://blog.csdn.net/weixin_44669698/article/details/134183219

版权

创建实体类（后面排序会用）

import java.util.Objects;

public class Person {
    int a = 1;
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {
        a = a+100;
        System.out.println("List的steam用法.Person init");
    }

    public void say(){
        System.out.println("List的steam用法.Person num "+a);
    }

    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 "Person{" +
                "a=" + a +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

测试代码，复制直接运行

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

public class List的stream用法 {
    public static void main(String[] args) {
        System.out.println("——————————————List中为普通类型——————————————");
        List<Integer> intList = new ArrayList();
        intList.add(5);
        intList.add(4);
        intList.add(2);
        intList.add(1);
        intList.add(3);
        intList.add(6);
        intList = intList.stream()
                // 筛选小于等于5的元素
                .filter(num -> num<=5)
                // 排序，默认升序
                .sorted()
                // 保留前3条
                .limit(3)
                //.sorted(Comparator.comparing(Integer::byteValue,Comparator.reverseOrder()))
                // 上面降序，不着急了解，可忽略
                // 输出为List
                .collect(Collectors.toList());
        // 打印结果
        intList.forEach(System.out::println);

        System.out.println("——————————————List中为实体类——————————————");
        List<Person> list = new ArrayList<>();
        list.add(new Person("a",17));
        list.add(new Person("b",17));
        list.add(new Person("c4",19));
        list.add(new Person("c3",19));
        list.add(new Person("e",18));
        list.add(new Person("f",20));
        list.add(new Person("g",21));
        list.add(new Person("h",21));
        list = list.stream()
                // 筛选年龄小于等于20岁的人
                .filter(person -> person.getAge()<=20)
                // 先根据年龄排序，再根据姓名排序（默认升序，降序的话追加.reversed()方法或像上面一样用Comparator.reverseOrder()，先了解,详细的比较器后面另说)
                .sorted(Comparator.comparing(Person::getAge).thenComparing(Person::getName))
                // 将操作后的strea转为List
                .collect(Collectors.toList());
        // 打印结果
        list.forEach(p -> {
            System.out.println(p.getName()+"——"+p.getAge());
        });
        System.out.println("——————————————toMap使用——————————————");
        // 添加一个重复的key
        list.add(new Person("a",100));
        // 注意此处封装的是Map
        Map<String, Integer> map = list.stream()
                .collect(Collectors.toMap(
                        Person::getName,// 生成key
                        Person::getAge // 生成value
                        // (重点)处理key相同时的情况（oldValue和newValue名称可以随便取，前面的为key旧值，后面的为key新值，->选择保留值）
                        ,(oldValue, newValue) -> newValue // 注释此行也可以运行，但当key重复时报异常，可以试一试
                ));
        // 打印结果
        map.forEach((key,value) ->{
            System.out.println(key+"——"+value);
        });
        System.out.println("——————————————.map()使用——————————————");
        // 加入重复数据Persn{b,17}顺带演示distinct去重
        list.add(new Person("b",17));
        list.add(new Person("b",17));
        list.add(new Person("b",17));
        List<String> collect = list.stream()
                // 先去重Person
                .distinct()
                // 再流元素重做映射，只保留name属性，变为List<String>
                .map(Person::getName)
                .collect(Collectors.toList());
        // 打印结果发现，只保留了name，且去重后只有一个b
        collect.forEach(c -> {
            System.out.println(c);
        });
        System.out.println("——————————————Collectors.groupingBy——————————————");
        Map<Integer, List<Person>> collect1 = list.stream().collect(Collectors.groupingBy(Person::getAge));
        collect1.forEach((key,value)->{
            System.out.println(key);
            System.out.println(value);
        });
        System.out.println("——————————————Collectors.joining(\"something\")——————————————");
        String s = "~~~".concat(list.stream().map(Person::getName).collect(Collectors.joining(";")));
        System.out.println(s);
    }
}

运行结果

——————————————List中为普通类型——————————————
1
2
3
——————————————List中为实体类——————————————
a——17
b——17
e——18
c3——19
c4——19
f——20
——————————————toMap使用——————————————
c3——19
c4——19
a——100
b——17
e——18
f——20
——————————————.map()使用——————————————
a
b
e
c3
c4
f
a
——————————————Collectors.groupingBy——————————————
17
[Person{a=1, name='a', age=17}, Person{a=1, name='b', age=17}, Person{a=1, name='b', age=17}, Person{a=1, name='b', age=17}, Person{a=1, name='b', age=17}]
18
[Person{a=1, name='e', age=18}]
19
[Person{a=1, name='c3', age=19}, Person{a=1, name='c4', age=19}]
100
[Person{a=1, name='a', age=100}]
20
[Person{a=1, name='f', age=20}]
——————————————Collectors.joining("something")——————————————
~~~a;b;e;c3;c4;f;a;b;b;b