深入理解 Java 的方法引用（Method Reference）_symbol: method setpredictiveamd(java.lang.string)-优快云博客

// Lambda表达式
List<String> names = Arrays.asList("Alice", "Bob");
names.forEach(name -> System.out.println(name));

// 等价的方法引用
names.forEach(System.out::println);

核心原理：方法引用会被编译器转换为对应的函数式接口实现，与 Lambda 表达式在运行时等价，但语法更简洁且语义更清晰。

二、四种方法引用类型：全面解析与应用场景

1. 静态方法引用（Class::staticMethod）

引用类的静态方法，适用于函数式接口参数与静态方法参数匹配的场景：

// 案例：使用Integer::parseInt替代Lambda
Function<String, Integer> parser1 = s -> Integer.parseInt(s);  // Lambda
Function<String, Integer> parser2 = Integer::parseInt;        // 方法引用

// 场景：数值转换、工具方法调用
List<String> numberStrings = Arrays.asList("1", "2", "3");
List<Integer> numbers = numberStrings.stream()
    .map(Integer::parseInt)
    .collect(Collectors.toList());

2. 实例方法引用（instance::instanceMethod）

引用对象的实例方法，要求函数式接口的第一个参数是实例方法的调用者：

// 案例：String的length()方法引用
Predicate<String> nonEmpty1 = s -> s.length() > 0;  // Lambda
Predicate<String> nonEmpty2 = String::length;       // 方法引用？不，正确写法是：
Predicate<String> nonEmpty3 = s -> s.length() > 0;  // 实际应写作：
Predicate<String> nonEmpty4 = s -> s.length() > 0;  // 注意：实例方法引用的正确形式需匹配参数列表
// 正确示例：已有String实例的方法引用
String str = "test";
Supplier<Integer> lengthSupplier = str::length;     // 无参数，返回str.length()

正确用法：当函数式接口参数为实例方法的操作对象时：

List<String> names = Arrays.asList("a", "bb", "ccc");
// 按字符串长度排序，引用String::compareTo
names.sort(String::compareTo);  // 等价于(a, b) -> a.compareTo(b)

3. 类的实例方法引用（Class::instanceMethod）

引用类的任意实例的方法，此时函数式接口的第一个参数作为方法的调用者：

// 案例：引用String的toLowerCase方法
Function<String, String> lower1 = s -> s.toLowerCase();  // Lambda
Function<String, String> lower2 = String::toLowerCase;    // 方法引用

// 场景：字符串转换、集合操作
List<String> upperNames = Arrays.asList("ALICE", "BOB");
List<String> lowerNames = upperNames.stream()
    .map(String::toLowerCase)
    .collect(Collectors.toList());

4. 构造器引用（Class::new）

引用类的构造方法，用于创建对象，匹配Supplier或Function等接口：

// 案例：创建String构造器引用
Supplier<String> strSupplier = String::new;  // 无参构造器
Function<String, String> strFunction = String::new;  // 单参数构造器（String s）

// 场景：对象批量创建
List<String> emptyStrings = Stream.generate(String::new)
    .limit(10)
    .collect(Collectors.toList());

// 复杂案例：自定义对象构造
class User {
    private String name;
    private int age;
    public User(String name, int age) { this.name = name; this.age = age; }
}
// 构造器引用匹配Function<String[], User>
Function<String[], User> userCreator = User::new;
User user = userCreator.apply(new String[] {"Alice", "25"});  // 注意：参数需与构造器匹配

三、方法引用与 Lambda 的选择原则

语义清晰度优先：当方法引用能更直观表达逻辑时（如System.out::println），优先使用；

参数匹配性：仅当方法的参数列表与函数式接口完全匹配时，才能使用方法引用：

// 反例：参数不匹配时无法使用方法引用
BiFunction<String, Integer, String> concat1 = (s, i) -> s + i;  // Lambda
// 以下写法错误，因String::concat是单参数方法
BiFunction<String, Integer, String> concat2 = String::concat;  // 编译错误

复杂逻辑用 Lambda：涉及条件判断、局部变量访问等逻辑时，Lambda 表达式更灵活；
性能无差异：方法引用与 Lambda 在编译后生成的字节码结构相同，运行时性能一致。

四、高级应用：方法引用与 Stream API 的深度结合

1. 集合操作中的方法引用

// 案例：过滤非空字符串并转为大写
List<String> strings = Arrays.asList("a", null, "b");
List<String> upperCase = strings.stream()
    .filter(Objects::nonNull)  // 引用静态方法Objects::nonNull
    .map(String::toUpperCase)  // 引用实例方法
    .collect(Collectors.toList());

2. 与 Comparator 结合的排序优化

// 案例：按对象属性排序
class Person {
    private String name;
    private int age;
    public String getName() { return name; }
    public int getAge() { return age; }
}
List<Person> people = ...;
// 按年龄升序，年龄相同时按姓名升序
people.sort(Comparator.comparingInt(Person::getAge)
    .thenComparing(Person::getName));

3. 构造器引用与收集器结合

// 案例：将流元素收集为指定类型集合
List<String> names = Arrays.asList("Alice", "Bob");
// 用构造器引用指定收集结果为LinkedList
LinkedList<String> linkedNames = names.stream()
    .collect(Collectors.toCollection(LinkedList::new));

五、底层实现：方法引用的字节码解析

通过javap -c反编译方法引用代码，可发现其本质是生成invokestatic/invokevirtual指令：

// 方法引用代码
Stream.of(1, 2, 3).forEach(System.out::println);

// 反编译结果（关键部分）
...
 invokedynamic #2,  0              // InvokeDynamic #0:forEach:()V
...

InvokeDynamic指令会在运行时动态绑定方法引用对应的函数式接口实现，与 Lambda 表达式的编译结果一致。

六、常见误区与避坑指南

实例方法引用的参数顺序：
错误认为Class::method等同于(x) -> x.method()，实际需函数式接口的参数与方法参数完全匹配：
```
// 正确：BiFunction的两个参数作为String::compareTo的两个参数
BiFunction<String, String, Integer> comp = String::compareTo;
```

构造器引用的参数匹配：
必须严格匹配构造器的参数类型，例如：

// 错误：User构造器需要(String, int)，但Function参数为(String, String)
Function<String, String, User> invalid = User::new;  // 编译错误
// 正确：
BiFunction<String, Integer, User> valid = User::new;