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

电玩女神 2023-10-15 22:04 7阅读 0赞

> 本文介绍Java 8中的Lambda表达式和方法引用，以及其在编程中的应用。

微信搜索关注《Java学研大本营》

![图片][bbd46321fcc45949bf078594fc537992.png]

### 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`

`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。

### 推荐书单 ###

![5b61f7c93b2342f3a4f8dfe62bdde0d9.png][]

#### **【秋日阅读企划】点击下方链接立享优惠，叠加五折使用** ####

[秋日阅读企划![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://pro.m.jd.com/mall/active/2Z3HoZGKy5i9aEpmoTUZnmcoAhHg/index.html][icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_pro.m.jd.com_mall_active_2Z3HoZGKy5i9aEpmoTUZnmcoAhHg_index.html]

#### 《Java编程讲义》 ####

《Java编程讲义》根据目前Java开发领域的实际需求，从初学者角度出发，详细讲解了Java技术的基础知识。全书共15章，包括Java开发入门，Java语言基础，Java控制结构，数组，面向对象编程，继承和多态，抽象类、接口和内部类，异常处理，Java常用类库，集合与泛型，Lambda表达式，输入-输出流，多线程，JDBC数据库技术，网络编程等内容。内容全面覆盖．1ava开发必备的基础知识点，结合生活化案例展开讲解，程序代码给出了详细的注释，能够使初学者轻松领会Java技术精髓，快速掌握Java开发技能。 　　《Java编程讲义》适合作为高等院校相关专业的教材及教学参考书，也适合作为Java开发入门者的自学用书，还可供开发人员查阅、参考。  
[Java编程讲义![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://item.jd.com/13495830.html][Java_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_item.jd.com_13495830.html]

![图片][9a0064f97cad116a8201293b11e437a7.jpeg]

> > ### 精彩回顾 ###
> > 
> > [Java 21性能提升，会推出什么新特性？][Java 21]
> > 
> > [超简单，实现Java线程池][Java]
> > 
> > [超简单，精通Java异常处理][Java 1]
> > 
> > [详解FPGA —— 下一代AI算力芯片（下）][FPGA _ _AI]
> > 
> > [详解FPGA —— 下一代AI算力芯片（中）][FPGA _ _AI 1]

> > 微信搜索关注《Java学研大本营》
> > 
> > 访问【IT今日热榜】，发现每日技术热点

[bbd46321fcc45949bf078594fc537992.png]: https://img-blog.csdnimg.cn/img_convert/bbd46321fcc45949bf078594fc537992.png
[5b61f7c93b2342f3a4f8dfe62bdde0d9.png]: https://img-blog.csdnimg.cn/5b61f7c93b2342f3a4f8dfe62bdde0d9.png
[icon-default.png_t_N7T8]: https://csdnimg.cn/release/blog_editor_html/release2.3.6/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N7T8
[icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_pro.m.jd.com_mall_active_2Z3HoZGKy5i9aEpmoTUZnmcoAhHg_index.html]: https://pro.m.jd.com/mall/active/2Z3HoZGKy5i9aEpmoTUZnmcoAhHg/index.html
[Java_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_item.jd.com_13495830.html]: https://item.jd.com/13495830.html
[9a0064f97cad116a8201293b11e437a7.jpeg]: https://img-blog.csdnimg.cn/img_convert/9a0064f97cad116a8201293b11e437a7.jpeg
[Java 21]: https://mp.weixin.qq.com/s?__biz=MzkzMDM3MjI3Nw==&mid=2247488488&idx=1&sn=c1d585f18424f5c2375c89d4a53c2d56&scene=21#wechat_redirect
[Java]: https://mp.weixin.qq.com/s?__biz=MzkzMDM3MjI3Nw==&mid=2247488456&idx=1&sn=cdacd900097749168554bb1df1d746a6&scene=21#wechat_redirect
[Java 1]: https://mp.weixin.qq.com/s?__biz=MzkzMDM3MjI3Nw==&mid=2247488442&idx=1&sn=9000fda279760fefe53d20c0d3510aca&scene=21#wechat_redirect
[FPGA _ _AI]: https://mp.weixin.qq.com/s?__biz=MzkzMDM3MjI3Nw==&mid=2247488426&idx=1&sn=c4c67c0571ab765f3288b14fcb576d71&scene=21#wechat_redirect
[FPGA _ _AI 1]: https://mp.weixin.qq.com/s?__biz=MzkzMDM3MjI3Nw==&mid=2247488407&idx=1&sn=c1d93ffe0e4f2b1f36b4cb61e1e5cc89&scene=21#wechat_redirect