JAVA8新特性之Lambda表达式

Lambda简介

什么是Lambda?
Lambda是JAVA 8 添加的新的特性，其实，Lambda就是一个匿名函数

为什么要使用Lambda?

​ 使用Lambda表达式可以对一个接口进行非常简洁的实现

public class Program{
    public static void main(String[] args){
		//方式1.使用接口实现类实现
        Comparator comparator = new MyComparator();
        //方式2.使用匿名内部类实现
        Comparator comparator1 = new Comparator(){
          	@Override
            public int compare(int a,int b){
                return a-b;
            }
        };
        //方式3.使用Lambda表达式来实现接口
        Comparator comparator2 = (a,b) -> a-b;
    }
}

class Mycomparator implements Comparator{
    @Override
    public int compare(int a,int b){
		  return a-b;
     }
}

interface Comparator{
    int compare(int a,int b);
}

Lambda对接口的要求？

​ 虽然可以使用Lambda表达式对某些接口进行简单实现，但是并不是所有的接口都可以用Lambda表达式来实现，要求接口中定义的必须要实现的抽象方法只能是一个。

在JAVA8对接口加了一个新的特性：default. 被default修饰的方法，可以在接口中有一个默认实现，因此实现类可以去实现这个方法，也可以不去实现。这样的方法对Lambda的实现没有影响

@FunctionalInterface : 修饰函数式接口的，即接口中的抽象方法只有一个。

Lambda基础语法

/*
	6个接口
*/

//无参无返回
@FunctionalInterface
public interface LambdaNoneReturnNoneParameter{
    void test();
}
 
//无返回值，单个参数
@FunctionalInterface
public interface LambdaNoneReturnSingleParameter{
    void test(int n);
}

//无返回值，多个参数
@FunctionalInterface
public interface LambdaNoneReturnMutipleParameter{
    void test(int a,int b);
}

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

//有返回值，单个参数
 @FunctionalInterface
 public interface  LambdaSingleReturnSingleParameter{
     int test(int a);
 }

 //有返回值，多个参数
@FunctionalInterface
public interface LambdaSingleReturnMutipleParameter{
    int test(int a,int b);
}

/*
	使用lambda表达式实现接口
*/
public class Syntax1{
    public static void main(String[] args){
        /**
        	1.Lambda表达式的基础语法
        	Lambda是一个匿名函数
        	参数列表	方法体
        	
        	( ) ： 用来描述参数列表
        	{ } ： 用来描述方法体
        	-> : Lambda运算符，连接在()和{}之间，读作goes to
        **/
        
        //无参无返回
        LambdaNoneReturnNoneParameter lambda1 = () -> {
            System.out.println("实现无参数无返回接口");
        };
            lambda1.test();
        
        //无返回值，单个参数
        LambdaNoneReturnSingleParameter lambda2 = (int a) -> {
            System.out.println(a);
        };
        lambda2.test(10);
        
        //无返回值，多个参数
        LambdaNoneReturnMutipleParameter lanmbda3 = (int a,int b) -> {
          System.out.println(a-b);  
        };
        lambda3.test(10,20);
        
        //有返回值，无参数
        LambdaSingleReturnParameter lambda4 = () -> {
            System.out.println("lambda4");
            return 100;
        };
        int ret = lambda4.test();
        System.out.println(ret);
        
        //有返回值，单个参数
        LambdaSingleReturnSingleParameter lambda5 = (int a) ->{
            return a*2;
        };
        int ret2 = lambda5.test(10);
        System.out.println(ret2);
        
        //有返回值，多个参数
        LambdaSingleReturnMutipleParameter lambda6 = (int a，int b) -> {
            return a+b;
        };
        int ret3 = lambda6.test(20,30);
        System.out.println(ret3);
    }
}

Lambda精简语法

/*
	使用lambda精简语法实现接口
*/
public class Syntax2{
    public static void main(String[] args){
        //1. 参数类型:
		//由于在接口的抽象方法中，已经定义了参数的数量和类型，所以在lambda表达式中，参数的类型可以省略
        //备注：如果需要省略类型，则每一个参数的类型都要省略。不能出现省略一部分，不省略一部分
        LambdaNoneReturnMutipleParameter lambda1 = (a,b) ->{
            System.out.println("hello wordl");
        };
        //2.参数小括号
        //如果参数列表中，参数的数量只有一个，此时小括号可以省略
        LambdaNoneReturnSingleParameter lambda2 = a ->{
            System.out.println("hello world");
        };
        //3.方法大括号
        //如果方法体中只有一条语句，此时大括号可以省略
        LambdaNoneReturnSingleParameter lambda3 = a -> System.out.println("hello world");
        //4.如果方法体中唯一的一条语句是一个返回语句，则在省略大括号的同时，也必须省略return
        LambdaSingleReturnNoneParameter lambda4 = () -> 10;
        
        //**综合使用
        LambdaSingleReturnMutipleParameter lambda5 = (a,b) -> a+b;
        
    }
}

Lambda方法引用

public class Syntax3{
    public static void main(String[] args){
 		//方法引用
        //可以快速的将一个Lambda表达式的实现指向一个已经实现的方法。(当需要频繁调用这个接口时，就用到方法引用实现代码的复用)
        //语法：方法的隶属者 :: 方法名		
        		//隶属者：是根据方法来确定。如：静态方法可以用类直接调用即的静态方法隶属者是类。普通方法用							对象调用即普通方法的隶属者是类的对象。
        
        //注意：
        	//1.方法引用中参数数量和类型一定要和接口中定义的方法一致
        	//2.返回值类型一定要和接口中定义的方法一致
        
        LambdaSingleReturnSingleParameter lambda1 =a -> change(a);
        
        //方法引用：引用了change方法的实现
        LambdaSingleReturnSingleParameter lambda2 = Syntax3::change;
        
    }
    private static int change(int a ){
		return a*2;
    }
}

Lambda构造方法引用

public class Person{
    public String name;
    public int age;
    public Person(){
        System.out.println("Person类的无参构造方法执行了");
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("Person类的有参构造方法执行了");
}
    
}
public class Syntax4{
    public static void main(String[] args){
    	PersonCreater creater = () -> new Person();
        
        //构造方法的引用:	在接口的某个方法中，返回了类的对象，此时适合引用构造方法
        
        PersonCreater creater1 = Person:new;
        Person p = create1.getPerson();
        //输出结果：Person类的无参构造方法执行了
        
        PersonCreater creater2 = Person:new;
        Person p = create2.getPerson("zhangsan"，23);
        //输出结果：Person类的有参构造方法执行了
  	}
}
interface PersonCreate{
    Person getPerson();
}
interface PersonCreate2{
    Person getPerson(String name,int age);
}