lambda表达式操作List集合的多种用法，以及stream流的常用api

Arbitrary.`

已于 2022-09-29 09:59:30 修改

阅读量3.6k

点赞数 1

文章标签： java

于 2022-03-24 19:38:19 首次发布

本文链接：https://blog.csdn.net/weixin_43939708/article/details/123698230

版权

新建person类

@Data
public class Person {

    private String name;
    private int age;
    private int size;
    
    public Person(String name, int age, int size) {
        super();
        this.name = name;
        this.age = age;
        this.size = size;
    }
    public Person() {
        super();
    }

}

写主函数，准备测试的list集合数据

package com.zh.entity;

import java.util.ArrayList;
import java.util.List;
import java.util.LongSummaryStatistics;
import java.util.Map;
import java.util.stream.Collectors;

public class LambdaTest {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        Person p1 = new Person("person01",1,1);
        Person p101 = new Person("person100",100,100);
        Person p2 = new Person("person02",2,2);
        Person p3 = new Person("person03",3,3);
        Person p4 = new Person("person04",4,4);
        Person p5 = new Person("person06",5,5);
        Person p6 = new Person("person07",6,6);
        list.add(p1);
        list.add(p2);
        list.add(p2);

        list.add(p101);
        list.add(p3);
        list.add(p4);
        list.add(p4);
        list.add(p4);
        list.add(p5);
        list.add(p6);

1. forEach()进行遍历集合

item：可以是任意值。类似于for循环中的循环值


        list.forEach(item->{
            //设置值
            item.setName(item.getName()+"测试");;
            //输出语句
            System.out.println(item.toString());
        });
        /*输出结果：
        Person(name=person01测试, age=1, size=1)
        Person(name=person02测试, age=2, size=2)
        Person(name=person02测试测试, age=2, size=2)
        Person(name=person100测试, age=100, size=100)
        Person(name=person03测试, age=3, size=3)
        Person(name=person04测试, age=4, size=4)
        Person(name=person04测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person06测试, age=5, size=5)
        Person(name=person07测试, age=6, size=6)*/

2.stream()流操作

2.1. 去重 distinct() 去重；collect(Collectors.toList())。封装成集合

       
        List<Person> distinctList = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重：");
        distinctList.forEach(System.out::println);
        /*去重：
        Person(name=person01测试, age=1, size=1)
        Person(name=person02测试测试, age=2, size=2)
        Person(name=person100测试, age=100, size=100)
        Person(name=person03测试, age=3, size=3)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person06测试, age=5, size=5)
        Person(name=person07测试, age=6, size=6)*/

2.2 排序 sorted((第一个对象，第二个对象)->返回值) （升降序看是第几个对象与第几个对象比较）

        
        List<Person> sortedList = list.stream().sorted((o1,o2)->o2.getAge()-o1.getAge()).collect(Collectors.toList());
        System.out.println("排序：");
        sortedList.forEach(System.out::println);
        /*排序：
        Person(name=person100测试, age=100, size=100)
        Person(name=person07测试, age=6, size=6)
        Person(name=person06测试, age=5, size=5)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person03测试, age=3, size=3)
        Person(name=person02测试测试, age=2, size=2)
        Person(name=person02测试测试, age=2, size=2)
        Person(name=person01测试, age=1, size=1)*/

集合比较的简写方式

        
        list.sort((o1,o2)->{return o1.getAge()-o2.getAge();});
        list.forEach(System.out::println);
        /*Person(name=person01测试, age=1, size=1)
        Person(name=person02测试测试, age=2, size=2)
        Person(name=person02测试测试, age=2, size=2)
        Person(name=person03测试, age=3, size=3)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person06测试, age=5, size=5)
        Person(name=person07测试, age=6, size=6)
        Person(name=person100测试, age=100, size=100)*/

2.3 过滤， filter(item->{}) item为每一项。按照自己的需求来筛选list中的数据


        List<Person> filterList = list.stream().filter(item->item.getAge()>3).collect(Collectors.toList());
        System.out.println("过滤，年龄>3的：");
        filterList.forEach(System.out::println);
        /*过滤，年龄>3的：
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person04测试测试测试, age=4, size=4)
        Person(name=person06测试, age=5, size=5)
        Person(name=person07测试, age=6, size=6)
        Person(name=person100测试, age=100, size=100)*/

2.4 map(), 提取对象中的某一元素. 用每一项来获得属性（也可以直接用对象::get属性()）

        
        System.out.println("提取对象中的某一元素.  用每一项来获得属性（也可以直接用  对象::get属性()）:");
        List<String> mapList1 = list.stream().map(Person::getName).collect(Collectors.toList());
        System.out.println("mapList1 = ");
        mapList1.forEach(System.out::println);
        List<String> mapList2 = list.stream().map(item->item.getName()).collect(Collectors.toList());
        System.out.println("mapList2 = ");
        mapList2.forEach(System.out::println);
        /*
        *
        * mapList1 =
            person01测试
            person02测试测试
            person02测试测试
            person03测试
            person04测试测试测试
            person04测试测试测试
            person04测试测试测试
            person06测试
            person07测试
            person100测试
            mapList2 =
            person01测试
            person02测试测试
            person02测试测试
            person03测试
            person04测试测试测试
            person04测试测试测试
            person04测试测试测试
            person06测试
            person07测试
            person100测试*/

2.5 统计 sum() 。mapToDouble() 转换成double。还有其他类型转换。可以自己研究。

max(),min(),average()

        
        double sum = list.stream().mapToDouble(Person::getAge).sum();
        System.out.println("sum = " + sum);
        /*统计：
        sum = 131.0*/

2.6 分组 Collectors.groupingBy(属性名)

        Map<Integer, List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getAge));
        map.forEach((k,v) -> System.out.println(k+":"+v));
        /*
        *
        * 分组：
            1:[Person(name=person01测试, age=1, size=1)]
            2:[Person(name=person02测试测试, age=2, size=2), Person(name=person02测试测试, age=2, size=2)]
            3:[Person(name=person03测试, age=3, size=3)]
            100:[Person(name=person100测试, age=100, size=100)]
            4:[Person(name=person04测试测试测试, age=4, size=4), Person(name=person04测试测试测试, age=4, size=4), Person(name=person04测试测试测试, age=4, size=4)]
            5:[Person(name=person06测试, age=5, size=5)]
            6:[Person(name=person07测试, age=6, size=6)]
        *
        * */

2.7 多重分组 Collectors.groupingBy(属性，Collectors.groupingBy(属性))

        Map<String, Map<Integer, List<Person>>> map2 = list.stream().collect(Collectors.groupingBy(t->t.getName(),Collectors.groupingBy(t->t.getAge())));
        map2.forEach((k,v) -> {
            System.out.println(k+":");
            v.forEach((vk,vv) -> System.out.println(vk+"："+vv));
        });
        /*
        * 多重分组：
            person01测试:
            1：[Person(name=person01测试, age=1, size=1)]
            person100测试:
            100：[Person(name=person100测试, age=100, size=100)]
            person03测试:
            3：[Person(name=person03测试, age=3, size=3)]
            person06测试:
            5：[Person(name=person06测试, age=5, size=5)]
            person07测试:
            6：[Person(name=person07测试, age=6, size=6)]
            person02测试测试:
            2：[Person(name=person02测试测试, age=2, size=2), Person(name=person02测试测试, age=2, size=2)]
            person04测试测试测试:
            4：[Person(name=person04测试测试测试, age=4, size=4), Person(name=person04测试测试测试, age=4, size=4), Person(name=person04测试测试测试, age=4, size=4)]
        * */

2.8 分组并计算综合 Collectors.summarizingLong()

        
        Map<String, Map<Integer, LongSummaryStatistics>> map3 = list.stream().collect(Collectors.groupingBy(t->t.getName(),Collectors.groupingBy(t->t.getAge(),Collectors.summarizingLong(Person::getSize))));
        map3.forEach((k,v) -> {
            System.out.println(k+":");
            v.forEach((vk,vv) -> System.out.println(vk+"："+vv));
        });
        /*
        * 分组并计算综合:
            person01测试:
            1：LongSummaryStatistics{count=1, sum=1, min=1, average=1.000000, max=1}
            person100测试:
            100：LongSummaryStatistics{count=1, sum=100, min=100, average=100.000000, max=100}
            person03测试:
            3：LongSummaryStatistics{count=1, sum=3, min=3, average=3.000000, max=3}
            person06测试:
            5：LongSummaryStatistics{count=1, sum=5, min=5, average=5.000000, max=5}
            person07测试:
            6：LongSummaryStatistics{count=1, sum=6, min=6, average=6.000000, max=6}
            person02测试测试:
            2：LongSummaryStatistics{count=2, sum=4, min=2, average=2.000000, max=2}
            person04测试测试测试:
            4：LongSummaryStatistics{count=3, sum=12, min=4, average=4.000000, max=4}
          * */
    }
}