函数式接口，lambda表达式，方法引用

你的名字 2023-03-14 08:28 14阅读 0赞

### 文章目录 ###

*   *  函数式接口
     *   *  常见函数式接口对比
         *  Function
         *   *  方法说明
             *  使用示例
         *  Consumer
         *   *  方法说明
             *  使用示例
         *  Supplier
         *   *  方法说明
             *  使用示例
         *  Predicate
         *   *  方法说明
             *  使用示例
     *  lambda
     *   *   *  常见的lambda表达式
     *  方法引用
     *   *  使用示例

函数式接口是指只拥有一个抽象函数。带有@FunctionalInterface标注的接口，编译时就需要完全符合函数式接口的定义。与函数式接口密切相连的便是lambda表达式。

## 函数式接口 ##

1.只拥有一个抽象方法。  
2.接口可以含有default-method。即使用default修饰的方法，该方法是具有方法体的。  
3.接口还可以含有static方法。

在jdk里面的function包中，就含有许多函数式接口，接下来就介绍一些常用的接口。

### 常见函数式接口对比 ###

<table> 
 <thead> 
  <tr> 
   <th>接口</th> 
   <th>说明</th> 
   <th>常用方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Function&lt;T,R&gt;</td> 
   <td>传入一个参数，返回一个值</td> 
   <td>apply，andThen，compose，identity</td> 
  </tr> 
  <tr> 
   <td>Consumer&lt; T &gt;</td> 
   <td>消费一个参数</td> 
   <td>accept，andThen</td> 
  </tr> 
  <tr> 
   <td>Supplier&lt; T&gt;</td> 
   <td>返回一个值</td> 
   <td>get</td> 
  </tr> 
  <tr> 
   <td>Predicate&lt;T,R&gt;</td> 
   <td>传入一个参数，返回一个布尔值</td> 
   <td>test，negate，and，or，isEqual</td> 
  </tr> 
  <tr> 
   <td>BiFunction&lt;T, U, R&gt;</td> 
   <td>传入两个参数，返回一个值</td> 
   <td>apply，andThen</td> 
  </tr> 
  <tr> 
   <td>BiConsumer&lt;T, U&gt;</td> 
   <td>消费两个参数</td> 
   <td>accept，andThen</td> 
  </tr> 
  <tr> 
   <td>BiPredicate&lt;T, U&gt;</td> 
   <td>断言两个参数，返回一个布尔值</td> 
   <td>test，negate，and，or</td> 
  </tr> 
  <tr> 
   <td>BinaryOperator&lt; T&gt;</td> 
   <td>对相同类型的参数进行比较，继承于BiFunction&lt;T,T,R&gt;</td> 
   <td>apply，andThen，minBy，maxBy</td> 
  </tr> 
  <tr> 
   <td>UnaryOperator&lt; T&gt;</td> 
   <td>返回输入值，继承于Function&lt;T,T&gt;</td> 
   <td>identity</td> 
  </tr> 
  <tr> 
   <td>BooleanSupplier</td> 
   <td>返回布尔值</td> 
   <td>getAsBoolean</td> 
  </tr> 
 </tbody> 
</table>

### Function ###

#### 方法说明 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>R apply(T t)</td> 
   <td>传入具体参数，执行方法体，返回结果</td> 
  </tr> 
  <tr> 
   <td> Function&lt;T, V&gt; andThen(Function&lt;? super R, ? extends V&gt; after)</td> 
   <td>传入function，执行完方法体后再执行传入的function</td> 
  </tr> 
  <tr> 
   <td> Function&lt;V, R&gt; compose(Function&lt;? super V, ? extends T&gt; before)</td> 
   <td>传入function，先执行传入的function，再执行方法体</td> 
  </tr> 
  <tr> 
   <td>Function&lt;T, T&gt; identity()</td> 
   <td>【静态方法】返回一个 返回值和传入参数一致的函数</td> 
  </tr> 
 </tbody> 
</table>

#### 使用示例 ####

Function<Integer, Integer> function1 = (input) -> input * 2;
    Function<Integer, Integer> function2 = (input) -> input + 10;
    Function<Integer, Integer> function3 = Function.identity();
    
    // 2
    System.out.println(function1.apply(1));
    // 11
    System.out.println(function2.apply(1));
    // 1
    System.out.println(function3.apply(1));
    
    // 12
    System.out.println(function1.andThen(function2).apply(1));
    // 2
    System.out.println(function1.andThen(function3).apply(1));
    
    // 22
    System.out.println(function1.compose(function2).apply(1));
    // 2
    System.out.println(function1.compose(function3).apply(1));

### Consumer ###

#### 方法说明 ####

注意：consumer是可以对接具有返回值的方法。

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>apply</td> 
   <td>传入具体参数，执行方法体，返回结果</td> 
  </tr> 
  <tr> 
   <td>andThen</td> 
   <td>传入function，执行完方法体后再执行传入的function</td> 
  </tr> 
  <tr> 
   <td>compose</td> 
   <td>传入function，先执行传入的function，再执行方法体</td> 
  </tr> 
  <tr> 
   <td>identity</td> 
   <td>【静态方法】返回一个 返回值和传入参数一致的函数</td> 
  </tr> 
 </tbody> 
</table>

#### 使用示例 ####

Consumer<Integer> consumer1 = (input) -> System.out.println("Comsumer1:" + input);
    Consumer<Integer> consumer2 = (input) -> System.out.println("Comsumer2:" + input);
    
    // Comsumer1:1
    consumer1.accept(1);
    // Comsumer1:1
    // Comsumer2:1
    consumer1.andThen(consumer2).accept(1);

### Supplier ###

#### 方法说明 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>T get()</td> 
   <td>执行方法体，获取返回结果</td> 
  </tr> 
 </tbody> 
</table>

#### 使用示例 ####

Supplier<Integer> supplier1 = () -> 100;
    Supplier<Integer> supplier2 = () -> 2 * 10 + 40;
    
    // 100
    System.out.println(supplier1.get());
    // 60
    System.out.println(supplier2.get());

### Predicate ###

#### 方法说明 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean test(T t)</td> 
   <td>断言t，返回一个布尔值</td> 
  </tr> 
  <tr> 
   <td>Predicate and(Predicate&lt;? super T&gt; other)</td> 
   <td>与逻辑</td> 
  </tr> 
  <tr> 
   <td>Predicate negate()</td> 
   <td>返回test相反值</td> 
  </tr> 
  <tr> 
   <td>Predicate or(Predicate&lt;? super T&gt; other)</td> 
   <td>或逻辑</td> 
  </tr> 
  <tr> 
   <td>Predicate isEqual(Object targetRef)</td> 
   <td>【静态方法】判断是否equal</td> 
  </tr> 
 </tbody> 
</table>

#### 使用示例 ####

Predicate<Integer> predicate1 = (input) -> input > 0;
    Predicate<Integer> predicate2 = (input) -> input < 0;
    
    // true
    System.out.println(predicate1.test(1));
    // false
    System.out.println(predicate1.negate().test(1));
    // false
    System.out.println(predicate1.and(predicate2).test(1));
    // true
    System.out.println(predicate1.or(predicate2).test(1));
    // true
    System.out.println(Predicate.isEqual(1).test(1));

在function包内部出了上述介绍的接口，还有针对int，long，double的相应接口，用法都大致相仿，就不在此赘述。

## lambda ##

大家都知道匿名类一定意义上简化了代码，而lambda表达式其实在一定程度上起到了再次简化代码的作用。在上节函数式接口的使用示例中，我都是直接使用最简单的lambda表达式来演示，可见一个方法体只需要用一行代码即可描述的简便性。

#### 常见的lambda表达式 ####

// 无参数
    ()-> { 1};
    // 无参数，一行代码的方法体可直接省略花括号
    ()-> 1;
    // 明确一个参数类型，且返回其二倍数
    (int nput)-> input*2;
    // 可以不明确参数类型
    (input)-> input;
    // 输入两个参数
    (input1, input2) -> input1 + input2;
    // 输入两个参数
    (int input1, int input2) -> input1 + input2;

看见上面常见的lambda表达式，我们可以发现有些时候lambda表达式需要定义参数类型，而有些时候却不需要，这是为啥？  
因为编译器会根据上下文环境对lambda表达式进行参数推导，所以有时候我们直接写一个lambda表达式时，可以根据该表达式所在环境适当省略类型声明，比如我们上节函数式接口的使用示例中，前方明确了参数类型，返回值类型就可以省略后续lambda表达式的类型声明。

注意：如果在lambda表达式直接用成员变量，意味着lambda表达式持有了外部对象的引用

public class Test { 
        static String str = "dddd";
        String str2 = "dddd";
    
    
        public static void main(String[] args) { 
            Thread t = new Thread(() -> { 
                System.out.println(str);
            });
    
    
        }
    
        void test() { 
    
            new Runnable() { 
                @Override
                public void run() { 
                    System.out.println(str2);
                }
            };
            
            Thread t = new Thread(() -> { 
                System.out.println(str2);
            });
        }
    }

对应的class文件

public class Test { 
        static String str = "dddd";
        String str2 = "dddd";
    
        public Test() { 
        }
    
        public static void main(String[] var0) { 
            new Thread(() -> { 
                System.out.println(str);
            });
        }
    
        void test() { 
            Runnable var10001 = new Runnable() { 
                public void run() { 
                    System.out.println(Test.this.str2);
                }
            };
            new Thread(() -> { 
                System.out.println(this.str2);
            });
        }
    }
    
    class Test$1 implements Runnable { 
        Test$1(Test var1) { 
            this.this$0 = var1;
        }
    
        public void run() { 
            System.out.println(this.this$0.str2);
        }
    }

## 方法引用 ##

当我们想再对lambda表达式进行简化时，或者说，只要方法体是调用一个已经存在的方法，不对现有方法进行改写，就可以使用方法引用了。

### 使用示例 ###

// 静态方法引用
    List<String> list = Arrays.asList("aa", "bb", "cc");
    List<String> valueList = list.stream().map(String::valueOf).collect(Collectors.toList());
    
    // 含参构造方法引用
    Function<String, String> function = String::new;
    
    // 实例方法引用
    valueList.forEach(System.out::println);

注意：  
针对下面这种方法，我们有两种方法引用的写法

default void follow(final Car another) { 
            System.out.println("Following the " + another.toString());
        }

final Car car = new Car() { 
    };
    // 第一种 
    Consumer<Car> c3 = car::follow;
    c3.accept(car);
    // 第二种
    BiConsumer<Car,Car> c4 = Car::follow;
    c4.accept(car,car);

因为follow是实例方法，所以使用第一种方式时，会默认调用car的follow方法，传入的参数默认是调用的实例；使用第二种时，由于是要通过类名引用，则需要传入实例，并且要指明参数是谁，所以要传入两个值。