java--java8 新特性 之 Lambda 表达式 list、set、map使用案例

一、Lambda 表达式

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

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

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

lambda表达式的重要特征:

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

 

lambda注意事项：

1.变量作用域：lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。或者外部变量没有final标记且lambda内没有修改外部变量也不报错。总而言之 lambda 内不可以修改外部变量！

2.在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

1.list遍历集合

.forEach()方法

ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list, 1,2,3,4,5);

//lambda表达式1 直接输出每个元素
list.forEach(System.out::println);
//lambda表达式2 直接输出每个元素 
list.forEach(element -> {
   System.out.println(element);
});

2.list删除集合中的某个元素

.removeIf()方法

public class Java8Test {
    private int id;
    private String name;
    private int age;
    public Java8Test(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "id: " + id + " name: " + name + " age: " + age;
    }
    public static void main(String args[]){
        ArrayList<Java8Test> list = new ArrayList<>();
        list.add(new Java8Test(1,"zhangsan",20));
        list.add(new Java8Test(2,"lisi",21));
        list.add(new Java8Test(3,"wangwu",22));
        list.add(new Java8Test(4,"zhaoliu",23));
        list.removeIf(filter -> "lisi".equals(filter.name));
        list.forEach(item -> System.out.println(item.toString()));
    }
}

输出结果：

id: 1 name: zhangsan age: 20
id: 3 name: wangwu age: 22
id: 4 name: zhaoliu age: 23

 3.list集合内元素的排序

.sort()方法

public class Java8Test {
    private int id;
    private String name;
    private int age;
    public Java8Test(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "id: " + id + " name: " + name + " age: " + age;
    }
    public static <T> void main(String args[]){
        ArrayList<Java8Test> list = new ArrayList<>();
        list.add(new Java8Test(1,"zhangsan",18));
        list.add(new Java8Test(2,"lisi",15));
        list.add(new Java8Test(3,"wangwu",20));
        list.add(new Java8Test(4,"zhaoliu",19));
        list.add(new Java8Test(5,"tianqi",18));
        //java8版本之前排序
        /*list.sort(new Comparator<Java8Test>() {
            @Override
            public int compare(Java8Test o1, Java8Test o2) {
                return o1.age - o2.age;
            }
        });*/
        //java8 排序
        list.sort((Java8Test o1, Java8Test o2) -> o1.age - o2.age);
        list.forEach(item -> System.out.println(item.toString()));
    }
}

4.set遍历集合、set删除某个元素、set排序

      4-1.set遍历

             和list遍历相同 不在赘述

      4-2.set删除某个元素

              和list 删除某个元素 相同 不在赘述

      4-3.set排序

public static void main(String args[]){
        Set<String> set = new HashSet<>();
        set.add("31");
        set.add("22");
        set.add("43");
        set.add("12");
        set.add("34");
        //java8 版本之前排序
        /*Set<String> sortSet = new TreeSet<String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);//降序排列
            }
        });
        sortSet.addAll(set);*/

        //java8 lambda排序1
        Set<String> sortSet = new TreeSet<String>((o1, o2) -> o2.compareTo(o1));
        sortSet.addAll(set);

        //java8 lambda排序2
        /*Set<String> sortSet = new TreeSet<String>(Comparator.naturalOrder());//Comparator.naturalOrder()升序；Comparator.reverseOrder()降序；
        sortSet.addAll(set);*/

        //java8 流排序 只能升序??
        /*Set<String> sortSet = new TreeSet<String>();
        sortSet.addAll(set);
        //sortSet.stream().sorted(Comparator.reverseOrder()); //亲测只能升序排！！what??
        //sortSet.stream().sorted((o1, o2) -> o2.compareTo(o1));//亲测只能升序排！！what??
        sortSet.stream().sorted(new Comparator<String>() { //亲测只能升序排！！what??
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);//降序排列
            }
        });*/
        sortSet.forEach(System.out :: println);

    }

5.map遍历集合、map删除某个元素、map排序

public static void main(String args[]){
        Map<String,String> map = new HashMap<>();
        map.put("zhangsan", "15");
        map.put("lisi", "20");
        map.put("wangwu", "17");
        map.put("zhaoliu", "19");
        map.put("tianqi", "14");
        //大致的思路是把Map的EntrySet转换成list，然后使用Collections.sort排序, 根据排序需求改写comparator
        List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());
        //1. 匿名函数写法:
        /*Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
            @Override
            public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                return o2.getValue().compareTo(o1.getValue());//降序
            }
        });*/

        //2. lambda表达式写法:
        //按value降序
        Collections.sort(list, (Map.Entry<String, String> o1, Map.Entry<String, String> o2)->o2.getValue().compareTo(o1.getValue()));

        //3.精简写法 默认升序排列，若要按value降序用上面的lambda表达式
        //Collections.sort(list,Comparator.comparing(Map.Entry<String, String> :: getValue));

        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        for (Map.Entry<String, String> e: list) {
            linkedHashMap.put(e.getKey(), e.getValue());
        }
        //map遍历
        linkedHashMap.forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }