Java lambda 表达式

prepare

• PersonDO

public class PersonDO {
    private String name;

    private Integer age;

    public PersonDO(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public PersonDO() {
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "PersonDO{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

• 生成测试数据

	private Random r = new Random();
	personList = getPersonList(5);

    /**
     * 生成待处理数据
     *
     * @param size
     * @return
     */
    public List<PersonDO> getPersonList(int size) {
        List<PersonDO> personList = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            PersonDO p = genPerson();
            personList.add(p);
        }
        return personList;
    }


    /**
     * 生成单个对象
     *
     * @return
     */
    public PersonDO genPerson() {
        String name = genRandomStr(5);
        int age = r.nextInt(10) + 15;

        return new PersonDO(name, age);
    }
    

extract

List<String> names = personList.stream().map(PersonDO::getName).collect(Collectors.toList());

distinct

// 姓名去重
List<String> distinctName = personList.stream()
        .map(PersonDO::getName)
        .distinct()
        .collect(Collectors.toList());

grouping

// 分组聚合
Map<Integer, List<PersonDO>> ageMap = personList.stream().collect(Collectors.groupingBy(PersonDO::getAge));

// 分组求和：按照姓名分组 统计年龄之和
Map<String, Integer> nameGroupSumAge = personList.stream()
        .collect(Collectors.groupingBy(PersonDO::getName, Collectors.summingInt(PersonDO::getAge)));

// 分组均值：按照姓名分组 统计年龄均值
Map<String, Double> nameGroupAvgAge = personList.stream()
        .collect(Collectors.groupingBy(PersonDO::getName, Collectors.averagingInt(PersonDO::getAge)));

// 分组取最小：按照姓名分组 再取年龄最小
Map<String, PersonDO> nameGroupSmallestOne = personList.stream()
        .collect(
                Collectors.groupingBy(PersonDO::getName,
                        Collectors.collectingAndThen(
                                Collectors.minBy(Comparator.comparing(PersonDO::getAge)), Optional::get)
                )
        );

// 分组取最大：按照姓名分组 再取年龄最大
Map<String, PersonDO> nameGroupBiggestOne = personList.stream()
        .collect(
                Collectors.groupingBy(PersonDO::getName,
                        Collectors.collectingAndThen(
                                Collectors.maxBy(Comparator.comparing(PersonDO::getAge)), Optional::get)
                )
        );

// 分组排序：按照姓名分组 按照年龄升序排列
Map<String, List<PersonDO>> nameGroupSortList = personList.stream()
        .collect(
                Collectors.groupingBy(PersonDO::getName,
                        Collectors.collectingAndThen(
                                Collectors.toList(), groupPersonList -> {
                                    groupPersonList.sort(Comparator.comparing(PersonDO::getAge));
                                    return groupPersonList;
                                }
                        )
                )
        );

sort

// sort 
List<PersonDO> afterSort = personList.stream().sorted(Comparator.comparing(PersonDO::getAge).thenComparing(PersonDO::getName)).collect(Collectors.toList());

// sort desc
List<PersonDO> afterDescSort = personList.stream().sorted(Comparator.comparing(PersonDO::getAge, (o1,o2)-> o2-o1).thenComparing(PersonDO::getName)).collect(Collectors.toList());
        
// sort & extract
List<Integer> afterSortExtract = personList.stream().sorted(Comparator.comparing(PersonDO::getAge).thenComparing(PersonDO::getName)).map(PersonDO::getAge).collect(Collectors.toList());

filter

// filter 
List<PersonDO> afterFilter = personList.stream().filter((p) -> (p.getAge() > 18)).collect(Collectors.toList());

// filter & Limit
List<PersonDO> afterFilter = personList.stream().filter((p) -> (p.getAge() > 18)).limit(2).collect(Collectors.toList());

// filter & Extract
List<String> afterFilter = personList.stream().filter((p) -> (p.getAge() > 18)).map(PersonDO::getName).collect(Collectors.toList());

transform

// Object Map
Map<String, PersonDO> nameMap = personList.stream().collect(Collectors.toMap(PersonDO::getName, Function.identity(), (k1, k2) -> k2));


// Field Map
Map<Integer, String> ageMap = personList.stream().collect(Collectors.toMap(PersonDO::getAge, PersonDO::getName, (k1, k2) -> k1));