0Pricing
Java Academy · 课时

任意实例的方法引用

引用实例方法而不指定接收者，这种方式广泛用于 Stream 操作

任意实例的方法引用 是 CoddyKit 上的免费 Java Academy 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

什么是任意实例引用

任意实例方法引用使用 ClassName::instanceMethod。在这里，函数式接口的第一个参数充当接收者——每个元素都会成为调用方法的对象。

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("alice","bob","carol");

// String::toUpperCase — receiver is each list element
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(upper); // [ALICE, BOB, CAROL]

如何解析接收者

对于任意实例引用 Type::method，函数式接口的第一个参数会成为 this（即接收者）：

// String::length matches Function<String, Integer>
// Equivalent to: s -> s.length()
Function<String, Integer> len = String::length;
System.out.println(len.apply("Java")); // 4

// String::isEmpty matches Predicate<String>
// Equivalent to: s -> s.isEmpty()
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test(""));   // true

广泛用于流操作

任意实例引用是流处理流水线中最常见的类型：

List<String> words = List.of("Hello","","World","","Java");

// filter with String::isEmpty
long empty = words.stream().filter(String::isEmpty).count();
System.out.println(empty); // 2

// map with String::toLowerCase
words.stream()
     .filter(s -> !s.isEmpty())
     .map(String::toLowerCase)
     .forEach(System.out::println);

双参数方法的 BiFunction 形式

类型上的双参数方法匹配 BiFunction<T, U, R>，其中 T 是接收者，U 是参数：

import java.util.function.*;

// String::startsWith → BiPredicate<String, String>
// receiver=first arg, argument=second arg
BiPredicate<String, String> starts = String::startsWith;
System.out.println(starts.test("JavaStream", "Java")); // true
System.out.println(starts.test("Python", "Java"));      // false

使用任意实例的比较器

String::compareTo 匹配 Comparator<String>——比较器的两个参数分别成为接收者和参数：

List<String> words = List.of("banana","apple","cherry");

List<String> sorted = words.stream()
    .sorted(String::compareTo)
    .collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]

自定义类的任意实例

它适用于任何类的实例方法，而不仅限于 JDK 类型：

record Product(String name, double price) {
    boolean isExpensive() { return price > 50; }
    String label() { return name + " ($" + price + ")"; }
}

List<Product> products = List.of(
    new Product("Widget", 9.99),
    new Product("Gadget", 99.99),
    new Product("Donut", 1.50)
);

products.stream()
    .filter(Product::isExpensive)
    .map(Product::label)
    .forEach(System.out::println); // Gadget ($99.99)

与特定实例的区别

关键区别如下：

  • 特定实例： obj::method——obj 始终是接收者
  • 任意实例： Type::method——每个元素都是接收者
String fixed = "prefix";
// Specific instance: fixed is always the receiver
Predicate<String> startsFixed = fixed::startsWith; // always checks 'prefix'.startsWith(arg)

// Arbitrary instance: each element is the receiver
Predicate<String> isEmpty = String::isEmpty; // each element.isEmpty()

集合器中的方法引用

任意实例引用可以自然地与集合器结合使用：

List<String> items = List.of("  hello "," world ","  java  ");
List<String> trimmed = items.stream()
    .map(String::trim)
    .collect(Collectors.toList());
System.out.println(trimmed); // [hello, world, java]

链接方法引用

方法引用可以通过函数接口上的 andThen/compose 进行链接：

Function<String, String> pipeline =
    ((Function<String, String>) String::trim)
        .andThen(String::toUpperCase);

System.out.println(pipeline.apply("  hello world  "));
// HELLO WORLD

陷阱：重载方法

当一个方法存在重载时，编译器必须推断哪个重载与函数式接口匹配。如果存在歧义，就会产生编译错误——请使用 lambda 消除歧义：

// println is overloaded — which one?
// Consumer<String> c = System.out::println; // OK — infers println(String)
// Consumer<Object> c2 = System.out::println; // OK

// But if ambiguous:
// Function<Object,?> fn = System.out::println; // Error — println doesn't return a value

性能

方法引用和 lambda 会编译为相同的字节码（通过 invokedynamic）。两者没有性能差异——请选择可读性更好的形式。当方法引用能够清晰表达意图时，大多数代码风格指南都更推荐使用它。

快速检查

在与 .map() 一起使用时，String::toUpperCase 表示什么？

回顾：任意实例的方法引用

要点：

  • 语法：ClassName::instanceMethod——每个元素都是接收者
  • 匹配接收者作为第一个参数的函数式接口
  • 最常用于 .map()、.filter()、.sorted() 和 .forEach()
  • 双参数方法 → BiFunction/BiPredicate，其中元素是接收者
  • 与 lambda 相比没有性能差异——根据可读性选择

常见问题解答

「任意实例的方法引用」课时是免费的吗？

是的 — 「任意实例的方法引用」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「任意实例的方法引用」这节课中我会学到什么？

引用实例方法而不指定接收者，这种方式广泛用于 Stream 操作 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「任意实例的方法引用」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 静态方法引用
  2. 特定实例上的实例方法引用
  3. 任意实例的方法引用
  4. 构造方法引用
← 返回 Java Academy