Lambada List集合操作实例

主要包含常用的排序、取某个属性list、按照属性分组、过滤集合、list转map重复key覆盖、获取最大最小值及平均数、获取基本类型的和、获取Bigdecimal求和、对基本集合去重、对集合中相同属性进行计数、集合排序、倒叙排序、多个字段排序等。
（1）person实体类

package com.example.projectmain;
import java.math.BigDecimal;
/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 2023/1/6/006
 * Time: 15:57
 * Description: No Description
 */
public class Person {
    public int age;
    public String sex;
    public BigDecimal weight;
    public double score;

    public BigDecimal getWeight() {
        return weight;
    }

    public void setWeight(BigDecimal weight) {
        this.weight = weight;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public Person(int age, String sex, double score,BigDecimal weight) {
        this.age = age;
        this.sex = sex;
        this.score = score;
        this.weight=weight;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", sex=" + sex +
                ", weight=" + weight +
                ", score=" + score +
                '}';
    }
}

（2）方法及测试

public class test {
    public static void main(String[] args) {
        List<Person> persons = new ArrayList<>();
        persons.add(new Person(22, "男", 90.0,new BigDecimal(150)));
        persons.add(new Person(17, "女", 91.0,new BigDecimal(152)));
        persons.add(new Person(12, "男", 92.0,new BigDecimal(155)));
        persons.add(new Person(12, "女", 92.0,new BigDecimal(158)));
        persons.add(new Person(25, "女", 93.0,new BigDecimal(159)));
//        sortPersons(persons);//排序
//        ages(persons);//取某个属性list
          groupbySex(persons);//按照属性分组
//        filterPersons(persons);//过滤集合
//        keyMap(persons);//list转map重复key覆盖
//        getDataMap(persons);//获取最大最小值及平均数
//        sumAge(persons);//获取基本类型的和
//        bigDecimalWeightSum(persons);//获取Bigdecimal求和
//        distinctAgeList(persons);//对基本集合去重
//        countByList(persons);//对集合中相同属性进行计数
//        sort(persons);//集合排序
//        sorted(persons);//集合排序
//        reverseOrder(persons);//倒叙排序
//        multiOrder(persons);//多个字段排序
    }
    /**
     * List排序
     * @param persons
     * @return
     */
    public static List<Person> sortPersons(List<Person> persons){
        persons.sort((Person o1, Person o2) -> {
            return o1.age - o2.age;
        });
        /*
        Person{age=12, sex=男, score=92.0}
        Person{age=17, sex=女, score=91.0}
        Person{age=22, sex=男, score=90.0}
        Person{age=25, sex=女, score=93.0}
         */
        persons.forEach(System.out::println);
        return persons;
    }
    //取某个属性List
    public static List<Integer> ages(List<Person> persons){
        List<Integer> ages=persons.stream().map(Person::getAge).collect(Collectors.toList());
        ages.forEach(System.out::println);
        return ages;
    }
    //按照属性分组
    public static Map<String, List<Person>> groupbySex(List<Person> persons){
        Map<String, List<Person>> groupbySexs=persons.stream().collect(Collectors.groupingBy(Person::getSex));
        //{女=[Person{age=17, sex=女, score=91.0}, Person{age=25, sex=女, score=93.0}], 男=[Person{age=12, sex=男, score=92.0}, Person{age=22, sex=男, score=90.0}]}
        System.out.println(groupbySexs);
        return groupbySexs;
    }
    //过滤集合
    public static List<Person> filterPersons(List<Person> persons){
      List<Person> filterPersons=persons.stream().filter(Person->Person.getAge()>=17).collect(Collectors.toList());
      //[Person{age=17, sex=女, score=91.0}, Person{age=22, sex=男, score=90.0}, Person{age=25, sex=女, score=93.0}]
      System.out.println(filterPersons);
      return filterPersons;
    }
    //list转map重复key覆盖
    public static Map<Integer,Person> keyMap(List<Person> persons){
        Map<Integer,Person> keyPersonMap=persons.stream().collect(Collectors.toMap(Person::getAge, Function.identity(),(key1, key2)->key1));
        System.out.println(keyPersonMap);
        return keyPersonMap;
    }
    //获取最大最小值及平均数
    public static Map<String,Object> getDataMap(List<Person> persons){
        Map<String,Object> dataMap=new HashMap<>();
        //最大值
        Integer max=persons.stream().mapToInt(Person::getAge).max().getAsInt();
        Integer min=persons.stream().mapToInt(Person::getAge).min().getAsInt();
        double  Average=persons.stream().mapToInt(Person::getAge).average().getAsDouble();
        dataMap.put("max",max);
        dataMap.put("min",min);
        dataMap.put("Average",Average);
        System.out.println(dataMap);
        return dataMap;
    }
    //基本类型求和
    public static Integer sumAge(List<Person> persons){
        Integer sumAge=persons.stream().mapToInt(Person::getAge).sum();
        System.out.println("sumAge:"+sumAge);
        return sumAge;
    }
    //bigdecimal求和
    public static BigDecimal bigDecimalWeightSum(List<Person> persons){
       BigDecimal weightSum=persons.stream().map(Person::getWeight).reduce(BigDecimal.ZERO,BigDecimal::add);
       System.out.println("weightSum:"+weightSum);
       return weightSum;
    }
    //对基本集合去重
    public static List<Integer> distinctAgeList(List<Person> persons){
        List<Integer> ages=ages(persons);
        System.out.println("ages:"+ages);
        List<Integer> distinctAgeList=ages.stream().distinct().collect(Collectors.toList());
        System.out.println("distinctAgeList:"+distinctAgeList);
        return distinctAgeList;
    }
    //判断是否存在某个属性值
    public static boolean  exist(List<Person> persons){
        boolean exist=persons.stream().allMatch(s->s.getAge()==12);
        System.out.println("exist:"+exist);
        return exist;
    }
    //对集合中相同属性进行计数
    public static long countByList(List<Person> persons){
        long count=persons.stream().filter(s->s.getAge()==12).count();
        System.out.println("count:"+count);
        return count;
    }
    //对集合进行排序
    public static List<Person> sort(List<Person> persons){
        persons.sort(Comparator.comparing(Person::getAge));
        System.out.println("persons-1:"+persons);
        return persons;
    }
    //对集合进行排序
    public static List<Person> sorted(List<Person> persons){
        persons.stream().sorted(Comparator.comparing(Person::getAge));
        System.out.println("persons-2:"+persons);
        return persons;
    }
    //倒序排序
    public static List<Person> reverseOrder(List<Person> persons){
       persons.sort(Comparator.comparing(Person::getAge,Comparator.reverseOrder()));
       System.out.println("persons-rever:"+persons);
       return persons;
    }
    //多个字段排序
    public static List<Person> multiOrder(List<Person> persons){
        persons.sort(Comparator.comparing(Person::getAge,Comparator.reverseOrder()).thenComparing(Person::getWeight));
        System.out.println("persons:"+persons);
        return persons;
    }
}