一文搞懂Java中的lambda匿名函数

1 Lambda表达式

Lambda函数，也称为Lambda表达式，是Java 8版本新增的一项功能。它提供了一种简洁的方式来定义小型匿名函数，这些函数可以作为参数传递给其他方法或作为返回值使用。

语法:

Lambda表达式可以使用这个语法->来表示。

示例:

零参数：() -> expression

interface PrintInfo {
  void print();
 }

 class TestLambda {
  
    static void printJob(PrintInfo printInfo) { 
      printInfo.print(); 
    }
  
    public static void main(String[] args) {
       printJob(() -> System.out.println("We're learning Java 8 fundamentals !"));
    }
 }

Output: We’re learning Java 8 fundamentals !

一个参数：parameter -> expression

interface PrintInfo {
  void print(String data);
 }

 class TestLambda {

  static void printJob(PrintInfo printInfo, String data) {
   printInfo.print(data);
  }

  public static void main(String[] args) {
   printJob(statement -> System.out.println("We're learning " + statement), "Lambda");
  }
 }

Output: We’re learning Lambda

多个参数:(parameter1, parameter2) -> expression

interface PrintInfo {
  void print(String data1, String data2);
 }

 class TestLambda {

  static void printJob(PrintInfo printInfo, String data1, String data2) {
   printInfo.print(data1, data2);
  }

  public static void main(String[] args) {
   printJob((statement1, statement2) -> System.out.println("We're learning " + statement1 + " and "+ statement2), "Lambda", "it's uses");
  }
 }

Output: We’re learning Lambda and it’s uses

复杂表达式：(parameter1, parameter2) -> { complex code block }

interface PrintInfo {
  void print(String data1, String data2);
}

 class TestLambda {

  static void printJob(PrintInfo printInfo, String data1, String data2) {
     printInfo.print(data1, data2);
  }

  public static void main(String[] args) {
     printJob((statement1, statement2) -> {
        System.out.println("We're learning " + statement1 + " and "+ statement2);
        System.out.println("This is a multi line lambda");
        System.out.println("This is a complex lambda implementation");
       }, 
        "Lambda",
        "it's uses"
      );
   }
 }

Output: We’re learning Lambda and it’s uses

This is a multi line lambda

This is a complex lambda implementation

2 方法引用

方法引用是一种紧凑、易读的Lambda表达式，用于已经具有名称的方法。简单地说，我们可以使用方法引用从Lambda函数中调用方法。

语法:

Object::method

让我们来看看如何使用Lambda打印列表中的元素:

public void print(List<String> list) {
    list.forEach(l -> System.out.println(l));
}

可以使用方法引用，如下所示:

public void print(List<String> list) {
    list.forEach(System.out::println);
}

如您所见，这使代码更加清晰、精确和易于阅读。

同样地，我们可以使用Classname::methodName来表示对静态方法的调用。

public static void main(String[]args){
    List<String> fruits = new ArrayList<>();
    fruits.add("mango");
    fruits.add("banana");
    fruits.add("kiwi");
    fruits.add("orange");

    fruits.forEach(Test::process);
}

private static void process(String value) {
    System.out.println("processed fruit: " + value);
}

同时，我们可以使用Object to be instantiated::new来使用方法引用引用构造函数。

public static void main(String[]args){
      List<String> fruits = new ArrayList<>();
      fruits.add("mango");
      fruits.add("banana");
      fruits.add("kiwi");
      fruits.add("orange");

      fruits.stream()
              .map(Fruit::new)
              .toArray(Fruit[]::new);
}

class Fruit {
    public Fruit(String name) {
        this.name = name;
    }
}

方法引用也可以用于Comparator。

按名称对水果列表排序:

public static void process(List<Fruit> fruits) {
    fruits.stream()
            .sorted(Comparator.comparing(Fruit::getName))
            .forEach(System.out::println);
}

3 Lambda的不同用途

遍历列表

public static void main(String[] args) {
   List<String> fruits = List.of("mango", "oranges", "banana", "kiwi", "apple");
   fruits.forEach(fruit -> System.out.println(fruit));
}

遍历Map

public static void main(String[] args) {
   Map<String, Integer> map = new HashMap<>();
   map.put("value1", 10);
   map.put("value2", 20);
   map.put("value3", 30);
   map.put("value4", 40);
   map.forEach((key, value) -> System.out.println("key: " + key + ", value: " + value));
  }

创建Runnable和Callable

Runnable是一个函数式接口，因此我们可以使用Lambda表达式来表示它。

使用匿名类创建Runnable的典型方式

public static void main(String[] args) {
  Runnable runnable = new Runnable() {
     @Override
     public void run() {
        System.out.println("Hello World !");
     }
  };
}

同样的Lambda表达式实现如下：

public static void main(String[] args) {
  Runnable runnable = () -> System.out.println("Hello World !");
}

同样地，Callable也可以实现：

public static void main(String args[]) throws InterruptedException {
    Callable<Integer> callable = () -> {
      int sum = 0;
      for (int i = 0; i < 5; i++) {
        sum += i;
      }
      return sum;
    };
}

Predicate

使用Lambda函数表示Predicate：

public class HelloWorld{

     public static void main(String []args){
        Predicate<Integer> predicate = (i) -> i > 10;
        System.out.println(predicate.test(15));
     }
}

Output: True

Consumer

使用Lambda函数表示Consumer:

public class HelloWorld{

     public static void main(String []args){
       //例1
        Consumer<Integer> consumer = System.out::println;
        consumer.accept(10);

       //例2
        List<String> inputs = new ArrayList<>();
        Consumer<String> consumer = str -> inputs.add(str);
        consumer.accept("first");
        consumer.accept("second");
        inputs.forEach(e -> System.out.println(e));
     }
}

Example 1 output: 10,Example 2 output: first \n second

Comparator

Comparator是Java中的一个函数式接口，因此我们可以使用Lambda函数来表示它。

下面我们使用Lambda创建一个Comparator：

public static void process(List<Movie> movies) {
    Comparator<Movie> movieComparator = (m1, m2) -> m1.getRating() - m2.getRating();
    movies.sort(movieComparator);
}

让我们看看更多的例子：

按自然顺序排序数字列表：

private static void process(List<Integer> numbers) {
    numbers.stream()
            .sorted(Comparator.naturalOrder())
            .forEach(System.out::println);
}

如果我们要根据多个参数对列表进行排序，则可以使用Comparator的thenComparing方法，如下所示：

private static void process(List<Movie> movies) {
    movies.stream()
            .sorted(Comparator.comparing(Movie::getName)
                    .thenComparing(Movie::getRating)
            )
            .forEach(System.out::println);
}

将排序后的列表反转:

private static void process(List<Movie> movies) {
    movies.stream()
            .sorted(Comparator.comparing(Movie::getName)
            .thenComparing(Movie::getRating)
            .reversed())
            .forEach(System.out::println);
}

4 总结

本文中，我们探讨了Lambda函数，看了很多不同的Lambda函数的例子，我们还了解了如何使用方法引用和Comparator。