搜索
您的当前位置：首页正文

最新版 Lambda 表达式｜万字笔记

来源：爱go旅游网


学习 Lambda 表达式（Lambda Expressions）可以从以下几个步骤和概念入手，逐步构建你的知识网络：

1. 基本概念

1.1 Lambda 表达式的定义

是一种匿名函数，可以简化代码，常用于函数式编程。它们允许你将函数作为参数传递给其他函数。

1.2 快速搞懂 Lambda

理解 Lambda 表达式的基本概念，可以类比为在日常生活中使用快递服务。

1.2.1 快递服务类比

想象你需要给朋友发送一些东西，但你不想亲自去邮局。你可以使用快递服务，这时 Lambda 表达式就像是给快递员的指令。

1.2.2 传统方式（类比于传统的匿名内部类）
  • 你需要：给朋友寄一个包裹。
  • 传统做法：你写一封信，详细说明如何打包、如何送达等步骤，然后交给快递员。
// 传统的匿名内部类
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Sending a package to friend.");
    }
}).start();
1.2.3 Lambda 表达式方式
  • 你需要：给朋友寄一个包裹。
  • Lambda 做法：你直接告诉快递员：“把这个包裹送给我的朋友。”，省去了写详细说明的步骤。
// 使用Lambda表达式
new Thread(() -> System.out.println("Sending a package to friend.")).start();
1.2.4 形象解释
  • 快递员：相当于 Java 中的 Thread 或其他需要函数作为参数的类。
  • 你给出的指令：就是 Lambda 表达式。
    • 传统方式：你写一封详细的信（匿名内部类），里面详细说明如何处理包裹。
    • Lambda 方式：你直接告诉快递员怎么做（Lambda 表达式），简洁明了。
1.2.5 具体案例

假设你想给朋友寄一个生日礼物：

  • 传统方式：你写一封信，里面详细说明：“请把这个包裹打包好，贴上地址，然后送到这个地址。” 这就像是匿名内部类，你定义了一个完整的类来实现这个任务。
  • Lambda方式：你直接告诉快递员：“请把这个包裹送给我的朋友。” 这就是Lambda表达式，你直接给出了一个简洁的指令。
1.2.6 代码实现

假设你有一个 GiftSender 接口，它只有一个方法 sendGift()：

interface GiftSender {
    void sendGift();
}
  • 传统方式：
GiftSender sender = new GiftSender() {
    @Override
    public void sendGift() {
        System.out.println("Sending a birthday gift to friend.");
    }
};
sender.sendGift();
  • Lambda方式：
GiftSender sender = () -> System.out.println("Sending a birthday gift to friend.");
sender.sendGift();

总结

  • Lambda 表达式就像是直接给快递员的简洁指令，省去了写详细说明的步骤。
  • 传统匿名内部类就像是写一封信，详细说明每一步骤。

通过这种类比，你可以更形象地理解Lambda表达式是如何简化代码的。它让你能够直接给出指令，而不是定义一个完整的类来实现这个简单的任务。

2. 函数式接口

2.1 函数式接口的定义

只有一个抽象方法的接口。Lambda 表达式通常用于实现这些接口的唯一抽象方法。

  • 例子：Runnable, Callable, Consumer, Supplier, Predicate 等。

2.2 快速搞懂函数式接口

理解 Lambda 函数式接口，可以类比为在餐馆点菜的过程。

2.2.1 餐馆点菜类比

想象你走进了一家自助餐馆，你可以选择不同的服务方式：

2.2.2 传统服务方式（类比于传统方法）
  • 服务员：给你菜单，你点菜，服务员去厨房取菜。
  • 菜单：上面有各种菜品，服务员根据你的选择去准备。
2.2.3 自助餐方式（类比于 Lambda 函数式接口）
  • 自助餐台：你直接去取你想要的食物。
  • 函数式接口：就像是自助餐台上的指示牌，告诉你可以做什么。
2.2.4 形象解释

假设你想点一份沙拉：

  • 传统服务：
    • 你告诉服务员：“请给我一份沙拉。”（你直接给出了命令）
    • 服务员去厨房，厨师准备沙拉，服务员端给你。
  • 自助餐：
    • 你走到沙拉吧台（函数式接口），那里有指示牌：“请自己取沙拉。”（函数式接口的抽象方法）
    • 你自己动手取沙拉（实现这个接口的方法）。

假设有一个FoodPreparer接口，它只有一个抽象方法 prepareFood()：

interface FoodPreparer {
    void prepareFood();
}
传统方式

就像你告诉服务员你想要什么：

// 传统方式
FoodPreparer preparer = new FoodPreparer() {
    @Override
    public void prepareFood() {
        System.out.println("Preparing a salad.");
    }
};
preparer.prepareFood();
Lambda 方式

就像你直接去自助餐台：

// Lambda方式
FoodPreparer preparer = () -> System.out.println("Preparing a salad.");
preparer.prepareFood();
2.2.5 具体案例

假设你想创建一个简单的应用，让用户可以选择不同的操作：

  • 操作选择：就像餐馆的菜单，你可以选择不同的菜品（操作）。
interface Operation {
    void execute();
}
  • 使用 Lambda 表达式：
// 定义一个操作
Operation add = () -> System.out.println("Adding numbers");

// 执行这个操作
add.execute();

总结

  • 函数式接口就像是自助餐台上的指示牌，它告诉你可以做什么，但不告诉你具体怎么做。
  • Lambda 表达式就像是你根据指示牌的指引去做的事情，简化了代码，减少了样板代码。

通过这种类比，你可以形象地理解：

  • 函数式接口提供了一个标准化的方式让你实现一个操作，就像自助餐台提供了一个标准化的取食方式。
  • Lambda 表达式让你可以非常简洁地定义这个操作，就像你直接去取食物一样简单。

3. Lambda 表达式的语法

  • 基本语法：

    (参数列表) -> { 代码块 }
    • 例如：(int x) -> System.out.println(x);

  • 参数类型推断：如果编译器可以推断出参数类型，可以省略类型。

    (x) -> System.out.println(x);

  • 单参数简写：如果只有一个参数，可以省略括号。

    x -> System.out.println(x);

  • 无参数：

    () -> System.out.println("Hello");

  • 返回值：如果只有一行代码且是返回值，可以省略 return 和花括号。

    x -> x * x; // 等同于 (x) -> { return x * x; }

4. Lambda 表达式的使用场景

4.1 两大使用场景

  • 作为方法参数：

    Arrays.asList("a", "b", "c").forEach(e -> System.out.println(e));

  • 实现函数式接口：

    Runnable r = () -> System.out.println("My Runnable");

4.2 具体案例

4.2.1. 作为方法参数
01 图书馆借书系统
  • 场景：你想从图书馆借书，但图书馆的借书系统需要你提供一个回调函数来通知你借书结果。
  • 传统方式：你需要实现一个接口来接收借书结果。
// 传统方式
class BookBorrowResult implements BorrowCallback {
    @Override
    public void onBorrowResult(String result) {
        System.out.println("Borrow result: " + result);
    }
}

Library.borrowBook("Java Programming", new BookBorrowResult());
  • Lambda 方式：你直接给出回调函数。
// Lambda方式
Library.borrowBook("Java Programming", result -> System.out.println("Borrow result: " + result));
02 咖啡店点单系统
  • 场景：你想在咖啡店点一杯咖啡，系统需要你提供一个回调函数来通知你咖啡准备好。
  • 传统方式：
class CoffeeReadyListener implements CoffeeCallback {
    @Override
    public void onCoffeeReady() {
        System.out.println("Your coffee is ready!");
    }
}

CoffeeShop.orderCoffee("Espresso", new CoffeeReadyListener());
  • Lambda 方式：
CoffeeShop.orderCoffee("Espresso", () -> System.out.println("Your coffee is ready!"));
4.2.2. 实现函数式接口
01 智能家居系统
  • 场景：你想让智能灯在特定时间自动打开。
  • 传统方式：
class LightOn implements Runnable {
    @Override
    public void run() {
        System.out.println("Turning the light on at 7 PM.");
    }
}

Timer timer = new Timer();
timer.schedule(new LightOn(), 7 * 60 * 60 * 1000); // 7 PM
  • Lambda 方式：
Timer timer = new Timer();
timer.schedule(() -> System.out.println("Turning the light on at 7 PM."), 7 * 60 * 60 * 1000);
02 文件处理系统
  • 场景：你想读取一个文件并打印每一行。
  • 传统方式：
class FileProcessor implements LineProcessor {
    @Override
    public void processLine(String line) {
        System.out.println("Line read: " + line);
    }
}

// 假设有一个FileReader类
FileReader reader = new FileReader("example.txt");
reader.processFile(new FileProcessor());
  • Lambda 方式：
FileReader reader = new FileReader("example.txt");
reader.processFile(line -> System.out.println("Line read: " + line));
4.2.3 总结
  • 作为方法参数：Lambda 表达式可以直接作为函数的参数传递，就像你给系统一个简短的指令，告诉它在特定条件下应该做什么。例子中，图书馆借书和咖啡店点单系统都是这种情况。
  • 实现函数式接口：Lambda 表达式可以直接实现函数式接口的唯一抽象方法，就像你给智能设备一个指令，让它在特定时间执行某个任务。例子中，智能家居系统和文件处理系统都是这种情况。

通过这些类比，你可以更形象地理解：

  • Lambda 表达式如何简化代码，使得代码更加简洁和直观。
  • 函数式接口和方法参数的概念，如何在实际编程中应用Lambda表达式来提高代码的可读性和可维护性。

4.3 更多案例

理解Lambda表达式的使用场景，可以通过日常生活中的一些任务来类比。以下是一些形象的例子：

01 订阅报纸
  • 传统方式：你需要亲自去报社订阅报纸，每次都要填写详细信息。
  • Lambda 方式：就像你给报社留了一个简短的指令：“每周一给我送报纸。”，报社会根据这个指令自动执行。
// 传统方式
class NewspaperSubscriber implements Runnable {
    @Override
    public void run() {
        System.out.println("Delivering newspaper weekly.");
    }
}

new Thread(new NewspaperSubscriber()).start();

// Lambda方式
new Thread(() -> System.out.println("Delivering newspaper weekly.")).start();
02 自动浇水
  • 传统方式：你需要设置一个定时器，每天提醒你去给植物浇水。
  • Lambda方式：就像你设置了一个智能灌溉系统，只需要告诉它：“每天早上6点给植物浇水。”
// 传统方式
class WaterPlants implements Runnable {
    @Override
    public void run() {
        System.out.println("Watering plants at 6 AM.");
    }
}

Timer timer = new Timer();
timer.schedule(new WaterPlants(), 6 * 60 * 60 * 1000); // 6 AM

// Lambda方式
Timer timer = new Timer();
timer.schedule(() -> System.out.println("Watering plants at 6 AM."), 6 * 60 * 60 * 1000);
03 处理邮件
  • 传统方式：你需要写一个程序，每次收到邮件时，你都要手动检查并处理。
  • Lambda 方式：就像你告诉邮局：“当有邮件时，立即通知我。”
// 传统方式
class EmailProcessor implements Runnable {
    @Override
    public void run() {
        System.out.println("Processing new email.");
    }
}

// 假设有一个邮件系统
EmailSystem emailSystem = new EmailSystem();
emailSystem.setEmailListener(new EmailProcessor());

// Lambda方式
EmailSystem emailSystem = new EmailSystem();
emailSystem.setEmailListener(() -> System.out.println("Processing new email."));
04 过滤列表
  • 传统方式：你需要遍历一个列表，检查每个元素是否符合条件，然后手动构建一个新列表。
  • Lambda方式：就像你告诉助手：“找出所有大于10的数字。”
// 传统方式
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 10, 15, 20);
List<Integer> filteredList = new ArrayList<>();
for (Integer number : numbers) {
    if (number > 10) {
        filteredList.add(number);
    }
}

// Lambda方式
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 10, 15, 20);
List<Integer> filteredList = numbers.stream()
                                     .filter(x -> x > 10)
                                     .collect(Collectors.toList());
05 事件监听
  • 传统方式：你需要实现一个接口来监听按钮点击事件。
  • Lambda方式：就像你告诉按钮：“当我被点击时，显示一个消息。”
// 传统方式
JButton button = new JButton("Click me");
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked!");
    }
});

// Lambda方式
JButton button = new JButton("Click me");
button.addActionListener(e -> System.out.println("Button clicked!"));
总结

这些例子展示了Lambda表达式如何简化代码：

  • Lambda表达式就像是给系统或设备的简短指令，告诉它在特定条件下应该做什么。
  • 传统方式需要定义完整的类或方法来实现这些任务，而Lambda表达式直接给出了任务的具体实现。

通过这些类比，你可以更形象地理解Lambda表达式的使用场景：它们用于简化代码，提供直接的、简洁的任务实现。

5. 方法引用

5.1 Lambda 的方法引用

方法引用（Method Reference）是一种简化 Lambda 表达式的写法，可以直接引用现有的方法或构造函数。

  • 类名::静态方法
  • 对象::实例方法
  • 类名::实例方法（适用于任意对象）
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println); // 调用System.out.println方法

5.2 快速搞懂 Lambda 的方法引用

5.2.1 快捷方式类比
  • 传统方式：每次你都要完整地输入朋友的地址。
  • 快捷方式：你创建了一个快捷方式，只需要点击这个快捷方式就能直接到达朋友家。
5.2.2 形象解释
  • 传统方式：每次都输入 Alice 的地址。
  • 快捷方式：你创建了一个名为“Alice”的快捷方式，直接点击它就能发消息。
5.2.3 具体使用

在编程中，Lambda 方法引用就像是创建了一个快捷方式，直接引用现有的方法。

场景：打印所有字符串

  • 传统 Lambda：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));
  • 方法引用：
names.forEach(System.out::println);
  • 传统 Lambda：就像每次你都要完整地输入 Alice 的地址来发消息。
  • 方法引用：就像你创建了一个快捷方式，直接点击它就能发消息。
5.2.4 更具体的例子
01 构造函数引用
  • 传统 Lambda：创建一个新的对象。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<Person> people = names.stream()
                           .map(name -> new Person(name))
                           .collect(Collectors.toList());
  • 方法引用：直接引用构造函数。
List<Person> people = names.stream()
                           .map(Person::new)
                           .collect(Collectors.toList());
02 静态方法引用
  • 传统Lambda：调用一个静态方法。
List<String> strings = Arrays.asList("hello", "world");
List<String> upperCaseStrings = strings.stream()
                                       .map(s -> s.toUpperCase())
                                       .collect(Collectors.toList());
  • 方法引用：直接引用静态方法。
List<String> upperCaseStrings = strings.stream()
                                       .map(String::toUpperCase)
                                       .collect(Collectors.toList());
03 实例方法引用
  • 传统 Lambda：调用对象的实例方法。
List<String> strings = Arrays.asList("hello", "world");
strings.forEach(s -> System.out.println(s));
  • 方法引用：直接引用实例方法。
strings.forEach(System.out::println);
总结
  • 方法引用就像是创建了一个快捷方式，让你能够直接引用现有的方法或构造函数，而不需要每次都写完整的Lambda表达式。

通过这种类比，你可以更形象地理解：

  • 方法引用如何简化代码，使得代码更加简洁和直观。
  • Lambda表达式和方法引用之间的关系，就像是手动输入地址和使用快捷方式的关系。

6. 函数式接口的常用接口

6.1 常见的接口

  • Consumer：接受一个输入参数，不返回值。

    Consumer<String> consumer = s -> System.out.println(s);

  • Supplier：不接受参数，返回一个结果。

    Supplier<String> supplier = () -> "Hello";

  • Predicate：接受一个参数，返回一个布尔值。

    Predicate<String> predicate = s -> s.length() > 5;

  • Function：接受一个参数，返回一个结果。

    Function<String, Integer> toInteger = Integer::valueOf;

6.2 具体案例

深入理解和使用Lambda函数式接口的常用接口，可以通过一些日常生活中的场景来类比。以下是一些形象的例子：

01 Consumer 接口
  • Consumer：接受一个输入参数，不返回结果，就像是给出指令但不需要反馈。

例子：通知服务

  • 场景：你想通知所有朋友一个消息。
  • 传统方式：
class NotificationService {
    public void notify(String message) {
        System.out.println("Notifying: " + message);
    }
}

NotificationService service = new NotificationService();
service.notify("Party tonight!");
  • Lambda 方式：
List<String> friends = Arrays.asList("Alice", "Bob", "Charlie");
friends.forEach(friend -> System.out.println("Notifying " + friend + ": Party tonight!"));
  • 方法引用：
List<String> friends = Arrays.asList("Alice", "Bob", "Charlie");
Consumer<String> notify = System.out::println;
friends.forEach(friend -> notify.accept("Notifying " + friend + ": Party tonight!"));
02 Supplier 接口
  • Supplier：不接受参数，返回一个结果，就像是请求一个信息。

例子：天气预报

  • 场景：你想查看今天的天气。
  • 传统方式：
class WeatherService {
    public String getWeather() {
        return "Sunny";
    }
}

WeatherService service = new WeatherService();
String weather = service.getWeather();
System.out.println("Today's weather: " + weather);
  • Lambda方式：
Supplier<String> weatherSupplier = () -> "Sunny";
String weather = weatherSupplier.get();
System.out.println("Today's weather: " + weather);
03 Predicate 接口
  • Predicate：接受一个参数，返回一个布尔值，就像是做一个判断。

例子：筛选朋友

  • 场景：你想找出所有名字长度大于5的朋友。
  • 传统方式：
class FriendFilter {
    public boolean isNameLongEnough(String name) {
        return name.length() > 5;
    }
}

List<String> friends = Arrays.asList("Alice", "Bob", "Charlie", "David");
FriendFilter filter = new FriendFilter();
List<String> longNameFriends = friends.stream()
                                      .filter(filter::isNameLongEnough)
                                      .collect(Collectors.toList());
  • Lambda方式：
List<String> friends = Arrays.asList("Alice", "Bob", "Charlie", "David");
Predicate<String> longNamePredicate = name -> name.length() > 5;
List<String> longNameFriends = friends.stream()
                                      .filter(longNamePredicate)
                                      .collect(Collectors.toList());
04 Function 接口
  • Function：接受一个参数，返回一个结果，就像是将一种东西转换成另一种。

例子：转换货币

  • 场景：你想将美元转换成欧元。
  • 传统方式：
class CurrencyConverter {
    public double convertToEuro(double dollars) {
        return dollars * 0.85; // 假设汇率为0.85
    }
}

CurrencyConverter converter = new CurrencyConverter();
double euros = converter.convertToEuro(100);
System.out.println("100 USD in EUR: " + euros);
  • Lambda方式：
Function<Double, Double> toEuro = dollars -> dollars * 0.85;
double euros = toEuro.apply(100.0);
System.out.println("100 USD in EUR: " + euros);
05 BiConsumer 接口
  • BiConsumer：接受两个参数，不返回结果，就像是同时处理两个东西。

例子：通知朋友和时间

  • 场景：你想通知朋友在某个时间点做某事。
  • 传统方式：
class NotificationService {
    public void notify(String friend, String time) {
        System.out.println(friend + " should be ready at " + time);
    }
}

NotificationService service = new NotificationService();
service.notify("Alice", "8 PM");
  • Lambda方式：
BiConsumer<String, String> notify = (friend, time) -> System.out.println(friend + " should be ready at " + time);
notify.accept("Alice", "8 PM");
06 BiFunction 接口
  • BiFunction：接受两个参数，返回一个结果，就像是基于两个输入生成一个输出。

例子：计算朋友聚会费用

  • 场景：你想计算每个朋友的聚会费用，根据他们吃的食物数量和单价。
  • 传统方式：
class PartyCostCalculator {
    public double calculateCost(int foodQuantity, double pricePerItem) {
        return foodQuantity * pricePerItem;
    }
}

PartyCostCalculator calculator = new PartyCostCalculator();
double cost = calculator.calculateCost(3, 5.99);
System.out.println("Cost: $" + cost);
  • Lambda 方式：
BiFunction<Integer, Double, Double> calculateCost = (quantity, price) -> quantity * price;
double cost = calculateCost.apply(3, 5.99);
System.out.println("Cost: $" + cost);

总结

这些例子展示了如何通过日常生活中的场景来理解和使用Lambda函数式接口：

  • Consumer：就像通知或处理信息。
  • Supplier：就像请求或提供信息。
  • Predicate：就像做判断或筛选。
  • Function：就像转换或处理数据。
  • BiConsumer 和 BiFunction：处理两个输入的场景。

通过这些类比，你可以更形象地理解这些接口的作用，并在实际编程中灵活使用它们。

7. 流（Stream API）

7.1 理解 Stream

用于处理集合数据的 API，常与 Lambda 表达式结合使用。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().filter(x -> x % 2 == 0).mapToInt(x -> x).sum();

7.2 具体案例

理解和使用 Lambda 流（Stream API）可以类比为在现实生活中处理一系列物品或信息的流程。

01 图书馆书籍管理
  • 场景：你想从图书馆的藏书中筛选出所有计算机类书籍。
  • 传统方式：
List<Book> books = Arrays.asList(
    new Book("Java Programming", "Computer"),
    new Book("1984", "Fiction"),
    new Book("Algorithms", "Computer")
);

List<Book> computerBooks = new ArrayList<>();
for (Book book : books) {
    if ("Computer".equals(book.getCategory())) {
        computerBooks.add(book);
    }
}
  • 使用 Stream API：
List<Book> books = Arrays.asList(
    new Book("Java Programming", "Computer"),
    new Book("1984", "Fiction"),
    new Book("Algorithms", "Computer")
);

List<Book> computerBooks = books.stream()
                                .filter(book -> "Computer".equals(book.getCategory()))
                                .collect(Collectors.toList());
02 咖啡店订单处理
  • 场景：你想找出所有价格超过5美元的咖啡订单。
  • 传统方式：
List<Order> orders = Arrays.asList(
    new Order("Espresso", 3.5),
    new Order("Latte", 4.5),
    new Order("Mocha", 6.0)
);

List<Order> expensiveOrders = new ArrayList<>();
for (Order order : orders) {
    if (order.getPrice() > 5) {
        expensiveOrders.add(order);
    }
}
  • 使用 Stream API：
List<Order> orders = Arrays.asList(
    new Order("Espresso", 3.5),
    new Order("Latte", 4.5),
    new Order("Mocha", 6.0)
);

List<Order> expensiveOrders = orders.stream()
                                    .filter(order -> order.getPrice() > 5)
                                    .collect(Collectors.toList());
03 学生成绩分析
  • 场景：你想找出所有及格的学生，并计算他们的平均分。
  • 传统方式：
List<Student> students = Arrays.asList(
    new Student("Alice", 85),
    new Student("Bob", 70),
    new Student("Charlie", 60)
);

List<Student> passedStudents = new ArrayList<>();
double sum = 0;
int count = 0;
for (Student student : students) {
    if (student.getScore() >= 60) {
        passedStudents.add(student);
        sum += student.getScore();
        count++;
    }
}
double average = count > 0 ? sum / count : 0;
  • 使用 Stream API：
List<Student> students = Arrays.asList(
    new Student("Alice", 85),
    new Student("Bob", 70),
    new Student("Charlie", 60)
);

double average = students.stream()
                         .filter(student -> student.getScore() >= 60)
                         .mapToInt(Student::getScore)
                         .average()
                         .orElse(0);
04 文件系统搜索
  • 场景：你想找出某个目录下所有大于 1MB 的文件。
  • 传统方式：
File directory = new File("/path/to/directory");
File[] files = directory.listFiles();
List<File> largeFiles = new ArrayList<>();
for (File file : files) {
    if (file.isFile() && file.length() > 1_000_000) {
        largeFiles.add(file);
    }
}
  • 使用 Stream API：
File directory = new File("/path/to/directory");
List<File> largeFiles = Arrays.stream(directory.listFiles())
                              .filter(File::isFile)
                              .filter(file -> file.length() > 1_000_000)
                              .collect(Collectors.toList());
05 数据清洗和转换
  • 场景：你有一组字符串数据，想去掉空格并转换成大写。
  • 传统方式：
List<String> data = Arrays.asList("  hello  ", "  world  ", "  java  ");

List<String> cleanedData = new ArrayList<>();
for (String s : data) {
    cleanedData.add(s.trim().toUpperCase());
}
  • 使用 Stream API：
List<String> data = Arrays.asList("  hello  ", "  world  ", "  java  ");

List<String> cleanedData = data.stream()
                               .map(String::trim)
                               .map(String::toUpperCase)
                               .collect(Collectors.toList());
总结

这些例子展示了如何通过日常生活中的场景来理解和使用Stream API：

  • 图书馆书籍管理：筛选特定类别的书籍。
  • 咖啡店订单处理：找出满足条件的订单。
  • 学生成绩分析：过滤及格学生并计算平均分。
  • 文件系统搜索：查找满足条件的文件。
  • 数据清洗和转换：对数据进行清理和转换。

通过这些类比，你可以更形象地理解 Stream API 的作用：

  • 流就像是一条生产线，每个操作（如filter, map, collect）都是生产线上的一个工序。
  • Lambda表达式则定义了每个工序的具体操作。

Stream API 简化了数据处理，使得代码更加简洁、易读，并且可以更方便地进行并行处理。

8. Lambda 表达式与并行处理

8.1 理解并行流

利用多核处理器提高性能。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().filter(x -> x % 2 == 0).mapToInt(x -> x).sum();

8.2 具体案例

理解和使用 Lambda 表达式与并行处理，可以类比为在现实生活中进行大规模任务的分发和处理。

01 图书馆书籍分类
  • 场景：你有一大堆书籍需要分类到不同的架子上。
  • 传统方式（单线程处理）：
List<Book> books = Arrays.asList(
    new Book("Java Programming", "Computer"),
    new Book("1984", "Fiction"),
    new Book("Algorithms", "Computer")
);

Map<String, List<Book>> categorizedBooks = new HashMap<>();
for (Book book : books) {
    String category = book.getCategory();
    if (!categorizedBooks.containsKey(category)) {
        categorizedBooks.put(category, new ArrayList<>());
    }
    categorizedBooks.get(category).add(book);
}
  • 并行处理：
List<Book> books = Arrays.asList(
    new Book("Java Programming", "Computer"),
    new Book("1984", "Fiction"),
    new Book("Algorithms", "Computer")
);

Map<String, List<Book>> categorizedBooks = books.parallelStream()
                                                .collect(Collectors.groupingBy(Book::getCategory));
02 咖啡店订单处理
  • 场景：你有一大批订单需要快速处理。
  • 传统方式（单线程处理）：
List<Order> orders = Arrays.asList(
    new Order("Espresso", 3.5),
    new Order("Latte", 4.5),
    new Order("Mocha", 6.0)
);

double totalPrice = 0;
for (Order order : orders) {
    totalPrice += order.getPrice();
}
  • 并行处理：
List<Order> orders = Arrays.asList(
    new Order("Espresso", 3.5),
    new Order("Latte", 4.5),
    new Order("Mocha", 6.0)
);

double totalPrice = orders.parallelStream()
                          .mapToDouble(Order::getPrice)
                          .sum();
03 数据中心文件搜索
  • 场景：你需要在一个大型数据中心中搜索所有大于1GB的文件。
  • 传统方式（单线程处理）：
List<File> files = Arrays.asList(new File("file1"), new File("file2"), new File("file3"));

List<File> largeFiles = new ArrayList<>();
for (File file : files) {
    if (file.length() > 1_000_000_000) {
        largeFiles.add(file);
    }
}
  • 并行处理：
List<File> files = Arrays.asList(new File("file1"), new File("file2"), new File("file3"));

List<File> largeFiles = files.parallelStream()
                             .filter(file -> file.length() > 1_000_000_000)
                             .collect(Collectors.toList());
04 社交网络用户分析
  • 场景：你需要分析数百万用户的数据，找出活跃用户。
  • 传统方式（单线程处理）：
List<User> users = Arrays.asList(
    new User("Alice", 100), // 活跃度
    new User("Bob", 20),
    new User("Charlie", 500)
);

List<User> activeUsers = new ArrayList<>();
for (User user : users) {
    if (user.getActivity() > 100) {
        activeUsers.add(user);
    }
}
  • 并行处理：
List<User> users = Arrays.asList(
    new User("Alice", 100),
    new User("Bob", 20),
    new User("Charlie", 500)
);

List<User> activeUsers = users.parallelStream()
                              .filter(user -> user.getActivity() > 100)
                              .collect(Collectors.toList());
05 数据清洗和分析
  • 场景：你有一大批数据需要清洗并进行统计分析。
  • 传统方式（单线程处理）：
List<String> data = Arrays.asList("  hello  ", "  world  ", "  java  ");

List<String> cleanedData = new ArrayList<>();
for (String s : data) {
    cleanedData.add(s.trim().toUpperCase());
}

int count = 0;
for (String s : cleanedData) {
    if (s.contains("O")) {
        count++;
    }
}
  • 并行处理：
List<String> data = Arrays.asList("  hello  ", "  world  ", "  java  ");

long count = data.parallelStream()
                 .map(String::trim)
                 .map(String::toUpperCase)
                 .filter(s -> s.contains("O"))
                 .count();
总结

这些例子展示了如何通过日常生活中的场景来理解和使用Lambda表达式与并行处理：

  • 图书馆书籍分类：并行处理可以加速分类过程。
  • 咖啡店订单处理：快速计算总价。
  • 数据中心文件搜索：并行搜索大文件。
  • 社交网络用户分析：快速找出活跃用户。
  • 数据清洗和分析：并行清洗数据并进行统计。

通过这些类比，你可以更形象地理解：

  • 并行流（parallelStream）就像是多个工人同时处理任务，而不是一个接一个地处理。
  • Lambda表达式定义了每个任务的具体操作。

并行处理通过分发任务到多个处理单元（如CPU核心），可以显著提高大规模数据处理的效率。特别是在处理大量数据时，Lambda表达式与并行流的结合可以极大地提升程序的性能。

9. Lambda 表达式与异常

9.1 Lambda 异常处理

Lambda 表达式中处理异常需要使用 try-catch 块。

Runnable r = () -> {
    try {
        // 代码可能抛出异常
    } catch (Exception e) {
        // 异常处理
    }
};

9.2 具体案例

理解和使用 Lambda 表达式与异常处理，可以类比为在日常生活中处理突发情况或错误。

01 图书馆书籍借阅
  • 场景：你想借一本书，但可能书不在库存中。
  • 传统方式（使用try-catch）：
class Library {
    public Book borrowBook(String title) throws BookNotFoundException {
        // 模拟借书过程
        if (!books.contains(title)) {
            throw new BookNotFoundException("Book not found: " + title);
        }
        return new Book(title);
    }
}

// 使用
try {
    Book book = library.borrowBook("Java Programming");
    System.out.println("Borrowed: " + book.getTitle());
} catch (BookNotFoundException e) {
    System.out.println("Error: " + e.getMessage());
}
  • Lambda方式（异常处理在Lambda内部）：
Optional<Book> book = Optional.ofNullable(library.borrowBook("Java Programming"))
                              .map(b -> {
                                  try {
                                      return b;
                                  } catch (BookNotFoundException e) {
                                      System.out.println("Error: " + e.getMessage());
                                      return null;
                                  }
                              });

book.ifPresent(b -> System.out.println("Borrowed: " + b.getTitle()));
02 网络请求处理
  • 场景：你想从多个 API 获取数据，但这些请求可能失败。
  • 传统方式：
List<String> apiUrls = Arrays.asList("api1", "api2", "api3");

for (String url : apiUrls) {
    try {
        String response = fetchDataFromAPI(url);
        System.out.println("Data from " + url + ": " + response);
    } catch (IOException e) {
        System.out.println("Failed to fetch data from " + url + ": " + e.getMessage());
    }
}
  • Lambda 方式：
List<String> apiUrls = Arrays.asList("api1", "api2", "api3");

apiUrls.forEach(url -> {
    try {
        String response = fetchDataFromAPI(url);
        System.out.println("Data from " + url + ": " + response);
    } catch (IOException e) {
        System.out.println("Failed to fetch data from " + url + ": " + e.getMessage());
    }
});
03 文件读取
  • 场景：你想读取多个文件的内容，但某些文件可能无法读取。
  • 传统方式：
List<String> filePaths = Arrays.asList("file1.txt", "file2.txt", "file3.txt");

for (String path : filePaths) {
    try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println("Line from " + path + ": " + line);
        }
    } catch (IOException e) {
        System.out.println("Failed to read " + path + ": " + e.getMessage());
    }
}
  • Lambda方式：
List<String> filePaths = Arrays.asList("file1.txt", "file2.txt", "file3.txt");

filePaths.forEach(path -> {
    try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println("Line from " + path + ": " + line);
        }
    } catch (IOException e) {
        System.out.println("Failed to read " + path + ": " + e.getMessage());
    }
});
04 数据转换与异常
  • 场景：你想将一组字符串转换为整数，但某些字符串可能不是有效的数字。
  • 传统方式：
List<String> numbers = Arrays.asList("1", "2", "three", "4");

List<Integer> intNumbers = new ArrayList<>();
for (String num : numbers) {
    try {
        intNumbers.add(Integer.parseInt(num));
    } catch (NumberFormatException e) {
        System.out.println("Invalid number: " + num);
    }
}
  • Lambda方式：
List<String> numbers = Arrays.asList("1", "2", "three", "4");

List<Integer> intNumbers = numbers.stream()
                                  .map(num -> {
                                      try {
                                          return Integer.parseInt(num);
                                      } catch (NumberFormatException e) {
                                          System.out.println("Invalid number: " + num);
                                          return null;
                                      }
                                  })
                                  .filter(Objects::nonNull)
                                  .collect(Collectors.toList());
总结

这些例子展示了如何通过日常生活中的场景来理解和使用Lambda表达式与异常处理：

  • 图书馆书籍借阅：处理书籍可能不存在的情况。
  • 网络请求处理：处理网络请求可能失败的情况。
  • 文件读取：处理文件可能无法读取的情况。
  • 数据转换与异常：处理数据转换过程中可能出现的异常。

通过这些类比，你可以更形象地理解：

  • Lambda表达式可以直接包含异常处理

10. Lambda 总结

  • 基础：理解Lambda表达式是什么。
  • 语法：掌握Lambda表达式的写法。
  • 函数式接口：知道Lambda表达式常与哪些接口一起使用。
  • 使用场景：如何在实际代码中应用Lambda表达式。
  • 方法引用：简化Lambda表达式的写法。
  • Stream API：结合Lambda表达式进行数据处理。
  • 并行处理：利用Lambda表达式提高程序效率。
  • 异常处理：在Lambda表达式中如何处理异常。

通过这些步骤，你可以从零基础逐步理解和掌握 Lambda 表达式的使用。记住，实践是最好的学习方式，尝试在你的项目中使用 Lambda 表达式来加深理解。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

Copyright © 2019- 版权所有

Top