Les interfaces fonctionnelles comme la fonction, le prédicat, le consommateur, le fournisseur, uny-opérateur et le binaryopérateur permettent l'abstraction du comportement et soutiennent les expressions de lambda. 2. L'API Streams autorise fonctionnellement les opérations déclaratives, paresseuses et encha?nées telles que filtre, carte et collectionner pour traiter les séquences de données. 3. Facultatif favorise la manipulation nul plus s?re en rendant l'absence explicite et la méthode de support cha?nage de carte, de map plat, de filtre et d'Orelse. 4. Références de méthodes (: :) Améliorer la lisibilité et la réutilisation en se référant aux méthodes existantes, y compris les références statiques, par instance et constructeurs. 5. L'immuabilité est encouragée par des collections non modifiables et des classes immuables avec des champs finaux pour soutenir les fonctions pures et réduire les effets secondaires. 6. Des fonctions d'ordre supérieur sont obtenues via des interfaces fonctionnelles qui acceptent ou renvoient d'autres fonctions, permettant des modèles comme la composition de fonction et la configuration basée sur le comportement. Ensemble, ces fonctionnalités permettent aux développeurs Java d'écrire du code plus expressif, plus s?r et maintenable dans un style fonctionnel au-delà de l'utilisation de Lambdas.

L'introduction de Lambdas par Java dans Java 8 a été un grand pas vers la prise en charge de la programmation fonctionnelle, mais il y a plus sous le capot que de simples expressions de lambda. Alors que les lambdas attirent l'essentiel, Java comprend plusieurs autres constructions de programmation fonctionnelle qui permettent un code plus propre, plus expressif et plus s?r lorsqu'ils sont utilisés de manière appropriée. Voici les principales fonctionnalités de programmation fonctionnelle en Java au-delà des lambdas.

1. Interfaces fonctionnelles

Les interfaces fonctionnelles sont l'épine dorsale de la programmation fonctionnelle en Java. Ce sont des interfaces avec exactement une méthode abstraite (SAM - méthode abstraite unique), ce qui les rend compatibles avec les expressions de lambda.

Les exemples courants de java.util.function comprennent:

• Function<t r></t> - prend une entrée de type T et renvoie le résultat du type R
• Predicate<t></t> - évalue une condition et renvoie un booléen
• Consumer<t></t> - Effectue une action avec l'entrée mais ne renvoie rien
• Supplier<t></t> - fournit une valeur sans prendre de saisie
• UnaryOperator<t></t> et BinaryOperator<t></t> - Fonctions spécialisées pour les entrées uniques et doubles du même type

Ces interfaces vous permettent d'écrire du code générique et réutilisable qui résume le comportement.

Exemple:

 List <string> names = arrays.aslist ("Alice", "Bob", "Charlie");
Prédicat <string> startWitha = s -> s.startswith ("a");
noms.stream ()
     .filter (startSwitha)
     .ForEach (System.out :: println);

L'utilisation d'interfaces fonctionnelles favorise la composabilité et aide à découpler la logique de l'implémentation.

2. API Streams

L'API Streams (introduite dans Java 8) est l'un des outils de programmation fonctionnelle les plus puissants de Java. Il permet des opérations de style fonctionnel sur des séquences d'éléments, des opérations de support comme le filtrage, la cartographie, la réduction et la collecte.

Caractéristiques clés:

• DéCARRATIF : Vous décrivez ce que vous voulez, pas comment le faire.
• évaluation paresseuse : les opérations intermédiaires (comme filter , map ) ne sont pas exécutées tant qu'une opération de terminal (comme forEach , collect ) n'est pas appelée.
• Prise en charge le cha?nage de la méthode : permet des pipelines courants et lisibles.

Exemple:

 List <Integer> result = nombres.stream ()
    .filter (n -> n> 0)
    .map (n -> n * 2)
    .limit (10)
    .Collect (collectionners.tolist ());

Les flux encouragent l'immuabilité et réduisent la bine-partout par rapport aux boucles traditionnelles.

3. Facultatif pour une manipulation nul plus s?re

Optional<T> est un conteneur qui peut ou non maintenir une valeur non nulle. Il s'agit d'une approche fonctionnelle pour éviter NullPointerException en rendant l'explicitation nullabilité.

Au lieu de retourner null , les méthodes peuvent renvoyer Optional<T> , for?ant les appelants à gérer l'absence d'une valeur.

Exemple:

 public facultatif <string> findNameById (int id) {
    // Valeur de retour si elle est trouvée, sinon facultatif.empty ()
}

// utilisation
FindNameByid (42)
    .map (String :: ToupperCase)
    .ifpresent (System.out :: println);

Des méthodes telles que map , flatMap , filter et orElse permettent des opérations de cha?nage en toute sécurité sans vérifications nuls explicites.

Cela déplace la gestion des erreurs des exceptions d'exécution à la sensibilisation à la compilation du temps.

4. Références de méthode

Bien que liés aux lambdas, les références de méthode ( :: :) sont une construction distincte qui favorise la réutilisation et la lisibilité en se référant aux méthodes existantes par leur nom.

Types de références de méthode:

• ClassName::staticMethod - par exemple, Integer::sum
• object::instanceMethod - par exemple, System.out::println
• ClassName::instanceMethod - par exemple, String::length (appelée sur chaque objet)
• ClassName::new - Référence du constructeur, par exemple, ArrayList::new

Exemple:

 list.ForEach (System.out :: println); // plus propre que x -> System.out.println (x)

Ils réduisent la verbosité et améliorent la clarté du code, en particulier lorsque les méthodes existantes implémentent déjà la logique souhaitée.

5. Imutabilité et fonctions pures (modèles encouragés)

Java n'applique pas l'immuabilité, mais la programmation fonctionnelle en Java fonctionne mieux lorsque vous adoptez des structures de données immuables et des fonctions pures (fonctions sans effets secondaires).

Bien que Java manque de structures de données persistantes intégrées, vous pouvez:

• Utilisez des collections non modifiables: List.copyOf(original) (Java 10)
• Concevoir des classes immuables avec des champs final et pas de sets
• évitez de muter l'état partagé

Exemple:

 Personne publique de classe finale {
    Nom de la cha?ne finale privée;
    ?ge final privé;

    Personne publique (nom de la cha?ne, Int Age) {
        this.name = name;
        this.age = age;
    }

    // Seulement Getters, pas de setteurs
}

Combiné avec des flux et des lambdas, l'immuabilité réduit les bogues dans des environnements simultanés.

6. Fonctions d'ordre supérieur via des interfaces fonctionnelles

Dans la programmation fonctionnelle, les fonctions peuvent prendre d'autres fonctions comme des paramètres ou les renvoyer. Java prend en charge cela via des interfaces fonctionnelles.

Vous pouvez écrire des méthodes qui acceptent ou renvoient les lambdas.

Exemple:

 Fonction publique <Integer, Integer> CreateMultiplier (Int Factor) {
    retour x -> x * facteur;
}

// utilisation
Fonction <Integer, Integer> doubleit = CreateMultiplier (2);
System.out.println (doubleit.Apply (5)); // 10

Cela permet des modèles puissants comme la composition de la fonction, la configuration via le comportement et les conceptions de type stratégie.

Réflexions finales

Java n'est peut-être pas un langage purement fonctionnel, mais il offre suffisamment de constructions fonctionnelles pour écrire du code dans un style plus fonctionnel. Au-delà de Lambdas, tirer parti des interfaces fonctionnelles , des flux , des options , des références de méthode et une conception immuable conduit à un code plus lisible, testable et moins sujet aux erreurs, en particulier dans les scénarios de transformation des données et de pipelines.

Utilisées à bon escient, ces outils apportent des avantages de programmation fonctionnelle dans le développement de Java quotidien.

Fondamentalement, une fois que vous passez au-delà de l'utilisation de Lambdas pour forEach , le vrai pouvoir commence à se montrer.

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!