Java8新特性 Lambda表达式处理List

1. Lambda表达式处理List

最近在做项目的过程中经常会看到 lambda 表达式，随后发现它基本上可以替代所有 for 循环，包括增强for循环。绝大部分的for循环都可以用 lambda 表达式改写。

lambda表达式优点：
（1）简洁，
（2）易并行计算。尤其适用于遍历结果，循环计算数值或者赋值的时候非常方便。

缺点: （1）若不用并行计算，很多时候计算速度没有比传统的 for 循环快。

　　 （2）不容易使用debug模式调试。

　　 （3）在 lambda 语句中直接强制类型转换不方便。

　　 （4）不可以在foreach中修改foreach外面的值。
           

下面是我再开发过程中经常使用过的表达式去处理list集合。

（1）先新建一个实体类

public class Person {
    private Integer id;

    private String name;

    private String sex;

    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Person(Integer id, String name, String sex, Integer age) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

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

2）写主函数。说明会写在代码中

```public class JdkTest {

    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        Person p1 = new Person(1,"谢逊","男",53);
        Person p2 = new Person(2,"赵敏","女",18);
        Person p3 = new Person(3,"张翠山","男",33);
        Person p4 = new Person(4,"张三丰","男",99);
        Person p5 = new Person(5,"张无忌","男",20);
        Person p6 = new Person(6,"张无忌","男",20);
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);
        /**
         * 1.forEach()进行遍历集合，item：可以是任意值。类似于for循环中的循环值
         */
         
        list.forEach(item->{
            System.out.println(item.toString());
        });
        
        /**
         * 2.stream()流操作
         */

        //2.1 map(), 提取对象中的某一元素.  用每一项来获得属性（也可以直接用  对象::get属性()）
        List<String> map1 = list.stream().map(Person::getName).collect(Collectors.toList());

        List<String> map2 = list.stream().map(item->item.getName()).collect(Collectors.toList());
        
        /**
         * 2.2 List转Map
         * id为key，Person对象为value，需要注意的是：
         * toMap 如果集合对象有重复的key，会报错Duplicate key ....
         * 可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
         */
         
        Map<Integer, Person> Map = list.stream().collect(Collectors.toMap(Person::getId, a -> a,(k1, k2)->k1));

        //2.3 过滤 ， filter(item->{})   item为每一项。 按照自己的需求来筛选list中的数据
        List<Person> filterList = list.stream().filter(item->item.getAge()>30).collect(Collectors.toList());

        //2.4 去重 distinct() 根据name去重。封装成集合
        List<Person> distinctList = list.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new));

        //2.5 求和   将集合中的数据按照某个属性求和:
        int sum = list.stream().mapToInt(Person::getAge).sum();

       //2.6 分组   Collectors.groupingBy(属性名)
        Map<Integer, List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getId));

       //2.7 多重分组 Collectors.groupingBy(属性，Collectors.groupingBy(属性))
        Map<String, Map<Integer, List<Person>>> map3 = list.stream()
                .collect(Collectors.groupingBy(p->p.getName(),Collectors.groupingBy(p->p.getAge())));
                
       //2.8 查找最大 最小的 Person
        //最大
        Person maxAgePerson = list.stream().max(Comparator.comparing(Person::getAge)).get();
        //最小
        Person minAgePerson = list.stream().min(Comparator.comparing(Person::getAge)).get();
        
        /**
         * 3. 排序
         */
        //倒序
        List<Person> newList = list.stream().sorted(Comparator.comparing(Person::getAge).reversed())
                .collect(Collectors.toList());
        // 正序
        List<Person> newList2 = list.stream().sorted(Comparator.comparing(Person::getAge))
                .collect(Collectors.toList()); 
        
    }
}