Was müssen Sie über funktionale Schnittstellen in Java 8 wissen?

Vorwort

Java 8 bietet viele funktionale Schnittstellen, einschließlich Funktion, Verbraucher, Lieferant, Prädikat usw. Sie befinden sich alle im Paket java.util.function. java.util.function 包下。

为什么需要知道这几个函数式接口

因为这 4 个函数式接口是 Java 8 中新增的重要接口，同时 Java 8 的 Stream 新特性，也有用到这些接口，所以学习它们可以帮助我们更好地理解 Stream 流。

也正因为这是函数式接口，所以就可以使用 Lambda 表达式来写接口的实现逻辑。而且学习的过程中可以更好地理解函数式编程的思想。

Function 接口

说明

Function 这个单词的意思就有「函数」的意思，就数学中的 y = f(x)，接收一个 x 参数，通过函数 f 运算后，返回一个结果 y。

Function 接口包含四个方法：

• apply(T t)：这是 Function 接口的主要方法，它接收一个参数并返回一个结果。同时它也是唯一的抽象的方法，剩下的都是有默认实现的（Java 8 中接口的抽象方法支持默认实现）。

• andThen(Function after)：作用是将两个 Function 组合。首先执行当前函数，再执行 andThen 函数，并将当前函数的结果作为参数传递给 andThen 函数。

• compose(Function before)：同理，将两个 Function 组合，将先执行 compose 函数，再执行当前函数，并将 compose 函数的结果作为参数传递给当前函数。

• identity(): 返回一个执行恒等转换的函数，即返回输入参数本身。

Function 接口通常用于将一个类型的值转换为另一个类型的值。

apply 方法

// Function 接口的泛型，第一个参数是入参类型，第二个参数是出参类型
// Function 接口只有一个抽象方法，就是 apply()，下面利用 Lambda 表达式实现这个抽象方法并创建 Function 对象
Function<Integer, String> function = num -> "GTA" + num;
// 将5这个参数传递给function，得到返回结果
String result = function.apply(5);
System.out.println(result); // 打印：GTA5

andThen 和 compose 方法

// 定义两个 Function 对象进行相关转换操作
Function<String, String> upperCase = s -> s.toUpperCase();
Function<String, String> addPostfix = s -> s + "5";
// 链式调用，将 gta 这个字符串参数先传递 upperCase 这个函数进行操作，然后将得到的结果传递给 addPostfix 函数进行操作，得到返回结果
String str = upperCase.andThen(addPostfix).apply("gta");
System.out.println(str); // 打印：GTA5

identify 方法

identity 方法返回一个执行恒等转换的函数，该函数将输入参数原样返回。例如：

Function<String, String> identity = Function.identity();
String result = identity.apply("hello"); // result is "hello"

Consumer 接口

说明

Consumer 这个单词的意思就有「消费者」的意思，就把入参消费了，并不会返回结果给你。

Consumer 接口包含两个方法：

• accept(T t)：该方法接受一个参数并执行一些操作。

• andThen(Consumer after)：同理，将两个 Consumer 组合，先后进行消费。

accept 方法

Consumer 接口通常用于消费一个参数然后执行一些操作。例如：

// Consumer 接口，泛型参数是入参类型，接受一个参数，并不返回结果，相当于消费了这个参数
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("我输入什么就打印什么"); // 打印：我输入什么就打印什么

andThen 方法

组合两个 Consumer：

Consumer<String> first = s -> System.out.println(s + 5);
Consumer<String> second = s -> System.out.println(s + 6);
// 先执行 first 这个 Consumer，接着执行 second 这个 Consumer
Consumer<String> combination = first.andThen(second);
combination.accept("GTA"); // 打印：GTA5 GTA6

Supplier 接口

Supplier 接口只定义了一个 get() 方法，该方法不接受任何参数并返回一个结果。

Supplier 这个单词的意思就有「供应者」的意思，给我的感觉就是生产者，不用参数，直接生产一个东西给你。

Supplier 接口通常用于生成一个值。例如：

// Supplier 接口，泛型参数是出参类型，不接受参数，但是会提供结果，相当于生产了某个东西
Supplier<String> supplier = () -> "提供一个我随便打的字符串给调用方";
String text = supplier.get();
System.out.println(text); // 打印：提供一个我随便打的字符串给调用方

Predicate 接口

说明

Predicate 这个单词的意思就有「预言，预测，谓语，谓词」的意思，就是用来预测判断的。

Predicate 接口包含四个方法：

• test(T t)：该方法接受一个参数并返回一个布尔值。

• and(Predicate other)：与另一个 Predicate 进行组合，实现逻辑与操作。

• negate()：与另一个 Predicate 进行组合，实现逻辑非操作。

• or(Predicate other)

  Warum Sie diese Funktionsschnittstellen kennen müssen

Da diese 4 Funktionsschnittstellen neue wichtige Schnittstellen in Java 8 sind,

Gleichzeitig verwenden auch die neuen Stream-Funktionen von Java 8 diese Schnittstellen

, sodass das Erlernen dieser Schnittstellen uns besser helfen kann ein gutes Verständnis von Stream-Streams.

Da es sich um eine funktionale Schnittstelle handelt, können Sie Lambda-Ausdrücke verwenden, um die Implementierungslogik der Schnittstelle zu schreiben. Und während des Lernprozesses können Sie die Ideen der funktionalen Programmierung besser verstehen.

Funktionsschnittstelle

Erklärung

Funktion bedeutet „Funktion“. In der Mathematik empfängt y = f(x) einen x-Parameter und gibt ein Ergebnis y zurück, nachdem es durch die Funktion f bedient wurde.

Function-Schnittstelle enthält vier Methoden:

apply(T t): Dies ist Funktion Die Hauptmethode der Schnittstelle, die einen Parameter empfängt und ein Ergebnis zurückgibt. Gleichzeitig ist es auch die einzige abstrakte Methode, und der Rest verfügt über Standardimplementierungen (die abstrakten Methoden der Schnittstellen in Java 8 unterstützen Standardimplementierungen).

andThen(Function after): Die Funktion besteht darin, zwei Funktionen zu kombinieren. Führen Sie zuerst die aktuelle Funktion aus, führen Sie dann die Funktion andThen aus und übergeben Sie das Ergebnis der aktuellen Funktion als Parameter an die Funktion andThen.

compose(Function before): Wenn zwei Function kombiniert werden, wird die compose-Funktion ebenfalls zuerst ausgeführt und dann Die aktuelle Funktion und übergibt das Ergebnis der Funktion compose als Parameter an die aktuelle Funktion.

identity(): Gibt eine Funktion zurück, die eine Identitätsumwandlung durchführt, also den Eingabeparameter selbst zurückgibt.

Funktionsschnittstelle wird normalerweise verwendet, um einen Wert eines Typs in einen Wert eines anderen Typs umzuwandeln. Die Apply-Methode

// Predicate 接口，泛型参数是入参类型，返回布尔值
Predicate<String> predicate = s -> s.contains("god23bin");
boolean flag = predicate.test("god23bin能给你带来收获吗？");
System.out.println("god23bin能给你带来收获吗？" + flag); // 打印：god23bin能给你带来收获吗？true

🎜andThen und die Compose-Methode🎜

Predicate<String> startsWithA = (str) -> str.startsWith("A"); // 如果传入的字符串是A开头，则返回 true
Predicate<String> endsWithZ = (str) -> str.endsWith("Z"); // 如果传入的字符串是Z结尾，则返回 true

🎜Identify-Methode🎜🎜identity-Methode geben eine Funktion zurück, die eine Identitätskonvertierung durchführt, die die Eingabeparameter unverändert zurückgibt. Zum Beispiel: 🎜

Predicate<String> startsWithAAndEndsWithZ = startsWithA.and(endsWithZ);
System.out.println(startsWithAAndEndsWithZ.test("ABCDEFZ")); // true
System.out.println(startsWithAAndEndsWithZ.test("BCDEFGH")); // false

🎜Consumer-Schnittstelle 🎜🎜 Beschreibung 🎜🎜Consumer bedeutet „Consumer“. Es verbraucht die Eingabeparameter und gibt das Ergebnis nicht an Sie zurück. 🎜🎜Consumer-Schnittstelle enthält zwei Methoden: 🎜

• 🎜accept(T t): Diese Methode akzeptiert einen Parameter und führt einige Operationen aus. 🎜🎜
• 🎜andThen(Consumer after): Kombinieren Sie auf die gleiche Weise zwei Consumer und konsumieren Sie sie nacheinander. 🎜🎜🎜🎜Accept-Methode 🎜🎜Die Verbraucherschnittstelle wird normalerweise verwendet, um einen Parameter zu konsumieren und dann einige Vorgänge auszuführen. Zum Beispiel: 🎜

  Predicate<String> notStartsWithA = startsWithA.negate();
  System.out.println(notStartsWithA.test("ABCDEF")); // false
  System.out.println(notStartsWithA.test("BCDEFGH")); // true

  🎜andThen-Methode 🎜🎜 kombiniert zwei Verbraucher: 🎜

  Predicate<String> startsWithAOrEndsWithZ = startsWithA.or(endsWithZ);
  System.out.println(startsWithAOrEndsWithZ.test("ABCDEF")); // true
  System.out.println(startsWithAOrEndsWithZ.test("BCDEFGH")); // false

  🎜Supplier-Schnittstelle 🎜🎜Supplier-Schnittstelle definiert nur eine get()-Methode, die keine Parameter akzeptiert und ein Ergebnis zurückgibt. 🎜🎜Lieferant Dieses Wort bedeutet „Lieferant“. Es gibt mir das Gefühl, dass es sich um einen Produzenten handelt, der ohne Parameter direkt etwas für Sie produziert. 🎜🎜Lieferantenschnittstelle wird normalerweise verwendet, um einen Wert zu generieren. Zum Beispiel: 🎜

  // map 方法，将 T 类型的值转换成 R 类型的值
  // R 是返回的 Stream 流的元素类型，T 是原先 Stream 流的元素类型
  <R> Stream<R> map(Function<? super T, ? extends R> mapper);

  🎜Prädikatschnittstelle🎜🎜Erklärung🎜🎜Prädikat Dieses Wort bedeutet „Prophezeiung, Vorhersage, Prädikat, Prädikat“ und wird für Vorhersage und Beurteilung verwendet. 🎜🎜Predicate -Schnittstelle enthält vier Methoden: 🎜
  • 🎜test(T t): Diese Methode akzeptiert Parameter und gibt einen 🎜Booleschen Wert🎜 zurück. 🎜🎜
  • 🎜and(Predicate other): Kombiniert mit einem anderen Prädikat, um 🎜logische UND-Operationen zu implementieren. 🎜🎜
  • 🎜negate(): Kombiniert mit einem anderen Prädikat, um die Operation „logische Negation“ zu implementieren. 🎜🎜
  • 🎜or(Predicate other): Kombiniert mit einem anderen Prädikat, um eine 🎜logische oder 🎜Operation zu implementieren. 🎜🎜🎜🎜Testmethode🎜🎜Die Prädikatschnittstelle wird normalerweise verwendet, um zu testen, ob eine Bedingung wahr ist. Zum Beispiel: 🎜

    // forEach 方法，遍历 Stream 流中的元素，T 类型是 Stream 流的元素类型
    void forEach(Consumer<? super T> action);

    🎜und Methode🎜🎜Zur Vereinfachung der Demonstration werden hier zwei Prädikate vorbereitet: 🎜

    // 生成一个无限长度的 Stream 流
    public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
            new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }

    🎜Verwenden Sie und für die Kombination, 🎜mit 🎜Operation: 🎜

    // 过滤出 Stream 流中，判断结果为 true 的元素
    Stream<T> filter(Predicate<? super T> predicate);

    🎜Negationsmethode🎜🎜Verwenden Sie Negieren für die Kombination, 🎜Nicht🎜 Operation: 🎜 Die rrreee🎜or-Methode 🎜🎜 verwendet oder zum Kombinieren, 🎜 oder 🎜 Operation: 🎜rrreee🎜Was sind also die Anwendungen dieser Schnittstellen 🎜🎜🎜Diese funktionalen Schnittstellen werden im Stream-Stream angewendet? 🎜Natürlich können Sie diese Schnittstellen bei ähnlichen Anforderungen auch selbst anwenden. Lassen Sie uns über die Anwendungen in Stream Flow sprechen. 🎜

    Function 接口：例如 map 方法，map 方法就是将一个类型的值转换为另一个类型的值。

    // map 方法，将 T 类型的值转换成 R 类型的值
    // R 是返回的 Stream 流的元素类型，T 是原先 Stream 流的元素类型
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

    Consumer 接口：例如 forEach 方法

    // forEach 方法，遍历 Stream 流中的元素，T 类型是 Stream 流的元素类型
    void forEach(Consumer<? super T> action);

    Supplier 接口：例如 generate 方法

    // 生成一个无限长度的 Stream 流
    public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
            new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }

    Predicate 接口：例如 filter 方法，使用 Predicate 进行过滤操作。

    // 过滤出 Stream 流中，判断结果为 true 的元素
    Stream<T> filter(Predicate<? super T> predicate);

Das obige ist der detaillierte Inhalt vonWas müssen Sie über funktionale Schnittstellen in Java 8 wissen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!