java8Lambda表达式总结

一.Lambda表达式简介

 Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

二.常见语法

      (parameters) -> expression 或 (parameters) ->{ statements; }

三.Lambda使用案例

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.Function;
import java.util.stream.Collectors;
public class LambdaDemo {

    public static void main(String[] args) {

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("张三", 18, new BigDecimal(15000)));
        personList.add(new Person("李四", 50, new BigDecimal(11000)));
        personList.add(new Person("王二", 17, new BigDecimal(12000)));
        personList.add(new Person("麻子", 20, new BigDecimal(5000)));
        System.out.println(personList.toString());
        // 统计数量
        Long num = personList.stream().collect(Collectors.counting());
        System.out.println(num);
        // 不使用Lambda
        System.out.println(personList.size());
        // 最大值
        Person maxVal =
                personList.stream().collect(Collectors.maxBy(Comparator.comparingInt(Person::getAge))).get();
        System.out.println("最大值" + maxVal);

        Person minVal =
                personList.stream().collect(Collectors.minBy(Comparator.comparingInt(Person::getAge))).get();
        System.out.println("最小值" + minVal);

        // 求和
        Long sum = personList.stream().collect(Collectors.summarizingInt(Person::getAge)).getSum();
        System.out.println("求和" + sum);

        // 平均值
        Double avg = personList.stream().collect(Collectors.averagingDouble(Person::getAge));
        System.out.println("平均值" + avg);
        // 普通分组
        Map<Integer, List<Person>> map = personList.stream().collect(Collectors.groupingBy(Person::getAge));
        for (Entry<Integer, List<Person>> mapRes : map.entrySet()) {
            System.out.println(mapRes.getKey() + "普通分组--" + mapRes.getValue());
        }

        // 5.一级分组
        Map<String, List<Person>> collect = personList.stream().collect(Collectors.groupingBy(person -> {
            if (person.getAge() >= 30) {
                return "30";
            } else if (person.getAge() >= 25) {
                return "25";
            } else {
                return "20";
            }
        }));

        for (Entry<String, List<Person>> mapRes : collect.entrySet()) {
            System.out.println(mapRes.getKey() + "一级分组--" + mapRes.getValue());
        }

        // 6.多级分组
        Map<String, Map<BigDecimal, List<Person>>> collect1 =
                personList.stream().collect(Collectors.groupingBy(p -> {
                    if (p.getAge() >= 30) {
                        return "30";
                    } else if (p.getAge() >= 25) {
                        return "25";
                    } else {
                        return "20";
                    }
                }, Collectors.groupingBy(Person::getSal)));

        for (Entry<String, Map<BigDecimal, List<Person>>> mapRes : collect1.entrySet()) {
            System.out.println(mapRes.getKey() + "多级分组--" + mapRes.getValue());
        }

        // 8.将对象集合中的属性转换映射到新的集合
        List<Integer> ageList = personList.stream().map(Person::getAge).collect(Collectors.toList());
        System.out.println("转list--" + ageList);

        // 9.将对象的一个属性作为 Map 的 key,本身作为 value 映射到 Map 集合
        Map<Integer, Person> mapRes =
                personList.stream().collect(Collectors.toMap(Person::getAge, Function.identity()));
        // 10.将对象的一个属性作为 Map 的 key,属性 映射到 Map 集合
        Map<Integer, String> mapRes1 =
                personList.stream().collect(Collectors.toMap(Person::getAge, Person::getName));
        // 11.通过属性过滤数据
        List<Person> empList = personList.stream().filter(p -> p.getAge() > 20).collect(Collectors.toList());

        // 12.数值进行求和算数操作,并将结果四舍五入
        BigDecimal totalIncome = personList.stream().map(Person::getSal)
                .reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);

        System.out.println("--------单条件排序开始-----------");
        // 13.单条件排序
        List<Person> sortList1 =
                personList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
        sortList1.forEach((e) -> {
            System.out.println(e.toString());
        });
        System.out.println("--------单条件排序结束-----------");

        System.out.println("--------多条件排序开始-----------");
        // 14.多条件排序
        List<Person> sortList2 = personList.stream()
                .sorted(Comparator.comparing(Person::getAge).thenComparing(Person::getSal).reversed())
                .collect(Collectors.toList());
        sortList2.forEach((e) -> {
            System.out.println(e.toString());
        });

        System.out.println("--------多条件排序结束-----------");
    }
}
import java.math.BigDecimal;
public class Person {

    private String name;

    private Integer age;

    private BigDecimal sal;

    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;
    }

    public BigDecimal getSal() {

        return sal;
    }

    public void setSal(BigDecimal sal) {

        this.sal = sal;
    }

    public Person(String name, Integer age, BigDecimal sal) {

        super();
        this.name = name;
        this.age = age;
        this.sal = sal;
    }

    @Override
    public String toString() {

        return "Person [name=" + name + ", age=" + age + ", sal=" + sal + "]";
    }

}