JAVA之Lambda表达式详解

目录

目录

 一、基本语法:

1、函数式接口

二、Lambda表达式的基本使用

1.无返回值函数式接口

2.有返回值函数接口 

 3.语法精简

三、变量捕获

1.匿名内部类

 2.Lambda的变量捕获

四、Lambda在集合当中的使用

1.List和forEach、sort 

 2.HashMap和forEach

总结

---

 

 一、基本语法:

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

1、函数式接口

 函数式接口定义： 一个接口有且只有一个抽象方法

注意：

        1.如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口

        2.如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数                    式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所                          以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个                      注解。加上就会自动进行检测的。

 

二、Lambda表达式的基本使用

1.无返回值函数式接口

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值两个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn n = ()->{
            System.out.println("无参数无返回值");
        };
        n.test();

        OneParameterNoReturn o = (a)-> {
            System.out.println("无返回值一个参数"+a);
        };
        o.test(666);
        MoreParameterNoReturn m = (int a,int b)->{
            System.out.println("无返回值两个参数"+a+" "+b);
        };
        m.test(666,999);
    }
}

运行结果：

2.有返回值函数接口 

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多个参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
public class TestDemo {
    public static void main(String[] args) {
        NoParameterReturn n = ()->{
            return 666;
        };
        int ret1 = n.test();
        System.out.println(ret1);
        System.out.println("================");
        OneParameterReturn o = (int a)->{
            return a;
        };
        int ret2 = o.test(999);
        System.out.println(ret2);
        System.out.println("================");
        MoreParameterReturn m = (int a,int b)-> {
            return a+b;
        };
        int ret3 = m.test(10,90);
        System.out.println(ret3);
    }
}

运行结果：

 3.语法精简

Lambda表达式的语法还可以精简，显得非常有逼格，但是可读性就非常差。

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略
3. 如果方法体当中只有一句代码，那么大括号可以省略
4. 如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且去掉return关键字
   把上面的代码精简示例：

	public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = (a, b)->{
            System.out.println("无返回值多个参数，省略参数类型："+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        OneParameterNoReturn oneParameterNoReturn = a ->{
            System.out.println("无参数一个返回值,小括号可以省略："+ a);
        };
        oneParameterNoReturn.test(10);
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有 一行代码");
        noParameterNoReturn.test();
        //方法体中只有一条语句，且是return语句
        NoParameterReturn noParameterReturn = ()-> 40;
        int ret = noParameterReturn.test();
        System.out.println(ret);
    }

三、变量捕获

1.匿名内部类

匿名内部类中：一定是程序在运行的过程当中没有发生改变的变量

如果把捕获的变量 a在匿名内部类中修改，就会报错。

 2.Lambda的变量捕获

Lambda的变量捕获，同样也是不能捕获放生改变的，如果发生改变就会报错。

@FunctionalInterface
interface NoParameterNoReturn {
	void test();
} 
public static void main(String[] args) {
	int a = 10;
	NoParameterNoReturn noParameterNoReturn = ()->{
	// a = 99; error
	System.out.println("捕获变量："+a);
	};
	noParameterNoReturn.test();
}

四、Lambda在集合当中的使用

1.List和forEach、sort 

 

import java.util.*;
import java.util.function.Consumer;

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

运行结果：

 2.HashMap和forEach

import java.util.function.Consumer;
public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach(new BiConsumer<Integer, String>(){
            @Override
            public void accept(Integer k, String v){
                System.out.println(k + "=" + v);
            }
        });
    }

运行结果

 改为Lambda后

public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach((k,v)-> System.out.println("key = "+k+" vak = "+v));
    }

 运行结果

 

总结

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读
优点：

1. 代码简洁，开发迅速
2. 方便函数式编程
3. 非常容易进行并行计算
4. Java 引入 Lambda，改善了集合操作
   缺点：
5. 代码可读性变差
6. 在非并行计算中，很多计算未必有传统的 for 性能要高
7. 不容易进行调试