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

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

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。

责任编辑:武晓燕 来源: Java学研大本营
相关推荐

2021-09-07 09:46:40

JavaScriptGenerator函数

2023-07-04 08:56:07

指针类型Golang

2023-09-08 08:20:46

ThreadLoca多线程工具

2021-03-22 10:05:59

netstat命令Linux

2023-09-15 12:00:01

API应用程序接口

2021-12-29 17:38:17

JavaScripttypeof前端

2022-03-24 08:51:48

Redis互联网NoSQL

2023-04-12 08:38:44

函数参数Context

2021-09-11 10:41:27

PythonPickle模块

2022-05-05 16:47:24

Docker网络空间容器

2023-12-21 08:02:21

CPUJava8列表

2021-01-13 05:21:59

参数

2021-06-30 08:45:02

内存管理面试

2023-10-16 08:16:31

Bean接口类型

2022-08-15 15:39:23

JavaScript面向对象数据

2023-08-24 16:50:45

2022-06-07 10:13:22

前端沙箱对象

2020-03-18 14:00:47

MySQL分区数据库

2023-04-03 15:04:00

RPCPHP语言

2019-11-19 08:00:00

神经网络AI人工智能
点赞
收藏

51CTO技术栈公众号