Lambda for Java

最新推荐文章于 2025-07-19 08:35:23 发布

原创最新推荐文章于 2025-07-19 08:35:23 发布 · 2.4k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#lambda for java #lambda java

go编程语言同时被 2 个专栏收录

10 篇文章

订阅专栏

编程语言

5 篇文章

订阅专栏

本文深入解析AWS Lambda服务，介绍其无服务器计算特性，自动缩放能力，以及按需计费模式。特别聚焦于使用Java语言编写Lambda函数，涵盖编程模型、库使用和日志记录实践。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Lambda 是一项计算服务，可使您无需预配置或管理服务器即可运行代码。AWS Lambda 只在需要时执行您的代码并自动缩放，从每天几个请求到每秒数千个请求。您只需按消耗的计算时间付费 – 代码未运行时不产生费用。借助 AWS Lambda，您几乎可以为任何类型的应用程序或后端服务运行代码，而且无需执行任何管理。AWS Lambda 在可用性高的计算基础设施上运行您的代码，执行计算资源的所有管理工作，其中包括服务器和操作系统维护、容量预置和自动扩展、代码监控和记录。您只需要以 AWS Lambda 支持的一种语言 (目前为 Node.js、Java、C#、Go 和 Python) 提供您的代码。

中文版官网：

使用 Java 编写 Lambda 函数的编程模型
https://docs.aws.amazon.com/zh_cn/lambda/latest/dg/java-programming-model.html

English-language version：

Building Lambda Functions with Java
https://docs.aws.amazon.com/lambda/latest/dg/java-programming-model.html

在这里插入图片描述

注：官网提示要在jdk版本大于1.8.0以上的才可以运行

Lambda 提供了以下库：

aws-lambda-java-core - 此库提供了 Context 对象、RequestStreamHandler 接口和 RequestHandler 接口。Context 对象 (Context 对象 (Java)) 提供有关您的 Lambda 函数的运行时信息。预定义接口提供一种定义 Lambda 函数处理程序的方法。有关更多信息，请参阅利用预定义接口创建处理程序 (Java)。
aws-lambda-java-events - 此库提供一些预定义类型，供您在编写 Lambda 函数以处理由 Amazon S3、Kinesis、Amazon SNS 和 Amazon Cognito 发布的事件时使用。这些类可帮助您处理事件，而不必自行编写自定义序列化逻辑。
Custom Appender for Log4j2.8 – 您可使用由 AWS Lambda 提供的自定义 Log4j (请参阅 Apache Log4j 2) Appender 从您的 Lambda 函数记录日志。每个对 Log4j 方法的调用（如 log.info() 或 log.error()）都将生成一个 CloudWatch Logs 事件。自定义 Appender 称为 LambdaAppender 并且必须在 log4j2.xml 文件中使用。您必须在部署程序包 (.jar 文件) 中包含 aws-lambda-java-log4j2 项目 (artifactId：aws-lambda-java-log4j2)。有关更多信息，请参阅日志记录 (Java)。
Custom Appender for Log4j1.2 – 您可使用由 AWS Lambda 提供的自定义 Log4j (请参阅 Apache Log4j 1.2) Appender 从您的 Lambda 函数记录日志。有关更多信息，请参阅日志记录 (Java)。

可通过 Maven Central 存储库及在 GitHub 上找到这些库。
注：其中Lambda 还有一个库 Log4j v1.2 自定义 Appender 的支持。它不会再有新的进行更新，也不建议再使用它。

Lambda 表达式实例

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

在 Java8Tester.java 文件输入以下代码实例：

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

执行以上脚本，输出结果为：
$ javac Java8Tester.java
$ java Java8Tester
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google

使用 Lambda 表达式需要注意以下两点：

Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

使用 lambda 来实现 Runnable 接口的示例:

// 1.1使用匿名内部类  
new Thread(new Runnable() {  
    @Override  
    public void run() {  
        System.out.println("Hello world !");  
    }  
}).start();  
  
// 1.2使用 lambda expression  
new Thread(() -> System.out.println("Hello world !")).start();  
  
// 2.1使用匿名内部类  
Runnable race1 = new Runnable() {  
    @Override  
    public void run() {  
        System.out.println("Hello world !");  
    }  
};  
  
// 2.2使用 lambda expression  
Runnable race2 = () -> System.out.println("Hello world !");  
   
// 直接调用 run 方法(没开新线程哦!)  
race1.run();  
race2.run();

使用 Lambdas 排序集合

Runnable 的 lambda 表达式，使用块格式，将五行代码转换成单行语句。

在 Java 中，Comparator 类被用来排序集合。在下面的例子中，我们将根据球员的 name、
surname、name 长度以及最后一个字母。和前面的示例一样，先使用匿名内部类来排序，然后再使用 lambda 表达式精简我们的代码。

在第一个例子中，我们将根据name来排序list。使用旧的方式，代码如下所示:

String[] players = {"Rafael Nadal", "Novak Djokovic",   
    "Stanislas Wawrinka", "David Ferrer",  
    "Roger Federer", "Andy Murray",  
    "Tomas Berdych", "Juan Martin Del Potro",  
    "Richard Gasquet", "John Isner"};  
   
// 1.1 使用匿名内部类根据 name 排序 players  
Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.compareTo(s2));  
    }  
});

使用 lambda，可以通过下面的代码实现同样的功能:

// 1.2 使用 lambda expression 排序 players  
Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));  
Arrays.sort(players, sortByName);  
  
// 1.3 也可以采用如下形式:  
Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));  

其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :

// 1.1 使用匿名内部类根据 surname 排序 players  
Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));  
    }  
});  
  
// 1.2 使用 lambda expression 排序,根据 surname  
Comparator<String> sortBySurname = (String s1, String s2) ->   
    ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) );  
Arrays.sort(players, sortBySurname);  
  
// 1.3 或者这样
      Arrays.sort(players,
                (String s1, String s2) ->
                ( s1.substring(s1.indexOf(" ")).
                        compareTo(
                        s2.substring(s2.indexOf(" "))
                        )
                )
        );
  
// 2.1 使用匿名内部类根据 name lenght 排序 players  
Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.length() - s2.length());  
    }  
});  
  
// 2.2 使用 lambda expression 排序,根据 name lenght  
Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length());  
Arrays.sort(players, sortByNameLenght);  
  
// 2.3 or this  
Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length()));  
  
// 3.1 使用匿名内部类排序 players, 根据最后一个字母  
Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));  
    }  
});  
  
// 3.2 使用 lambda expression 排序,根据最后一个字母  
Comparator<String> sortByLastLetter =   
    (String s1, String s2) ->   
        (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));  
Arrays.sort(players, sortByLastLetter);  
  
// 3.3 or this  
Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));

使用 kotlin 加 lambda如下

import java.util.*

/**
 * author : Jeff  5899859876@qq.com
 * Github: https://github.com/Jay-YaoJie
 * Created :  2018-12-03.
 * description ：
 */
fun main(ager: Array<String>) {
    var players = arrayOf(
        "Rafael Nadal",
        "Novak Djokovic",
        "Stanislas Wawrinka",
        "David Ferrer",
        "Roger Federer",
        "Andy Murray",
        "Tomas Berdych",
        "Juan Martin Del Potro",
        "Richard Gasquet",
        "John Isner"
    )
    Arrays.sort(
        players,
        { s1: String, s2: String ->
            (
              s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" ")))
             )
        }
    )
    for (str: String in players) {
        System.out.println(str)
    }

}

在这里插入图片描述