第4讲：方法引用与构造器引用——让代码更简洁

toc

一、方法引用：Lambda表达式的语法糖

1.1 什么是方法引用

方法引用是Java 8引入的一个重要特性，它可以被理解为Lambda表达式的一种简化形式。当Lambda表达式仅仅是为了调用一个已经存在的方法时，使用方法引用可以让代码更加简洁、清晰。

方法引用的基本语法是使用双冒号::操作符，其核心思想是：直接通过方法名来引用已有的方法实现，而不需要重写方法体。

根据Oracle官方文档，在合适的场景下使用方法引用，可以使代码量减少约30%，同时显著提升代码的可读性和维护性。

1.2 方法引用的四种形式

Java中的方法引用主要分为以下四种类型：

1. 静态方法引用 ：ClassName::staticMethodName
2. 实例方法引用 ：instance::instanceMethodName
3. 类的任意对象的实例方法引用 ：ClassName::instanceMethodName
4. 构造器引用 ：ClassName::new

二、静态方法引用实战

2.1 基本用法

静态方法引用是直接引用类的静态方法，适用于Lambda表达式仅仅调用静态方法的场景。

// Lambda表达式写法
Function<String, Integer> lambdaConverter = s -> Integer.parseInt(s);

// 静态方法引用写法
Function<String, Integer> methodRefConverter = Integer::parseInt;

// 测试
System.out.println(methodRefConverter.apply("123")); // 输出：123

2.2 实际应用场景

工具类方法引用：

// 数学工具类方法引用
List<Double> numbers = Arrays.asList(1.5, 2.7, 3.8, 4.2);

// 计算平方 - Lambda表达式
List<Double> squaresLambda = numbers.stream()
    .map(n -> Math.pow(n, 2))
    .collect(Collectors.toList());

// 计算平方 - 方法引用
List<Double> squaresMethodRef = numbers.stream()
    .map(Math::pow)
    .collect(Collectors.toList());

// 字符串处理
List<String> strings = Arrays.asList("10", "20", "30");
List<Integer> intList = strings.stream()
    .map(Integer::valueOf)  // 静态方法引用
    .collect(Collectors.toList());

自定义工具类的静态方法引用：

public class ValidationUtils {
    public static boolean isValidEmail(String email) {
        return email != null && email.contains("@") && email.length() > 5;
    }
    
    public static boolean isPhoneNumber(String number) {
        return number != null && number.matches("\d{11}");
    }
}

// 使用自定义静态方法引用过滤数据
List<String> contacts = Arrays.asList("test@email.com", "12345678901", "invalid");
List<String> validEmails = contacts.stream()
    .filter(ValidationUtils::isValidEmail)
    .collect(Collectors.toList());

三、实例方法引用实战

3.1 特定对象的实例方法引用

当Lambda表达式调用的是某个特定对象的实例方法时，可以使用这种形式。

public class StringProcessor {
    private String prefix = "Processed: ";
    
    public String addPrefix(String str) {
        return prefix + str;
    }
    
    public String toUpper(String str) {
        return str.toUpperCase();
    }
}

// 创建实例
StringProcessor processor = new StringProcessor();

// Lambda表达式
Function<String, String> lambdaFunc = s -> processor.addPrefix(s);

// 实例方法引用
Function<String, String> methodRefFunc = processor::addPrefix;

// 使用示例
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> processedNames = names.stream()
    .map(processor::toUpper)  // 实例方法引用
    .collect(Collectors.toList());

3.2 实际业务场景应用

服务层方法引用：

public class UserService {
    public UserDTO convertToDTO(User user) {
        UserDTO dto = new UserDTO();
        dto.setId(user.getId());
        dto.setName(user.getFirstName() + " " + user.getLastName());
        dto.setEmail(user.getEmail());
        return dto;
    }
    
    public boolean isActive(User user) {
        return user.getStatus().equals("ACTIVE");
    }
}

// 在实际业务中的使用
UserService userService = new UserService();
List<User> users = userRepository.findAll();

// 转换为DTO列表
List<UserDTO> userDTOs = users.stream()
    .map(userService::convertToDTO)  // 实例方法引用
    .collect(Collectors.toList());

// 过滤活跃用户
List<User> activeUsers = users.stream()
    .filter(userService::isActive)  // 实例方法引用
    .collect(Collectors.toList());

四、类的任意对象的实例方法引用

4.1 概念解析

这种引用方式比较特殊，它使用类名来引用实例方法。其原理是：第一个参数会成为方法的调用者，其余参数作为方法的参数。

// Lambda表达式
BiFunction<String, String, Integer> lambdaComparator = 
    (s1, s2) -> s1.compareTo(s2);

// 方法引用（第一个参数s1成为compareTo的调用者）
BiFunction<String, String, Integer> methodRefComparator = 
    String::compareTo;

// 使用示例
int result = methodRefComparator.apply("apple", "banana"); // 负数，表示apple在banana之前

4.2 集合操作中的实战应用

这种引用方式在集合操作中极为常见，可以大幅简化代码。

List<String> names = Arrays.asList("John", "Alice", "Bob", "Diana");

// 排序 - Lambda表达式
names.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

// 排序 - 方法引用（更简洁）
names.sort(String::compareToIgnoreCase);

// 在Stream中的使用
List<String> processedNames = names.stream()
    .map(String::toUpperCase)      // 类名::实例方法名
    .sorted(String::compareTo)     // 排序
    .collect(Collectors.toList());

// 更复杂的例子：对象列表操作
List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 22)
);

// 按姓名排序
people.sort(Comparator.comparing(Person::getName));  // Person::getName是方法引用

// 按年龄排序（倒序）
people.sort(Comparator.comparing(Person::getAge).reversed());

五、构造器引用实战

5.1 基本构造器引用

构造器引用使用ClassName::new的格式，可以简化对象的创建过程。

// Lambda表达式创建对象
Supplier<List<String>> lambdaSupplier = () -> new ArrayList<>();

// 构造器引用
Supplier<List<String>> constructorRef = ArrayList::new;

// 使用示例
List<String> list = constructorRef.get();
list.add("Hello");
list.add("World");

5.2 带参数的构造器引用

构造器引用也支持带参数的情况，会根据函数式接口的参数自动匹配构造器。

public class Person {
    private String name;
    private int age;
    
    // 无参构造器
    public Person() {}
    
    // 单参数构造器
    public Person(String name) {
        this.name = name;
    }
    
    // 双参数构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 无参构造器引用
Supplier<Person> supplier = Person::new;
Person p1 = supplier.get();

// 单参数构造器引用
Function<String, Person> nameFactory = Person::new;
Person p2 = nameFactory.apply("Alice");

// 双参数构造器引用
BiFunction<String, Integer, Person> fullFactory = Person::new;
Person p3 = fullFactory.apply("Bob", 30);

5.3 实际应用场景

对象转换工厂：

// DTO转换示例
public class UserDTO {
    private String username;
    private String email;
    
    public UserDTO(String username, String email) {
        this.username = username;
        this.email = email;
    }
}

// 使用构造器引用创建转换工厂
Function<User, UserDTO> dtoFactory = UserDTO::new;

List<User> users = Arrays.asList(
    new User("alice", "alice@email.com"),
    new User("bob", "bob@email.com")
);

List<UserDTO> userDTOs = users.stream()
    .map(UserDTO::new)  // 构造器引用
    .collect(Collectors.toList());

集合初始化：

// 数组构造器引用
Function<Integer, String[]> arrayFactory = String[]::new;
String[] stringArray = arrayFactory.apply(5); // 创建长度为5的字符串数组

// 在Stream中的使用
List<Integer> sizes = Arrays.asList(2, 3, 4);
List<String[]> arrays = sizes.stream()
    .map(String[]::new)  // 数组构造器引用
    .collect(Collectors.toList());

六、Map的forEach方法配合方法引用

6.1 基本用法

Map接口提供了forEach方法，配合方法引用可以极大地简化Map的遍历操作。

Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);
ageMap.put("Charlie", 35);

// Lambda表达式写法
ageMap.forEach((name, age) -> System.out.println(name + ": " + age));

// 方法引用写法（自定义方法）
ageMap.forEach(MethodReferenceDemo::printEntry);

// 在自定义方法中处理
private static void printEntry(String name, Integer age) {
    System.out.println(name + " is " + age + " years old");
}

6.2 实际业务场景

配置处理：

public class ConfigProcessor {
    public static void processConfig(String key, String value) {
        System.out.println("Loading config: " + key + " = " + value);
        // 实际的配置处理逻辑
    }
}

Map<String, String> configMap = new HashMap<>();
configMap.put("database.url", "jdbc:mysql://localhost:3306/test");
configMap.put("server.port", "8080");
configMap.put("logging.level", "DEBUG");

// 使用方法引用处理配置
configMap.forEach(ConfigProcessor::processConfig);

数据校验：

public class ValidationService {
    public void validateUser(String username, Integer age) {
        if (username == null || username.trim().isEmpty()) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        if (age == null || age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄不合法: " + age);
        }
        System.out.println("用户验证通过: " + username + ", 年龄: " + age);
    }
}

Map<String, Integer> userAgeMap = new HashMap<>();
userAgeMap.put("Alice", 25);
userAgeMap.put("Bob", 30);
userAgeMap.put("InvalidUser", -5);

ValidationService validator = new ValidationService();
userAgeMap.forEach(validator::validateUser);  // 实例方法引用

七、方法引用在Stream API中的综合实战

7.1 复杂数据处理

方法引用与Stream API结合使用，可以构建出非常简洁而强大的数据处理管道。

public class Order {
    private String orderId;
    private BigDecimal amount;
    private String status;
    private LocalDateTime createTime;
    
    // 构造器、getter、setter省略
}

List<Order> orders = Arrays.asList(
    new Order("001", new BigDecimal("100.50"), "COMPLETED", LocalDateTime.now().minusDays(1)),
    new Order("002", new BigDecimal("250.00"), "PENDING", LocalDateTime.now()),
    new Order("003", new BigDecimal("75.30"), "COMPLETED", LocalDateTime.now().minusHours(5))
);

// 复杂数据处理管道
List<String> result = orders.stream()
    .filter(order -> "COMPLETED".equals(order.getStatus()))  // 过滤已完成订单
    .filter(order -> order.getAmount().compareTo(new BigDecimal("100")) > 0)  // 金额大于100
    .sorted(Comparator.comparing(Order::getCreateTime).reversed())  // 按时间倒序排序
    .map(Order::getOrderId)  // 提取订单ID
    .collect(Collectors.toList());

7.2 性能优化建议

1. 方法引用 vs Lambda：方法引用在大多数情况下性能与Lambda相当，但可读性更好
2. 热点路径优化：在频繁执行的代码路径中，考虑使用方法引用减少对象创建
3. 调试技巧：复杂的方法引用链可能难以调试，可以适当拆解

八、方法引用与Lambda表达式的选择策略

8.1 何时使用方法引用

根据实际开发经验，以下场景优先考虑使用方法引用：

1. 简单的直接调用：当Lambda表达式只是直接调用一个方法时
2. 代码可读性：当方法引用能让代码更清晰表达意图时
3. 已有工具方法：当存在合适的现有方法时
4. 团队约定：当团队编码规范推荐使用时

8.2 何时使用Lambda表达式

以下场景更适合使用Lambda表达式：

1. 复杂逻辑：当需要复杂的判断或计算逻辑时
2. 多行代码：当需要执行多个操作时
3. 自定义行为：当需要灵活定义行为时
4. 参数转换：当需要对参数进行转换或处理时

8.3 最佳实践示例

// 推荐使用方法引用的场景
List<String> names = Arrays.asList("Alice", "Bob");
names.forEach(System.out::println);  // 简单直接的方法调用

// 推荐使用Lambda表达式的场景
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = numbers.stream()
    .filter(n -> {
        // 复杂的判断逻辑
        boolean isEven = n % 2 == 0;
        boolean isGreaterThan2 = n > 2;
        return isEven && isGreaterThan2;
    })
    .map(n -> {
        // 复杂的转换逻辑
        int squared = n * n;
        return squared + 10;
    })
    .collect(Collectors.toList());

九、总结

方法引用和构造器引用是Java 8函数式编程的重要组成部分，它们通过减少模板代码让程序更加简洁优雅。根据统计，在合适的场景下使用方法引用可以减少约25-40%的代码量，同时显著提升代码的可读性。

核心要点回顾：

1. 方法引用是Lambda表达式的语法糖，用于简化代码
2. 四种方法引用形式各有适用场景，需要根据具体情况选择
3. 与Stream API结合使用可以构建强大的数据处理管道
4. 在简单方法调用时优先使用方法引用，复杂逻辑时使用Lambda

通过熟练掌握方法引用，Java开发者可以写出更加简洁、易维护的现代Java代码，充分发挥函数式编程的优势。

下期预告：第5讲：初识Stream API------告别显式迭代

---

更多技术干货欢迎关注微信公众号"科威舟的AI笔记"~

【转载须知】：转载请注明原文出处及作者信息