Java8新特性-Lambda表达式

junewgl

已于 2022-08-12 15:48:34 修改

阅读量830

点赞数 5

分类专栏： Java基础文章标签： java 排序 lambda表达式

于 2022-04-09 13:24:05 首次发布

本文链接：https://blog.csdn.net/qq_40755094/article/details/124053387

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.概念

Lambda表示式是一个匿名函数，java8允许把函数作为参数传递到方法中

2.语法

参数parameters-> 表达式expression  或者
参数parameters-> {声明statements;}

3.作用

使用 Lambda 表达式可以使代码变的更加简洁紧凑。让 java 也能支持简单的函数式编程。

4.常见的应用场景

1.集合排序 --替代匿名内部类，排序替代的是`Comparator` 接口

排序场景1

假如集合list存放的元素就是一个整数int, 如何实现升序和降序？

比如对集合的list进行排序，Collections.sort（list）就可以了，此时默认为升序排列。如果我们需要降序输出呢，那么反转一下就可以Collections.reverse(list)，这样就可以了。

这里使用lambda表达式的话，直接一行代码：Collections.sort(list, (a, b) -> (b - a));就可以了。

排序场景2

进一步思考，假如这个list里面存储了两个数字，我们希望按照第二列降序处理，怎么办？

显然使用自带的排序Collections.sort(list)，是远远不够的，这时候使用lambda表达式很方便

Collections.sort(list, (a, b) -> b[1] - a[1]);

测试代码：

        List<int[]>list = new ArrayList<int[]>();
        list.add(new int[]{111, 234});
        list.add(new int[]{222, 345});
        list.add(new int[]{221, 345});
        list.add(new int[]{223, 345});
        Collections.sort(list, (a, b) -> b[1] - a[1]);
        for(int[] i : list)
            System.out.println(i[0] + " " + i[1]);

测试结果：

这时候发现已经按照第二列进行降序输出了，满足题意。

排序场景3

再进一步思考，我们希望先按照第二列的数字降序排列，然后假如两个数字相等，那么按照第一列的数字降序排列。这种要求怎么实现呢？

也就是在场景2的测试代码中，我们希望先输出 223，345，然后再输出222， 345，然后再输出221， 345。

显然普通排序肯定是解决不了的，这时候用lambda表示式比较简单

核心代码：

        List<int[]>list = new ArrayList<int[]>();
        list.add(new int[]{111, 234});
        list.add(new int[]{222, 345});
        list.add(new int[]{221, 345});
        list.add(new int[]{223, 345});
        // Collections.sort(list, (a, b) -> b[1] - a[1]);
        Collections.sort(list, (a, b) ->{
            if(b[1] > a[1]) 
                return 1;
            else if(b[1] == a[1]) 
                return b[0] - a[0];
            else 
                return -1;
        });
        for(int[] i : list)
            System.out.println(i[0] + " " + i[1]);

测试结果：

总结

其实能用lambda表达式写的sort，都是相当于隐藏了Comparator 接口。比如场景3不使用lambda表达式的写法可以是这样写：

        // 先按第二列的数降序，再按第一列的数降序
        Collections.sort(list, new Comparator<int[]>(){
            @Override
            public int compare(int[]a, int[]b){
                if(b[1] > a[1])
                    return b[1] - a[1];
                else if(b[1] == a[1])
                    return b[0] - a[0];
                else
                    return -1;
            }
        });

也可以把比较器拆分开来写，分成两步骤。先定义一个比较器，然后在sort()方法中传入比较器。

 // 分解开的写法
        Comparator<int[]> listComparator =  new Comparator<int[]>(){
            @Override
            public int compare(int[]a, int[]b){
                if(b[1] > a[1])
                    return b[1] - a[1];
                else if(b[1] == a[1])
                    return b[0] - a[0];
                else
                    return -1;
            }
        };
        Collections.sort(list, listComparator);

除了排序场景中隐藏掉的Comparator 接口，还可以隐藏.Runnable 接口、Listener 接口、自定义接口等

注意事项：

如果是数组的话，用lambda表达式就不行了。如果数组只有一个数字，那么直接默认的排序方法就可以，如果实在要使用lambda表达式，可以转化为集合list或者stream来使用。

2.集合迭代 --测试输出代码很好用

普通输出1

   for(int i = 0 ; i < n ; i++)
            System.out.println(list.get(i));

普通输出2

        for(int i : list)
            System.out.println(i);

lambda表达式输出

list.forEach((s) -> System.out.println(s[0] + " " +s[1]));

非常简洁明了！！！！！

        List<int[]>list = new ArrayList<int[]>();
        list.add(new int[]{111, 234});
        list.add(new int[]{222, 345});
        list.add(new int[]{221, 345});
        list.add(new int[]{223, 345});
        list.forEach((s) -> System.out.println(s[0] + " " +s[1]));

还有一种写法，针对只有一个元素的集合输出非常友好。

list.forEach(System.out::println);

        List<Integer>list = Arrays.asList(1,2,3,4,5,6);
        list.forEach(System.out::println);

测试输出：

如果list存储的是两个元素的话，用：：这种输出输出的是地址，并不是值。

        List<int[]>list = new ArrayList<int[]>();
        list.add(new int[]{111, 234});
        list.add(new int[]{222, 345});
        list.add(new int[]{221, 345});
        list.add(new int[]{223, 345});
        // list.forEach((s) -> System.out.println(s[0] + " " +s[1]));
        
        // List<Integer>list = Arrays.asList(1,2,3,4,5,6);
        list.forEach(System.out::println);

测试输出：

如果是map的输出写法，也比较类似。


        Map<Character, Integer>map = new HashMap<Character, Integer>();
        for(int i = 0 ; i < 6 ; i++){
            map.put((char)(i + 'a'), 1);
        }
        map.forEach((k, v) -> System.out.println(k +" " + v));

在日常写代码的场景中，我lambda表达式使用比较多的是上面两个场景，还有方法的引用、变量的引用，这里不过多叙述。

附上完整的代码，可以测试一下上述，感觉还是挺有意思的！

import java.util.*;

public class Input1{
    public static void main(String[]args){
        // Scanner sc = new Scanner(System.in);
        // int n = sc.nextInt(); 
        

        List<int[]>list = new ArrayList<int[]>();
        list.add(new int[]{111, 234});
        list.add(new int[]{222, 345});
        list.add(new int[]{221, 345});
        list.add(new int[]{223, 345});
        list.forEach((s) -> System.out.println(s[0] + " " +s[1]));
        
        // List<Integer>list = Arrays.asList(1,2,3,4,5,6);
        // list.forEach(System.out::println);
        // map.forEach((k, v) -> System.out.println(k +" " + v));
        // Collections.sort(list, (a, b) -> b[1] - a[1]);
        // Collections.sort(list, (a, b) ->{
        //     if(b[1] > a[1]) 
        //         return 1;
        //     else if(b[1] == a[1]) 
        //         return b[0] - a[0];
        //     else 
        //         return -1;
        // });

        // for(int[] i : list)
        //     System.out.println(i[0] + " " + i[1]);


        // // 先按第二列的数降序，再按第一列的数降序
        // Collections.sort(list, new Comparator<int[]>(){
        //     @Override
        //     public int compare(int[]a, int[]b){
        //         if(b[1] > a[1])
        //             return b[1] - a[1];
        //         else if(b[1] == a[1])
        //             return b[0] - a[0];
        //         else
        //             return -1;
        //     }
        // });

        // // 分解开的写法
        // Comparator<int[]> listComparator =  new Comparator<int[]>(){
        //     @Override
        //     public int compare(int[]a, int[]b){
        //         if(b[1] > a[1])
        //             return b[1] - a[1];
        //         else if(b[1] == a[1])
        //             return b[0] - a[0];
        //         else
        //             return -1;
        //     }
        // };
        // Collections.sort(list, listComparator);

        // list.forEach((s) -> System.out.println(s[0] +">>" + s[1]));
        
        // List<String> strings = Arrays.asList("1", "2", "3");
        // strings.forEach(System.out::println);

      

        Map<Character, Integer>map = new HashMap<Character, Integer>();
        for(int i = 0 ; i < 6 ; i++){
            map.put((char)(i + 'a'), 1);
        }
        map.forEach((k, v) -> System.out.println(k +" " + v));


        // // int[]nums = new int[]{1,3,4,2,5,6};
        // // // Arrays.stream(nums).forEach((s) -> System.out.println(s));
        // // Arrays.asList(nums).forEach(System.out::println);
        // // nums.forEach((s) -> System.out.println(s)); // 数组不能直接使用forEach
        
       

        // int[]nums =  new int[]{1,3,5,2,4,6,7,9,8};
        // Arrays.sort(nums);
        // Arrays.sort(nums, (int a, int b) -> b - a);
        // for(int num : nums)
        //     System.out.println(num);
    }

}