Java prend en charge le concept de programmation fonctionnelle, qui peut être réalisée par 1. En utilisant des interfaces fonctionnelles et des expressions lambda pour implémenter des fonctions de première classe et d'ordre supérieur; 2. Utilisation d'objets immuables et de fonctions pures pour implémenter l'immuabilité et les fonctions pures; 3. Utilisation de l'API Stream pour le traitement déclaratif des données; 4. Utilisation de la fonction et des méthodes et composez des méthodes pour réaliser des combinaisons de fonctions; 5. évitez les effets secondaires et hiérarchisez les expressions sur les instructions, afin d'écrire du code plus clair, prévisible et facile à tester.

Java n'est peut-être pas un langage purement fonctionnel, mais il a intégré de nombreux concepts de programmation fonctionnelle (FP) depuis Java 8. Ces concepts aident à écrire un code plus propre, plus prévisible et plus facile à tester. Voici une ventilation des idées de programmation fonctionnelle clés disponibles en Java et comment les utiliser efficacement.

1. fonctions de première classe et d'ordre supérieur via des interfaces fonctionnelles

Dans la programmation fonctionnelle, les fonctions sont traitées comme des citoyens de première classe - ce qui signifie qu'ils peuvent être passés comme des arguments, retournés d'autres fonctions et affectés à des variables.

En Java, ceci est réalisé à l'aide d'interfaces fonctionnelles (interfaces avec exactement une méthode abstraite) et des expressions de lambda .

Exemple:

 @FunctionalInterface
Mathépation d'interface {
    int applique (int a, int b);
}

Exemple de classe publique {
    public static void main (String [] args) {
        MathOpation Add = (A, B) -> AB;
        MathOperation Multiply = (a, b) -> a * b;

        System.out.println (add.Apply (5, 3)); // 8
        System.out.println (Multiply.Apply (5, 3)); // 15
    }
}

Java fournit des interfaces fonctionnelles intégrées dans java.util.function :

• Function<T, R> - prenez un argument et renvoie un résultat
• Predicate<T> - Renvoie un booléen (utile pour le filtrage)
• Consumer<T> - Prenez les commentaires mais ne renvoie rien (effets secondaires)
• Supplier<T> - Ne prenez aucune entrée, renvoie une valeur
• UnaryOperator<T> , BinaryOperator<T> - Pour les opérations sur des valeurs simples ou deux du même type

2. Imutabilité et fonctions pures

Un principe de base FP est l'immuabilité - une fois créée, les données ne devraient pas changer. Cela évite les effets secondaires et rend le code plus prévisible.

Bien que Java autorise l'état mutable, vous pouvez suivre les pratiques FP par:

• Utilisation d'objets immuables (par exemple, String , LocalDateTime ou Classes personnalisées avec des champs finaux)
• éviter la mutation de l'état dans les fonctions
• écrire des fonctions pures - la même entrée donne toujours la même sortie, sans effets secondaires

Exemple d'une fonction pure:

 public static int square (int x) {
    retour x * x; // Pas d'effets secondaires, pas de changement d'état
}

éviter:

 COMPRESSION INT STATIQUE PRIVé = 0;
public static int impureadd (int x) {
    retour x (compteur); // dépend de l'état externe - pas pur
}

CONSEIL: Utilisez Collections.unmodifiableList() ou des bibliothèques comme Google Guava ou des enregistrements (Java 14) pour créer des structures de données immuables.

3. Fonctions d'ordre supérieur avec des flux

L'API Stream de Java (introduit dans Java 8) est fortement inspirée par la programmation fonctionnelle. Il vous permet de traiter les données de manière déclarative - en vous concentrant sur ce qu'il faut faire, pas comment .

Opérations communes de style FP:

• map - Transformer les éléments
• filter - Sélectionnez des éléments en fonction de l'état
• reduce - Mélanger les éléments en un résultat
• forEach - effectuer une action sur chaque (effet secondaire)

Exemple:

 List <Integer> nombres = arrays.aslist (1, 2, 3, 4, 5);

// Style fonctionnel: obtenez une somme de carrés de nombres pair
Int result = nombres.stream ()
    .filter (n -> n% 2 == 0)
    .map (n -> n * n)
    .reduce (0, entier :: sum);

System.out.println (résultat); // 20 (4 16)

Ceci est plus lisible et moins sujet aux erreurs que les boucles et les variables temporaires.

4. Composition de la fonction

En FP, les fonctions peuvent être composées pour créer un comportement plus complexe. Java prend en charge cela via des méthodes comme andThen et compose sur Function .

Exemple:

 Fonction <Integer, entier> carré = x -> x * x;
Fonction <Integer, entier> incrément = x -> x 1;

// (x 1) ^ 2
Fonction <entier, entier> incrémentThensquare = incrément.etthen (carré);
System.out.println (incmenmentThensquare.Apply (3)); // (3 1) ^ 2 = 16

// x ^ 2 1
Fonction <Integer, Integer> SquareThenInCment = Square.etThen (incrément);
System.out.println (SquareThenInCment.Apply (3)); // 9 1 = 10

Cela permet de construire des pipelines de transformations de manière propre et réutilisable.

5. éviter les effets secondaires et embrasser les expressions

La programmation fonctionnelle favorise les expressions sur les instructions. En Java, les lambdas et les flux aident à se déplacer vers le codage basé sur l'expression.

Préférer:

 Facultatif <string> result = list.stream ()
    .filter (s -> s.startswith ("a"))
    .FindFirst ();

Sur:

 Résultat de cha?ne = null;
pour (String s: list) {
    if (s.startswith ("a")) {
        résultat = s;
        casser;
    }
}

La version Stream est plus concise et moins sujette aux bugs.

évitez également de muter l'état externe à l'intérieur des lambdas - gardez-les sans état lorsque cela est possible.

Résumé

Même si Java est orienté objet en son c?ur, vous pouvez appliquer efficacement les concepts de programmation fonctionnelle:

• Utilisez des expressions lambda et des interfaces fonctionnelles pour passer le comportement
• Tirez parti de l' API Stream pour le traitement déclaratif des données
• Favoriser l'immutabilité et les fonctions pures pour réduire les bogues
• Composez des fonctions en utilisant andThen / compose
• Minimiser les effets secondaires et l'état partagé

Ces pratiques conduisent à un code plus facile à raisonner, à tester et à paralléliser (par exemple, parallelStream() ).

Fondamentalement, vous n'avez pas besoin de Haskell pour effectuer une programmation fonctionnelle - Java vous donne suffisamment d'outils pour commencer à penser et à coder fonctionnellement.

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!