Lambda表达式你学废了吗！

Posted 2021-06-28 Putarmor

新特性：Lambda表达式

• • Lambda
  • • 1.Lambda语法
    • 2.函数式接口
  • 一、Lambda基本使用
  • 二、变量捕获
  • 三、集合中使用Lambda
  • 四、Lambda表达式优缺点

Lambda

1.Lambda语法

Lambda表达式（Lambda expression）是jdk1.8出现的新特性，允许我们通过表达式来代替功能接口；它和正常方法一样，提供了一个正常的参数列表和一个使用这些参数的主体（表达式或者代码块）；同时可以看作是一个匿名函数，也可称为闭包（Closure）。

基本语法：（parameters）-> expression 或 （parameters）-> {statements;}

表达式构成：
①parameters：就像是方法中的参数列表，这里的参数是函数式接口里的参数，参数类型可以明确地声明也可以不明确地声明去由Jvm隐含判断；当只有一个推断类型时可以省略掉圆括号。
②->：理解为“被用于”的意思。
③expression：可以是表达式可以是代码块，是函数式接口里方法的实现；表达式或代码块可以返回一个值也可以什么都不返回，这里的代码块等同方法的方法体。

Lambda示例：

2.函数式接口

想要对Lambda有清楚的认识，首先就要知道“函数式”接口概念，函数式接口就是指一个接口interface有且只有一个抽象方法。

1.当一个接口只有一个抽象方法，该接口就是一个函数式接口
2.在某个接口上使用@FunctionalInterface注解，编译器就会按照函数式接口定义要求该接口，如果有两个抽象方法，程序编译就会报错。

函数式接口定义：

@FunctionalInterface
interface NoParameterNoReturn{
	//只能拥有一个方法
	void testDemo();
}

一、Lambda基本使用

@FunctionalInterface
interface NoParameterNoReturn {
    //注意：只能有一个方法
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}


public class TestDemo2 {

    public static void main(String[] args) {
    	//无返回值lambda表达式
        NoParameterNoReturn noParameterNoReturn = ()->{
            System.out.println("woaizhongguo!");
        };
        noParameterNoReturn.test();


        OneParameterNoReturn oneParameterNoReturn = (int a)->{
            System.out.println(a);
        };
        oneParameterNoReturn.test(10);

        MoreParameterNoReturn moreParameterNoReturn = (int a,int b) ->{
            System.out.println(a+b);
        };
        moreParameterNoReturn.test(10,20);

        //一个参数一个返回值的lambda表达式
        OneParameterReturn oneParameterReturn = (int a) -> a;
        System.out.println(oneParameterReturn.test(66));

        OneParameterReturn oneParameterReturn1 = a -> a;
        System.out.println(oneParameterReturn1.test(88));

        OneParameterReturn oneParameterReturn2 = a -> {
            return a;
        };
        System.out.println(oneParameterReturn2.test(99));

    }
}

使用lambda表达式后结果：

二、变量捕获

Lambda表达式中存在变量捕获，了解变量捕获后才能理解表达式的作用域；我们知道匿名类存在变量捕获，那么接下来我们分别来看匿名内部类的变量捕获与lambda表达式的变量捕获。

变量捕获演示：

class Test{
    public void func() {
        System.out.println("加油！");
    }
}
public class TestDemo3 {

    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                //a = 999;  
                System.out.println("奥力给！");
                System.out.println("捕获到的变量："+a+"这个变量是不能修改过的!");
            }
        }.func();
    }
}

匿名内部类中，捕获的要么是常量，要么是不能发生修改的变量。

Lambda表达式变量捕获：

public static void main(String[] args) {
        int a = 100;
        NoParameterReturn noParameterReturn = ()->{
            System.out.println(a);
            return 10;
        };
        System.out.println(noParameterReturn.test());
}

lambda变量捕获要求变量的值也是不能修改的。

三、集合中使用Lambda

为了让Lambda和Java的集合类更好地一起使用，集合当中增加了部分方法，以便于与Lambda表达对接。

对应接口	新增的方法
Collection	steam() forEach() removeIf()等
List	replaceAll() sort()
Map	getOrDefault() forEach() replace() compute() merge()

List接口演示：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("prepare");
        list.add("for");
        list.add("lambda");
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println();
        list.forEach((String s) -> {
            System.out.println(s);
        });
        System.out.println();
        list.forEach(s->System.out.println(s));
    }

从结果可以看出，我们在List接口中使用了lambda表达式去实现forEach打印了list中的元素。

Collection接口演示：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("prepare");
        list.add("for");
        list.add("lambda");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        //list.sort((String o1,String o2)->{return o1.compareTo(o2);});
        list.sort((o1, o2)->  o1.compareTo(o2) );
        list.forEach(s-> System.out.println(s));
    }

从结果看出，我们使用lambda表达式去实现sort方法，比较了元素之间的大小。

Map接口演示：

public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "prepare");
        map.put(3, "for");
        map.put(4, "lambda");

        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println(integer+" "+s);
            }
        });
//        map.forEach((k,v)->{
//            System.out.println(k+" "+v);
//        });
        System.out.println();
        map.forEach((k,v) -> System.out.println(k+" "+v));
    }

四、Lambda表达式优缺点

从代码层次上看，使代码变得非常简洁，但是代码难读。

优点：

代码简洁，便于开发；
方便函数式编程；
非常容易进行并行计算；
改善了集合操作。

缺点：

代码可读性较差；
不容易进行调试；
在非并行计算中，有些计算不一定有for高效。