Que devez-vous savoir sur les interfaces fonctionnelles de Java 8 ?

Préface

Java 8 fournit de nombreuses interfaces fonctionnelles, notamment Fonction, Consommateur, Fournisseur, Prédicat, etc. Ils sont tous situés sous le package 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)

  Pourquoi vous devez connaître ces interfaces fonctionnelles

Parce que ces 4 interfaces fonctionnelles sont de nouvelles interfaces importantes dans Java 8,

En même temps, les nouvelles fonctionnalités Stream de Java 8 utilisent également ces interfaces

, donc les apprendre peut nous aider à mieux avoir une bonne compréhension des flux Stream.

Comme il s'agit d'une interface fonctionnelle, vous pouvez utiliser des expressions Lambda pour écrire la logique d'implémentation de l'interface. Et vous pouvez mieux comprendre les idées de programmation fonctionnelle au cours du processus d'apprentissage.

Interface de fonction

Explication

Fonction signifie "fonction". En mathématiques, y = f(x) reçoit un paramètre x et renvoie un résultat y après avoir été opéré par la fonction f.

L'interface Function contient quatre méthodes :

apply(T t) : Ceci est Fonction La méthode principale de l'interface, qui reçoit un paramètre et renvoie un résultat. En même temps, c'est également la seule méthode abstraite, et les autres ont des implémentations par défaut (les méthodes abstraites des interfaces dans Java 8 prennent en charge les implémentations par défaut).

andThen(Function after) : La fonction consiste à combiner deux Fonction. Exécutez d’abord la fonction actuelle, puis exécutez la fonction andThen et transmettez le résultat de la fonction actuelle en tant que paramètre à la fonction andThen.

compose(Function before) : De la même manière, lorsque deux Fonction sont combinées, la fonction compose sera exécutée d'abord, puis La fonction actuelle, et transmet le résultat de la fonction compose en tant que paramètre à la fonction actuelle.

identity() : renvoie une fonction qui effectue une conversion d'identité, c'est-à-dire renvoie le paramètre d'entrée lui-même.

L'interface de fonction est généralement utilisée pour convertir une valeur d'un type en une valeur d'un autre type. La méthode apply

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

🎜andThen et la méthode compose🎜

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

🎜identify method🎜🎜identity renvoient une fonction qui effectue une conversion d'identité, qui renvoie les paramètres d'entrée inchangés. Par exemple : 🎜

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

🎜Interface consommateur 🎜🎜 Description 🎜🎜Consumer signifie "consommateur". Il consomme les paramètres d'entrée et ne vous renvoie pas le résultat. 🎜🎜L'interface consommateur contient deux méthodes : 🎜

• 🎜accept(T t) : Cette méthode accepte un paramètre et effectue certaines opérations. 🎜🎜
• 🎜andThen(Consumer after) : De la même manière, combinez deux Consommateurs et consommez-les l'un après l'autre. 🎜🎜🎜🎜méthode d'acceptation 🎜🎜L'interface consommateur est généralement utilisée pour consommer un paramètre puis effectuer certaines opérations. Par exemple : la méthode 🎜

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

  🎜andThen 🎜🎜 combine deux consommateurs : 🎜

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

  🎜Interface fournisseur 🎜🎜L'interface fournisseur ne définit qu'une seule méthode get(), qui n'accepte aucun paramètre et renvoie un résultat. 🎜🎜Fournisseur Ce mot signifie "fournisseur". Cela me donne le sentiment que c'est un producteur, sans paramètres, il produit directement quelque chose pour vous. 🎜🎜L'interface fournisseur est généralement utilisée pour générer une valeur. Par exemple : 🎜

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

  🎜Interface de prédicat🎜🎜Explication🎜🎜Prédicat Ce mot signifie « prophétie, prédiction, prédicat, prédicat », qui est utilisé pour la prédiction et le jugement. 🎜🎜L'interface Predicate contient quatre méthodes : 🎜
  • 🎜test(T t) : Cette méthode accepte un paramètre et renvoie une 🎜Valeur booléenne🎜. 🎜🎜
  • 🎜and(Predicate other) : combiné avec un autre prédicat pour implémenter des opérations 🎜logiques AND🎜. 🎜🎜
  • 🎜negate() : combiné avec un autre prédicat pour implémenter l'opération 🎜négation logique🎜. 🎜🎜
  • 🎜ou(Prédicat autre) : combiné avec un autre prédicat pour implémenter une opération 🎜logique ou 🎜. 🎜🎜🎜🎜méthode de test🎜🎜L'interface de prédicat est généralement utilisée pour tester si une condition est vraie. Par exemple : 🎜

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

    🎜et méthode🎜🎜Pour faciliter la démonstration, deux prédicats sont préparés ici : 🎜

    // 生成一个无限长度的 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);
    }

    🎜Utiliser et pour la combinaison, 🎜avec 🎜opération : 🎜

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

    🎜méthode de négation🎜🎜Utiliser la négation pour la combinaison, 🎜Non🎜 opération : 🎜 La méthode rrreee🎜or 🎜🎜 utilise ou pour combiner, 🎜 ou 🎜 opération : 🎜rrreee🎜Alors quelles sont les applications de ces interfaces 🎜🎜🎜Ces interfaces fonctionnelles sont appliquées dans le flux Stream. 🎜Bien sûr, lorsque vous avez des besoins similaires, vous pouvez également appliquer ces interfaces vous-même. Parlons des applications dans Stream Flow. 🎜

    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);

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!