pratique de conception de l'utilisation java.util.Function dans un contexte non-stream

Question

Je suis en train de définir une fonction au sein d'une méthode pour aider w/deux objectifs:

1. si Simplifier le bloc dans une section de non code piloté par le flux,
2. Encapsulation de la fonction dans la méthode pour laquelle elle est uniquement .

Exemple (pour illustration uniquement):

public String someMethod(String parm1, String parm2) { 
    final Function<String, Boolean> isValidString = parm -> parm.equals("Test") || parm.equals("Test2"); 
    ... 
    String parm1 = ... 
    if (parm1 != null && isValidString.apply(parm)) { 
    ... do something 
} 
... 

Dans ma situation, la méthode de fonction est un peu plus complexe et couvre 1 cas particulier d'affaires Je vérifie pour dans le cas bloc.

Existe-t-il un modèle de conception standard ou un anti-modèle pour ceci ou recommandation? Je cherche spécifiquement des réponses plus que des préférences personnelles.

===

succincts Résultat:

Pro de: Encapsulation, Lisibilité et l'accès aux variables finales/finales efficaces dans la recherche.

Points faibles: Avoir trop ou trop de fonctions complexes peut créer des problèmes de lisibilité du code.

Answer 1

Cette utilisation de Function<T,R> est un modèle qui correspond à méthode locale - une caractéristique de langage manquante en Java, mais présente dans d'autres langages de programmation.

Il n'y a absolument rien de mal à utiliser ce modèle, surtout si vous envisagez de réutiliser plusieurs fois la même logique de validation dans la même implémentation de méthode.

Contrairement à une méthode privée, une fonction locale vous permet de capturer param1 et param2 implicitement dans le cas où vous avez besoin:

final Function<String, Boolean> isValidString = parm -> parm.equals(param1); 
//                 ^
//                  | 
// Implicitly captured param1 ---------------------------------------+ 

Note: Étant donné que votre fonction retourne Boolean, une interface plus appropriée pour ce serait :

final Predicate<String> isValidString = parm -> parm.equals("Test") || parm.equals("Test2"); 
... 
if (parm1 != null && isValidString.test(parm)) { 
    ... 
}