Java8集合操作collect、filter、toMap、groupingBy、partitioningBy

最新推荐文章于 2023-07-07 16:33:39 发布

最初的倔强

最新推荐文章于 2023-07-07 16:33:39 发布

阅读量752

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_34042417/article/details/117336282

java 专栏收录该内容

22 篇文章

订阅专栏

本文演示了Java8中对集合操作的新特性，包括使用forEach遍历集合，将对象List转换为Map并处理键冲突，筛选List对象属性，过滤和筛选集合，按特定属性分组以及根据条件对集合进行分区。这些操作展示了Java8在处理集合时的灵活性和高效性。

记录下Java8中新特性对集合的相关操作。

新建个person类：

package mytest;

public class Person {
    private String name;
    private String address;

    public String getSex() {
        return sex;
    }

    private String sex;

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public Person(String name, String address, String sex) {
        this.name = name;
        this.address = address;
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public Person(String name, String address) {
        this.name = name;
        this.address = address;
    }

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

    public void setAddress(String address) {
        this.address = address;
    }
}

准备测试数据：

List<Person> people = new ArrayList<>();
people.add(new Person("小米","江西","女"));
people.add(new Person("小米","江西","女"));
people.add(new Person("小民","江西","男"));
people.add(new Person("小红","湖南","女"));
people.add(new Person("小名","湖南","男"));

1、forEach循环

people.forEach(person -> {
    System.out.println(JSON.toJSON(person));
});


/****输出****/
{"address":"江西","sex":"女","name":"小米"}
{"address":"江西","sex":"女","name":"小米"}
{"address":"江西","sex":"男","name":"小民"}
{"address":"湖南","sex":"女","name":"小红"}
{"address":"湖南","sex":"男","name":"小名"}

2、对象List转Map,当map两个元素key相等时，取最后一个key对应的value

Map<String, String> phoneBook1 = people.stream().collect(toMap(p->p.getName(), p->p.getAddress(), (s, a) -> a));
System.out.println(phoneBook1);


/****输出****/
{小名=湖南, 小红=湖南, 小民=江西, 小米=湖北}

3、对象List转Map,当map两个元素key相等时，取两个key对应的value值相加

Map<String, String> phoneBook2 = people.stream().collect(toMap(p->p.getName(), p->p.getAddress(), (s, a) -> a+","+s));
System.out.println(phoneBook2);


/****输出****/
{小名=湖南, 小红=湖南, 小民=江西, 小米=湖北,江西}

4、筛选List对象集合某个属性形成新的集合

List<String> names = people.stream().map(item -> item.getName()).collect(Collectors.toList());
System.out.println(names);


/****输出****/
[小米, 小米, 小民, 小红, 小名]

5、根据某条件过滤list集合

List<Person> womens = people.stream().filter(item -> !"男".equals(item.getSex())).collect(Collectors.toList());
System.out.println(womens);



/****输出****/
[mytest.java8List.Person@7530d0a, mytest.java8List.Person@27bc2616, mytest.java8List.Person@3941a79c]

6、根据某条件过滤后筛选集合对象某个属性形成新的集合

List<String> womens1 = people.stream().filter(item -> !"男".equals(item.getSex())).map(item -> item.getName()).collect(Collectors.toList());
System.out.println(womens1);



/****输出****/
[小米, 小米, 小红]

7、按照地址+性别堆list对象集合分组

Map<String, List<Person>> groupByPerson = people.stream().collect(Collectors.groupingBy(
                p -> JSON.toJSONString(new String[]{p.getAddress(),p.getSex()}),
                Collectors.toList()));
System.out.println(groupByPerson);



/****输出****/
{["江西","女"]=[mytest.java8List.Person@7530d0a], ["江西","男"]=[mytest.java8List.Person@1b701da1], ["湖南","男"]=[mytest.java8List.Person@726f3b58], ["湖北","女"]=[mytest.java8List.Person@27bc2616], ["湖南","女"]=[mytest.java8List.Person@3941a79c]}

8、根据性别分组

Map<Boolean, List<Person>> partitioningByPerson = people.stream().collect(Collectors.partitioningBy(s -> {
     String sex = s.getSex();
     return "女".equals(sex);
}));
System.out.println(partitioningByPerson);


/****输出****/
{false=[mytest.java8List.Person@1b701da1, mytest.java8List.Person@726f3b58], true=[mytest.java8List.Person@7530d0a, mytest.java8List.Person@27bc2616, mytest.java8List.Person@3941a79c]}

partitioningBy和groupingBy都是用于将数据进行分组的函数。
两者的区别要从函数的签名看起。
partitioningBy函数的定义如下

public static <T>
    Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
        return partitioningBy(predicate, toList());
    }

可以看出函数的参数一个Predicate接口，那么这个接口的返回值是boolean类型的，也只能是boolean类型，然后他的返回值是Map的key是boolean类型，也就是这个函数的返回值只能将数据分为两组也就是ture和false两组数据。

groupingBy函数的定义，仅查看与partitioningBy参数相同的定义

public static <T, K> Collector<T, ?, Map<K, List<T>>>
    groupingBy(Function<? super T, ? extends K> classifier) {
        return groupingBy(classifier, toList());
    }

groupingBy的函数参数为Function然后他的返回值也是Map，但是他的key是泛型，那么这个分组就会将数据分组成多个key的形式。