Java Lambda表达式案例怎么写

本文目录导读：

1. Lambda表达式基础案例
2. 实际开发常用案例
3. 多线程案例
4. 综合实战案例
5. Lambda表达式常见用法速查表

我来给你提供一个Lambda表达式的详细案例教程,从基础到进阶。

Lambda表达式基础案例

最简单的Lambda表达式

// 传统方式 vs Lambda方式
// 1. 无参无返回值
// 传统方式
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("传统方式");
    }
};
// Lambda方式
Runnable runnable2 = () -> System.out.println("Lambda方式");
// 2. 有参有返回值
// 传统方式
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
};
// Lambda方式
Comparator<Integer> comparator2 = (o1, o2) -> o1.compareTo(o2);

函数式接口案例

// 自定义函数式接口
@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}
// 使用示例
public class LambdaExample {
    public static void main(String[] args) {
        // 加法
        MathOperation addition = (a, b) -> a + b;
        // 减法
        MathOperation subtraction = (a, b) -> a - b;
        // 乘法
        MathOperation multiplication = (a, b) -> a * b;
        // 除法
        MathOperation division = (a, b) -> {
            if (b == 0) {
                throw new ArithmeticException("除数不能为0");
            }
            return a / b;
        };
        System.out.println("10 + 5 = " + operate(10, 5, addition));
        System.out.println("10 - 5 = " + operate(10, 5, subtraction));
        System.out.println("10 * 5 = " + operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + operate(10, 5, division));
    }
    private static int operate(int a, int b, MathOperation operation) {
        return operation.operate(a, b);
    }
}

实际开发常用案例

集合遍历

import java.util.Arrays;
import java.util.List;
public class CollectionLambda {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "Python", "JavaScript", "C++");
        // 传统遍历
        for (String item : list) {
            System.out.println(item);
        }
        // Lambda遍历
        list.forEach(item -> System.out.println(item));
        // 方法引用
        list.forEach(System.out::println);
    }
}

集合过滤和排序

import java.util.*;
import java.util.stream.Collectors;
public class FilterAndSortLambda {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 6, 3, 8, 2, 9, 4, 7, 5);
        // 过滤偶数并排序
        List<Integer> sortedEvenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)           // 过滤偶数
                .sorted((a, b) -> a.compareTo(b))  // 排序
                .collect(Collectors.toList());      // 收集结果
        System.out.println("排序后的偶数: " + sortedEvenNumbers);
        // 将集合中的元素转换为大写
        List<String> names = Arrays.asList("alice", "bob", "charlie");
        List<String> upperNames = names.stream()
                .map(name -> name.toUpperCase())
                .collect(Collectors.toList());
        System.out.println("大写名称: " + upperNames);
    }
}

对象集合操作

import java.util.*;
import java.util.stream.Collectors;
class Student {
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    // getter和setter方法
    public String getName() { return name; }
    public int getAge() { return age; }
    public int getScore() { return score; }
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + ", score=" + score + "}";
    }
}
public class ObjectLambda {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("张三", 20, 85),
            new Student("李四", 22, 92),
            new Student("王五", 19, 78),
            new Student("赵六", 21, 95)
        );
        // 1. 按成绩排序
        List<Student> sortedByScore = students.stream()
                .sorted((s1, s2) -> Integer.compare(s2.getScore(), s1.getScore()))
                .collect(Collectors.toList());
        System.out.println("按成绩排序: " + sortedByScore);
        // 2. 筛选成绩大于80的学生
        List<Student> excellentStudents = students.stream()
                .filter(s -> s.getScore() > 80)
                .collect(Collectors.toList());
        System.out.println("优秀学生: " + excellentStudents);
        // 3. 计算平均分
        double averageScore = students.stream()
                .mapToInt(Student::getScore)
                .average()
                .orElse(0);
        System.out.println("平均分: " + averageScore);
        // 4. 获取所有学生姓名
        List<String> names = students.stream()
                .map(Student::getName)
                .collect(Collectors.toList());
        System.out.println("学生姓名: " + names);
    }
}

多线程案例

import java.util.concurrent.*;
public class ThreadLambda {
    public static void main(String[] args) {
        // 1. 创建线程
        new Thread(() -> System.out.println("Lambda线程")).start();
        // 2. Callable接口
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Callable<Integer> task = () -> {
            Thread.sleep(1000);
            return 100;
        };
        Future<Integer> future = executor.submit(task);
        try {
            Integer result = future.get();  // 等待结果
            System.out.println("计算结果: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

综合实战案例

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
public class RealWorldLambda {
    public static void main(String[] args) {
        // 模拟订单数据
        List<Order> orders = createOrders();
        // 1. 统计本月已完成订单的总金额
        double monthlyRevenue = orders.stream()
                .filter(order -> order.getStatus() == OrderStatus.COMPLETED)
                .filter(order -> order.getCreateTime().getMonth() == LocalDateTime.now().getMonth())
                .mapToDouble(Order::getAmount)
                .sum();
        System.out.println("本月已完成订单总额: " + monthlyRevenue);
        // 2. 获取前5个最贵的订单
        List<Order> top5Orders = orders.stream()
                .sorted((o1, o2) -> Double.compare(o2.getAmount(), o1.getAmount()))
                .limit(5)
                .collect(Collectors.toList());
        System.out.println("最贵的5个订单: " + top5Orders);
        // 3. 按状态分组统计
        Map<OrderStatus, Long> orderCountByStatus = orders.stream()
                .collect(Collectors.groupingBy(Order::getStatus, Collectors.counting()));
        System.out.println("订单状态统计: " + orderCountByStatus);
        // 4. 找出最大的订单ID
        Optional<Long> maxOrderId = orders.stream()
                .map(Order::getId)
                .reduce(Long::max);
        maxOrderId.ifPresent(id -> System.out.println("最大订单ID: " + id));
    }
    static List<Order> createOrders() {
        return Arrays.asList(
            new Order(1L, "张三", 100.0, OrderStatus.COMPLETED, LocalDateTime.now()),
            new Order(2L, "李四", 200.0, OrderStatus.PENDING, LocalDateTime.now()),
            new Order(3L, "王五", 150.0, OrderStatus.COMPLETED, LocalDateTime.now()),
            new Order(4L, "赵六", 300.0, OrderStatus.CANCELLED, LocalDateTime.now()),
            new Order(5L, "孙七", 250.0, OrderStatus.COMPLETED, LocalDateTime.now())
        );
    }
}
enum OrderStatus {
    PENDING, COMPLETED, CANCELLED
}
class Order {
    private Long id;
    private String customerName;
    private double amount;
    private OrderStatus status;
    private LocalDateTime createTime;
    // 构造方法
    public Order(Long id, String customerName, double amount, OrderStatus status, LocalDateTime createTime) {
        this.id = id;
        this.customerName = customerName;
        this.amount = amount;
        this.status = status;
        this.createTime = createTime;
    }
    // getter方法
    public Long getId() { return id; }
    public String getCustomerName() { return customerName; }
    public double getAmount() { return amount; }
    public OrderStatus getStatus() { return status; }
    public LocalDateTime getCreateTime() { return createTime; }
    @Override
    public String toString() {
        return "Order{id=" + id + ", customer='" + customerName + "', amount=" + amount + "}";
    }
}

Lambda表达式常见用法速查表

这些案例覆盖了Lambda表达式的常见使用场景,建议你动手实践每个示例，加深理解。