Lambda表达式（一）

Lambda表达式其实就是实现SAM接口的语法糖，作用就是简化代码的冗余，同时可读性也好过匿名内部类。

以下先一步步演示是如何把大段的代码变成一句代码的，加强理解！

第一种正常的写法

 1 public class Test {
 2
 3     public static void main(String[] args) {
 4
 5         //非Lambda表达式的方式创建一个线程
 6         MyRunnable myRunnable = new MyRunnable();
 7         Thread thread = new Thread(myRunnable);
 8         thread.start();
 9     }
10
11 }
12 class MyRunnable implements Runnable{
13
14     @Override
15     public void run() {
16         System.out.println("Hello Run");
17     }
18 }

结果：Hello Run

第二种匿名内部类

public class Test {

    public static void main(String[] args) {
        //匿名内部类，带对象名字
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello Run");
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

结果：Hello Run

第三种匿名内部类

public class Test {

    public static void main(String[] args) {
        //匿名内部类，不带对象名
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello Run");
            }
        });
        thread.start();
    }
}

结果：Hello Run

第四种匿名内部类

public class Test {

    public static void main(String[] args) {
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello Run");
            }
        }).start();
    }
}

结果：Hello Run

第五种Lambda表达式

public class Test {

    public static void main(String[] args) {
        //使用Lambda表达式
        new Thread(() -> System.out.println("Hello Run")).start();
    }
}

结果：Hello Run

以上的演变估计你已经大概知道这个是怎么演变过来的，那为什么这个Runnable可以这样只写呢？

原因就是Runnable符合接口SAM特征;   另外科普一下SAM：Single Abstract Method(一个抽象方法)

下面再来一个例子

import java.util.Arrays;

public class Test2 {

    public static void main(String[] args) {
        //什么都不管，先来几辆车（代码中满足自己一下）
        Car[] carArry = new Car[5];
        carArry[0] = new Car(1, "BMW");
        carArry[1] = new Car(2, "Mercedes-benz");
        carArry[2] = new Car(3, "Audi");
        carArry[3] = new Car(4, "Porsche");
        carArry[4] = new Car(5, "Ferrari");
        //这里就把我的豪车进行排序，按照id排序
        Arrays.sort(carArry);
        for (Car car : carArry) {
            System.out.println(car);
        }
    }

}

class Car implements Comparable<Car> {
    private int id;
    private String brand;

    public Car(int id, String brand) {
        this.id = id;
        this.brand = brand;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", brand='" + brand + '\'' +
                '}';
    }

    @Override
    public int compareTo(Car car) {
        return this.id - car.id;
    }
}

输出的结果：

Car{id=1, brand='BMW'}
Car{id=2, brand='Mercedes-benz'}
Car{id=3, brand='Audi'}
Car{id=4, brand='Porsche'}
Car{id=5, brand='Ferrari'}

这时候，为了秀一下我的车，我又想要按照品牌排序，这时候就要在实现一个类是按照品牌来排序的

import java.util.Arrays;
import java.util.Comparator;

public class Test2 {

    public static void main(String[] args) {
        //什么都不管，先来几辆车（代码中满足自己一下）
        Car[] carArry = new Car[5];
        carArry[0] = new Car(1, "BMW");
        carArry[1] = new Car(2, "Mercedes-benz");
        carArry[2] = new Car(3, "Audi");
        carArry[3] = new Car(4, "Porsche");
        carArry[4] = new Car(5, "Ferrari");
        //这里就把我的豪车进行排序，按照id排序
        Arrays.sort(carArry, new carByBrandComparator());
        for (Car car : carArry) {
            System.out.println(car);
        }
    }

}

/**
 * 按汽车的品牌排序
 **/
class carByBrandComparator implements Comparator<Car> {

    @Override
    public int compare(Car brand1, Car brand2) {
        return brand1.getBrand().compareTo(brand2.getBrand());
    }
}

class Car implements Comparable<Car> {
    private int id;
    private String brand;

    public Car(int id, String brand) {
        this.id = id;
        this.brand = brand;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", brand='" + brand + '\'' +
                '}';
    }

    @Override
    public int compareTo(Car car) {
        return this.id - car.id;
    }
}

结果：

Car{id=3, brand='Audi'}
Car{id=1, brand='BMW'}
Car{id=5, brand='Ferrari'}
Car{id=2, brand='Mercedes-benz'}
Car{id=4, brand='Porsche'}

这时候排序就是按照品牌来排序了，可是这样就又多了一个类，是不是觉得很不爽，这就对了，因为还可以再简单一点，下面一起来看看：

我们采用匿名类来解决

import java.util.Arrays;
import java.util.Comparator;

public class Test2 {

    public static void main(String[] args) {
        //什么都不管，先来几辆车（代码中满足自己一下）
        Car[] carArry = new Car[5];
        carArry[0] = new Car(1, "BMW");
        carArry[1] = new Car(2, "Mercedes-benz");
        carArry[2] = new Car(3, "Audi");
        carArry[3] = new Car(4, "Porsche");
        carArry[4] = new Car(5, "Ferrari");
        //这里就把我的豪车进行排序，按照id排序
        Arrays.sort(carArry, new Comparator<Car>() {
            @Override
            public int compare(Car brand1, Car brand2) {
                return brand1.getBrand().compareTo(brand2.getBrand());
            }
        });
        for (Car car : carArry) {
            System.out.println(car);
        }
    }

}

class Car implements Comparable<Car> {
    private int id;
    private String brand;

    public Car(int id, String brand) {
        this.id = id;
        this.brand = brand;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", brand='" + brand + '\'' +
                '}';
    }

    @Override
    public int compareTo(Car car) {
        return this.id - car.id;
    }

结果：

Car{id=3, brand='Audi'}
Car{id=1, brand='BMW'}
Car{id=5, brand='Ferrari'}
Car{id=2, brand='Mercedes-benz'}
Car{id=4, brand='Porsche'}

甚至我们还可以更简单：

import java.util.Arrays;
import java.util.Comparator;

public class Test2 {

    public static void main(String[] args) {
        //什么都不管，先来几辆车（代码中满足自己一下）
        Car[] carArry = new Car[5];
        carArry[0] = new Car(1, "BMW");
        carArry[1] = new Car(2, "Mercedes-benz");
        carArry[2] = new Car(3, "Audi");
        carArry[3] = new Car(4, "Porsche");
        carArry[4] = new Car(5, "Ferrari");
        //这里就把我的豪车进行排序，按照id排序
        Arrays.sort(carArry, (brand1, brand2) -> brand1.getBrand().compareTo(brand2.getBrand()));
        for (Car car : carArry) {
            System.out.println(car);
        }
    }

}

class Car implements Comparable<Car> {
    private int id;
    private String brand;

    public Car(int id, String brand) {
        this.id = id;
        this.brand = brand;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", brand='" + brand + '\'' +
                '}';
    }

    @Override
    public int compareTo(Car car) {
        return this.id - car.id;
    }
}

结果：

Car{id=3, brand='Audi'}
Car{id=1, brand='BMW'}
Car{id=5, brand='Ferrari'}
Car{id=2, brand='Mercedes-benz'}
Car{id=4, brand='Porsche'}

之所以可以这样写，也是因为Comparator符合SAM接口的特征；

到这里，是不是已经感受到Lambda的魅力！！！

这些函数式接口集中在java.util.function包中

可以分为四大类：

1、消费型接口：有参无返回值

2、供给型接口：无参有返回值

3、判断型接口：有参有返回值，但返回类型是boolean

4、功能型接口：有参有返回值

一、消费型接口
        经典代表：
            Consumer<T>   抽象方法  void accept(T t)

        延伸代表：
            （1）
                BiConsumer<T,U>    void accept(T t, U u)     接收两个对象用于完成功能
            （2）
                DoubleConsumer    　　void accept(double value)         接收一个double值
                IntConsumer        　void accept(int value)          接收一个int值
                LongConsumer    　　　void accept(long value)          接收一个long值
            （3）
                ObjDoubleConsumer<T>    void accept(T t, double value)      接收一个对象和一个double值
                ObjIntConsumer<T>        void accept(T t, int value)         接收一个对象和一个int值
                ObjLongConsumer<T>        void accept(T t, long value)         接收一个对象和一个long值

    总结：
        （1）消费型接口，都以“Consumer”单词为结尾
        （2）Bi开头，传两个参数   Binary（二元的）
        （3）xxConsumer，前面的xx代表形参类型

二、供给型接口
        经典代表：
            Supplier<T>   抽象方法    T get()

        延伸代表：
            （1）BooleanSupplier    boolean getAsBoolean()      返回一个boolean值
            （2）DoubleSupplier        double getAsDouble()          返回一个double值
            （3）IntSupplier        int getAsInt()              返回一个int值
            （4）LongSupplier        long getAsLong()              返回一个long值

    总结：
        （1）供给型接口以“Supplier”单词结尾
        （2）xxSupplier说明返回xx类型的结果
        （3）供给型接口的抽象方法都是无参的

三、判断型接口
        经典代表：
            Predicate<T>  抽象方法    boolean test(T t)

        延伸代表：
            （1）BiPredicate<T,U>        boolean test(T t, U u)          接收两个对象
            （2）DoublePredicate        boolean test(double value)      接收一个double值
            （3）IntPredicate            boolean test(int value)          接收一个int值
            （4）LongPredicate            boolean test(long value)         接收一个long值

    总结：
        （1）判断型接口以“Predicate”结尾
        （2）判断型接口抽象方法的返回值类型是固定的，是boolean
        （3）xxPredicate，说明形参是xx类型的

四、功能型接口
        经典代表：
            Function<T,R>   抽象方法    R apply(T t)

        延伸代表：
            （1）
                UnaryOperator<T>    T apply(T t)    接收一个T类型对象，返回一个T类型对象结果
            （2）
                DoubleFunction<R>    R apply(double value)      接收一个double值，返回一个R类型对象
                IntFunction<R>        R apply(int value)        接收一个int值，返回一个R类型对象
                LongFunction<R>        R apply(long value)        接收一个long值，返回一个R类型对象
            （3）
                ToDoubleFunction<T>    double applyAsDouble(T value)     接收一个T类型对象，返回一个double
                ToIntFunction<T>    int applyAsInt(T value)          接收一个T类型对象，返回一个int
                ToLongFunction<T>    long applyAsLong(T value)         接收一个T类型对象，返回一个long
            （4）
                DoubleToIntFunction        int applyAsInt(double value)          接收一个double值，返回一个int结果
                DoubleToLongFunction    long applyAsLong(double value)         接收一个double值，返回一个long结果
                IntToDoubleFunction        double applyAsDouble(int value)     接收一个int值，返回一个double结果
                IntToLongFunction        long applyAsLong(int value)          接收一个int值，返回一个long结果
                LongToDoubleFunction    double applyAsDouble(long value)      接收一个long值，返回一个double结果
                LongToIntFunction        int applyAsInt(long value)             接收一个long值，返回一个int结果
            （5）
                DoubleUnaryOperator    double applyAsDouble(double operand)      接收一个double值，返回一个double
                IntUnaryOperator    int applyAsInt(int operand)              接收一个int值，返回一个int结果
                LongUnaryOperator    long applyAsLong(long operand)          接收一个long值，返回一个long结果

            （6）
                BiFunction<T,U,R>    R apply(T t, U u)     接收一个T类型和一个U类型对象，返回一个R类型对象结果
            （7）
                BinaryOperator<T>    T apply(T t, T u)     接收两个T类型对象，返回一个T类型对象结果
            （8）
                ToDoubleBiFunction<T,U>  double applyAsDouble(T t, U u)     接收一个T类型和一个U类型对象，返回一个double
                ToIntBiFunction<T,U>     int applyAsInt(T t, U u)     接收一个T类型和一个U类型对象，返回一个int
                ToLongBiFunction<T,U>    long applyAsLong(T t, U u)     接收一个T类型和一个U类型对象，返回一个long

                （9）    DoubleBinaryOperator    double applyAsDouble(double left, double right)      接收两个double值，返回一个double结果
                IntBinaryOperator    int applyAsInt(int left, int right)     接收两个int值，返回一个int结果
                LongBinaryOperator    long applyAsLong(long left, long right)      接收两个long值，返回一个long结果

    总结：
        （1）以Unary开头的，表示一元的，泛型的类型只有一个，形参和返回值都是同一种类型
        （2）xxFunction，说明形参的类型是xx类型的
        （3）toXXFunction，说明返回值类型是xx类型
        （4）xxToyyFunction，说明形参的类型是xx类型的,返回值类型是yy类型
        （5）xxUnary开头的，表示一元，形参类型和返回值类型都是xx
        （6）Bi开头，表示二元，形参类型是2个
        （7）BinaryOperator，既是Bi开头表示两个形参，又是Operator结尾，表示形参和返回值类型是一样
        （8）toXXBi开头的，表返回值类型是xx，并且形参是两个
        （9）xxBinaryOperator，表示两个形参，又是Operator结尾，表示形参和返回值类型是一样