Java8 函数式接口与 Lambda 及方法引用

太过爱你忘了你带给我的痛 2021-10-01 10:18 274阅读 0赞

## 函数式接口 ##

*  Lambda 表达式只能在函数式接口上操作，**函数式接口是具有单个抽象方法的接口**，也称为 SAM（Single Abstract Method）
 *  函数接口可以有任意的 default 或 static 方法

### 函数式接口例子 ###

*  最基本的函数式接口

public interface Foo1 {
        void bar();
    }

public interface Foo1 {
        int bar(boolean bz);
    }

public interface Foo1 {
        String bar(Object baz, int mink);
    }

*  default 方法不会被计算到函数式接口的单个抽象方法里

public interface Foo1 {
        default String bar() {          
            return "baz";
        }
        void quux();
    }

*  可以使用 @FunctionalInterface 注解，该注解可以让编译器帮我们审核该接口是否函数式接口

@FunctionalInterface
    public interface Foo1 {
        void bar();
    }

@FunctionalInterface
    interface BlankFoo1 extends Foo1 {       // 从Foo1继承抽象方法
    }

@FunctionalInterface
    interface Foo1 {
        void bar();
        boolean equals(Object obj);         // 重写 Object 的方法因此不计算
    }

*  下面不是一个函数式接口，因为它没有任何方法

@FunctionalInterface
    interface Foo1 {}

## Lambda 表达式 ##

*  任何函数的参数只要是一个函数式接口都能接收一个 Lambda
 *  案例准备：

public interface TestFunctionInterface1 {
        void print();
    }
    public interface TestFunctionInterface2 {
        void print(String name);
    }
    public interface TestFunctionInterface3 {
        void print(String name,int age);
    }
    
    // 与静态方法
    
    public static void print(TestFunctionInterface1 testFunctionInterface) {
            testFunctionInterface.print();
        }
    
    public static void print(TestFunctionInterface2 testFunctionInterface) {
            testFunctionInterface.print("linyuan");
        }
    
    public static void print(TestFunctionInterface3 testFunctionInterface) {
            testFunctionInterface.print("linyuan", 21);
        }

*  通过 Lambda（“闭包”或“匿名方法”）表达式

print(()->System.out.println("Hello"));
    
    // 等同于 
    
    print(new TestFunctionInterface(){
        @Override
        public void print(){
            System.out.println("Hello");
        }
    });

*  Lambda 表达式参数类型由编译推理得出，也可以显式的指定参数类型

Arrays.asList("a", "b", "c", "d").forEach((String e)  -> System.out.println(e));

*  Lambda 表达式是匿名函数，因为函数式接口有一个抽象方法，所以 Java 重写了它，若 Lambda 类型不能确定，需要加上强制类型转换

TestFunctionInterface1 t1 = (TestFunctionInterface1)()->System.out.println("hello");
    testFunctionInterface.print();

*  如果函数只有一个参数，可以省略圆括号，并且如果代码比较多，可以使用花括号括起来：

TestFunctionInterface2 t2 = name -> {System.out.println("my name is "+name);};
    TestFunctionInterface3 t3 = (name,age) -> {System.out.println("my name is "+name+" and age "+age);};

*  如果Lambda中的代码是一个表达式而不是一个声明，它就会被当作一个返回值

IntUnaryOperator addOne = x -> x + 1;

*  使用 Lambda 表达式去排序一个集合，在 Java8 之前，排序一个集合的时候，需要用匿名内部类去实现 java.util.Comparator 接口：

// 匿名内部类方式：
    List<String> list = Arrays.asList("a", "c", "b");
    list.stream().sorted(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });
    
    // Lambda 表达式方式：
    List<String> list = Arrays.asList("a", "c", "b");
    list.stream().sorted((p1,p2)->p1.compareTo(p2));

*  **Lambda 表达式（匿名类） 在访问外部局部变量时，其实是拷贝了一份外部局部变量的副本，修改副本的值是不会影响到外部局部变量的值的（因为Java只有值拷贝，没有引用拷贝，而外部局部变量的引用与Lambda表达式内部变量的引用并非同一个），因此若欲想在 Lambda 表达式中修改外部局部变量的值，则会提醒需要将外部局部变量显式的声明为 final，以免开发者会误以为能够在 Lambda 表达式中修改外部局部变量的值**

int number = 0;
    IntStream.range(1, 3).forEach(i -> {
        // 若无修改外部局部变量的值的操作，则无需声明为 final
        System.out.println(number);
    });

int number = 0; 
    IntStream.range(1, 3).forEach(i -> {
        // 此处报错，Lambda 表达式中不能修改外部局部变量的值
        // 因为 Lambda 表达式中的变量是外部局部变量的副本拷贝，修改副本的值不会影响原变量的值
        // 需显示的声明 number 为 final
        number = number + 1;       
    });

## 方法引用 ##

*  方法引用是用来直接访问类或者实例已存在的方法或构造方法，可以理解为 Lambda 简化写法，使用 :: 来引用

@FunctionalInterface
    public interface Supplier<T> {
        T get();
    }
     
    class Car {
        //Supplier是jdk1.8的接口，这里和lamda一起使用了
        public static Car create(final Supplier<Car> supplier) {
            return supplier.get();
        }
     
        public static void collide(final Car car) {
            System.out.println("Collided " + car.toString());
        }
     
        public void follow(final Car another) {
            System.out.println("Following the " + another.toString());
        }
     
        public void repair() {
            System.out.println("Repaired " + this.toString());
        }
    }

*  构造器引用

Car car = Car.create( Car::new );
    List< Car > cars = Arrays.asList( car );

*  静态方法引用

cars.forEach( Car::collide );

*  特定类任意对象方法引用

cars.forEach( Car::repair );

*  特定对象的方法引用

Car police = Car.create( Car::new );
    cars.forEach( police::follow );