【Java8新特性 之Lambda】对接口的简单实现

一、Lambda简介

1.什么是Lambda？

Lambda是java8添加的一个新特性，说白了，Lambda就是一个匿名函数

2.为什么要使用Lambda？

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

问题来了：对接口的实现，我们可以写一个实现类或者匿名内部类来实现接口，为什么要用Lambda呢？下面我们来做个对比
补充：匿名内部类

public class program {
    public static void main(String[] args) {
        //方式1：接口实现类
        Comparator c = new MyComparator();
        //方式2：匿名内部类
        Comparator c1 = new Comparator() {
            @Override
            public int compare(int a, int b) {
                return a-b;
            }
        };
        //方式3：Lambda实现接口
        Comparator c2 = ((a, b) -> a-b);
    }
}

//第一种方式，接口实现类
class  MyComparator implements Comparator{
    @Override
    public int compare(int a, int b) {
        return a-b;
    }
}
//这个接口对两个int值数据进行对比
interface Comparator{
    int compare(int a,int b);
}

3.Lambda对接口的要求

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

Java8对接口加了一个新特性：default

我们可以使用default对接口中的方法进行修饰，那么被default修饰的方法可以在接口中有一个默认实现的，你的实现类可以去实现它，也可以不去实现它，这个对我们的Lambda是没有影响的

4.@FunctionalInterface
修饰函数式接口的。函数式接口：接口中的抽象方法只有一个

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

二、Lambda基本语法

Lambda 表达式基础语法 ：参数列表+方法体
（）：参数列表
{}：用来描述方法体 ->:Lambda运算符 读作：goes to

我们在讲Lambda语法之前，我们先自定义多个不同类型的接口，分别用Lambda来实现，分析不同的情况，结合这些接口来看看Lambda的语法

定义接口：

//1、无参无返回
public interface LambdaNoneReturnNoneParameter {
    void test();
}

//2.无返回值 单个参数
public interface LambdaNoneReturnSingleParameter {
    void test(int n);
}

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

//4.有返回值，没有参数
public interface LambdaSingleReturnNoneParameter {
    int test();
}

// 5.有返回值 单个参数
public interface LambdaSingleReturnSingleParameter {
    int test(int a);
}
//6.有返回值， 多参数
public interface LambdaSingleReturnMutipleParameter {
    int test(int a,int b);
}

Lambda来实现上述接口：

/**
 * 1.Lambda 表达式基础语法
 * 参数列表+方法体
 （）：参数列表    {}：用来描述方法体   ->:Lambda运算符 读作：goes to
 */
public class Syntax1 {
    public static void main(String[] args) {
        //1.无返回 无参
        LambdaNoneReturnNoneParameter lambda1 = ()->{
            System.out.println("hello");
        };
        lambda1.test();//hello

        //2.无返回， 单个参数
        LambdaNoneReturnSingleParameter lambd2 = (int a)->{
            System.out.println(a);
        };
        lambd2.test(10);//10

        //3.无返回值多个参数
        LambdaNoneReturnMutipleParameter lambd3 = (int a,int b)->{
            System.out.println(a+" "+b);
        };
        lambd3.test(10,20);// 10 20

        //4.有返回 无参
        LambdaSingleReturnNoneParameter lambd4 = ()->{
            System.out.println("hello");
            return 100;
        };
        int re = lambd4.test();
        System.out.println(re);//100

        //5.有返回 单一参数
        LambdaSingleReturnSingleParameter lambd5 = (int a)->{
            return a*2;
        };
        int re1 = lambd5.test(10);
        System.out.println(re1);//20

        //6.有返回值 多个参数
        LambdaSingleReturnMutipleParameter lambd6 = (int a,int b)->{
            return a+b;
        };
        int re2 = lambd6.test(1,2);
        System.out.println(re2);
    }
}

三、Lambda基本语法精简

        //4.有返回 无参
        LambdaSingleReturnNoneParameter lambd4 = ()->{
            System.out.println("hello");
            return 100;
        };
        int re = lambd4.test();
        System.out.println(re);//100
        //5.有返回 单一参数
        LambdaSingleReturnSingleParameter lambd5 = (int a)->{
            return a*2;
        };
        int re1 = lambd5.test(10);
        System.out.println(re1);//20

        //6.有返回值 多个参数
        LambdaSingleReturnMutipleParameter lambd6 = (int a,int b)->{
            return a+b;
        };
        int re2 = lambd6.test(1,2);
        System.out.println(re2);

我们分析下上面这部分，我们看到每个方法的实现部分都有：return返回值；为什么呢？因为我们在定义接口的时候定义了抽象方法，返回值类型不是void，那么方法在结束的就必须返回结果。
我们单纯的看上面的Lambda表达式，它没有在任何地方定义返回值类型，之所以方法的实现部分需要返回值类型，因为我们接口中抽象方法定义的，抽象方法不仅定义了返回值类型，还定义了参数列表，所以我们就可以对其精简：

import tulun.Lambda.LambdaNoneReturnSingleParameter;
import tulun.Lambda.LambdaSingleReturnMutipleParameter;
import tulun.Lambda.LambdaSingleReturnNoneParameter;

public class Syntax2 {
    public static void main(String[] args) {
          //语法精简
          //1.参数
          //由于接口的抽象方法定义了参数的类型和数量，所以在Lambda表达式中，参数类型可以省略
          //备注：如果需要省略参数类型，要么都省略，要么都别省略

        //6.有返回值 多个参数
        LambdaSingleReturnMutipleParameter lambd6 = (a,b)->{
            return a+b;
        };
        int re2 = lambd6.test(1,2);
        System.out.println(re2);

        //2.参数小括号
        //如果参数列表只有一个参数，则小括号可以省略
        
        LambdaNoneReturnSingleParameter lambd2 =  a->{
            System.out.println(a);
        };
        lambd2.test(10);//10
        
        //3.方法大括号
        //如果说方法体中只有一条语句，则大括号可以省略
        LambdaNoneReturnSingleParameter lambd3 =  a-> System.out.println(a);
        lambd2.test(10);//10
        
        //4.如果说方法体中唯一的一条语句是返回语句,则大括号可以省略，同时要省略return
        LambdaSingleReturnNoneParameter lambd4 = ()-> 10;
        
        
        LambdaSingleReturnMutipleParameter lambd5 = (a,b)->a+b;
    }
}

四、Lambda进阶

1.方法引用
可以快速的将一个Lambda表达式的实现指向一个已经实现的方法
语法： 方法的隶属者：方法名

package tulun.Lambda.Syntax;

import tulun.Lambda.LambdaSingleReturnSingleParameter;

public class Syntax3 {
    public static void main(String[] args) {
        //方法引用：
        //可以快速的将一个Lambda表达式的实现指向一个已经实现的方法
        //语法：  方法的隶属者：方法名
        //注意：参数数量和类型一定要和接口中定义的方法一致  返回值类型也要和接口中定义的方法一致
        
        //LambdaSingleReturnSingleParameter lambd1 = a -> a+=2;
       // LambdaSingleReturnSingleParameter lambd2 = a -> a+=2;
        
        LambdaSingleReturnSingleParameter lambda1 = a->change(a);
        //方法引用
        LambdaSingleReturnSingleParameter lambda2 = Syntax3::change;
        
    }
    public static int change(int a){
        return a*=2;
    }
}

2.构造方法的引用

先创建一个People类

public class Person {
    String name;
    int age;
    //无参构造
    public Person() {
        System.out.println("无参构造");
    }
    //有参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造");
    }
}

构造方法的引用表示：

public class Syntax4 {
    public static void main(String[] args) {

        PersonCreater creater = ()-> new Person();

        //构造方法的引用
        PersonCreater creater1 = Person::new;

        //测试
        Person a = creater1.getPerson();//无参构造

        PersonCreater2 creater2 = Person::new;
        Person b = creater2.getPerson2("x",1);//有参构造
    }
}
//需求：
interface PersonCreater{
    Person getPerson();
}
interface  PersonCreater2{
    Person getPerson2(String name,int age);
}

五、Lambda表达式综合练习

1、ArrayList排序

/**
 * 集合排序
 * 题目：已知一个Arraylist中存有若干个Person对象，按照年龄降序
 */
public class exercise1 {
    public static void main(String[] args) {
        ArrayList<People> list = new ArrayList<>();
        list.add(new People("小明",10));
        list.add(new People("小磊",14));
        list.add(new People("小花",3));
        list.add(new People("小美",1));
        //排序
        list.sort((o1, o2) -> o2.age-o1.age);
        System.out.println(list);
    }
}
//定以People类
class People{
    String name;
    int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

分析上述这条代码：

 list.sort((o1, o2) -> o2.age-o1.age);

上面这行代码，查看源码知道sort的参数是一个Comparator类型的对象：

 public void sort(Comparator<? super E> c) {

Comparator是一个接口，其中只有一个方法需要被实现，就是compare方法：所以实际上我们是写了一个内部类

 int compare(T o1, T o2);

那么如果是没有lambda之前是什么样呢，我们看一下:

 //Lambda
        list.sort((o1, o2) -> o2.age-o1.age);
        //内部类
        list.sort(new Comparator<People>() {
            @Override
            public int compare(People o1, People o2) {
                return o2.age-o1.age;
            }
        });

可以看出lambda的强大了吧！
2、TreeSet排序

public class exercise2 {
    public static void main(String[] args) {
        /**
         * 使用Lambda表达式来实现Comparator接口，并实例化一个TreeSet对象················
         */
        TreeSet<Person> list = new TreeSet<>((o1, o2) -> o2.age-o1.age);
        list.add(new Person("小明",10));
        list.add(new Person("小磊",14));
        list.add(new Person("小花",3));
        list.add(new Person("小美",1));
        System.out.println(list);
    }
}

3、集合遍历 forEach

public class exercise3 {
    public static void main(String[] args) {
        //集合遍历
        ArrayList<Integer> list =  new ArrayList<>();

        Collections.addAll(list,1,2,3,4,5,6);
        //将集合中的每一个元素都加入到该方法accept中

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

        //输出集合中所有的偶数
        list.forEach(ele->{
            if (ele %2 ==0){
                System.out.println(ele);
            }
        });
    }
}

4、删除集合中满足条件的元素 removeIf

public class exercise4 {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("小明",10));
        list.add(new Person("小磊",14));
        list.add(new Person("小花",3));
        list.add(new Person("小美",1));

        //删除集合age>10的

        //将集合中的每一个元素都带入test方法中，如果满足返回值true，则删除元素
        list.removeIf(ele->ele.age>10);
        System.out.println(list);
    }
}

5、开辟线程

public class exercise5 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0;i<10;i++){
                System.out.println(i);
            }
        });
        t.start();
    }
}

六、系统内置函数式接口

import java.util.function.*;
public class FunctionalInterface {
    public static void main(String[] args) {
        //系统内置函数式接口
        
       //Predicate<T>  参数T 返回值boolean
              // IntPredicate   int   boolean
              //LongPredicate  long  boolean
               // DoublePredicate  double  boolean
        //Consumer<T>  参数T   返回值void
       //Function<T,R> 参数T 返回值R
        //Supplier<T>   参数 无  返回值 T
        //UnaryOperator 参数T 返回值T
        //BinaryOperator<T, U, R>  参数T T  返回值T
        // BiFunction<T, U, R>   参数 T U  返回值 R
        //BiPredicate<T ,U>  参数T ,U   返回值boolean
        //BiConsumer<T U> 参数T，U 返回值void
    }
}

七、Lambda表达式闭包问题

什么是闭包？

举例1：
（JDK 1.8）

public class Closuredemo {
    public static void main(String[] args) {
        int n = getnum().get();
        System.out.println(n);//10
    }
    private static Supplier<Integer> getnum(){
         int num = 10;
         return()-> num;
    };
}

我们知道Lambda表达式： return()-> num; 可以看做一个匿名方法，我们在这个方法中引用到了getnum()里面的一个局部变量，那么这个就是一个闭包，我们用Lambda表达式这个匿名方法把这个局部变量包围起来了

我们运行程序输出10，看起来没有错，理所应当；但是我们知道方法里面的局部变量在方法执行结束，它的生命周期也会结束，被销毁，可为什么我们的getnum（）方法执行结束了，但是num还在呢，不在的话，我们肯定接收不到返回值，输出没结果

由此我们得到一个结论：闭包可以提升局部变量的生命周期，在方法运行结束时，该变量不会被销毁

注意：

public class Closuredemo {
    public static void main(String[] args) {
      int a = 10;

        Consumer<Integer> c = ele->{
            //System.out.println(a);
            System.out.println(a++);
        };
        c.accept(a);
    }
}

运行上述代码 会出现如下错误：

java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量

结论：闭包中引用的局部变量一定是常量，默认的被final修饰