Efficace Java 3e édition Chapitre 7 Lambda et Stream

[Effective Java 3rd Edition](https://www.amazon.co.jp/Effective-Java-%E7%AC%AC3%E7%89%88-%E3%], qui est un livre indispensable pour les utilisateurs Java intermédiaires et supérieurs. 82% B8% E3% 83% A7% E3% 82% B7% E3% 83% A5% E3% 82% A2% E3% 83% BB% E3% 83% 96% E3% 83% AD% E3% 83% 83% E3% 82% AF-ebook / dp / B07RHX1K53) a une version Kindle, donc je vais le résumer.

Précédent: Enum et annotations du chapitre 6 de Java 3rd Edition effective Suivant: Méthodes efficaces du chapitre 8 de Java 3rd Edition

Point 42 Choisissez Lambda plutôt que la classe anonyme

//Classe anonyme
Collections.sort(words, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return Integer.compare(o1.length(), o2.length());
    }
});
//Utiliser lambda
Collections.sort(words, (o1, o2) -> Integer.compare(o1.length(), o2.length()));
//Comparer la méthode de construction
Collections.sort(words, comparingInt(String::length));
//Encore plus court en Java 8
words.sort(comparingInt(String::length));

• Exemple d'énumération avec des champs d'objet de fonction et un comportement spécifique à la constante.

public enum Operation {
    PLUS("+", (x, y) -> x + y),
    MINUS("-", (x, y) -> x + y),
    TIMES("*", (x, y) -> x + y),
    DIVIDE("/", (x, y) -> x + y);

    private final String symbol;
    private final DoubleBinaryOperator op;

    Operation(String symbol, DoubleBinaryOperator op) {
        this.symbol = symbol;
        this.op = op;
    }
    @Override public String toString() {
        return  symbol;
    }
    public double apply(double x, double y) {
        return op.applyAsDouble(x, y)
    }
}

Point 43 Sélectionnez une référence de méthode plutôt qu'un lambda

--Type de référence de méthode --statique ・ ・ ・ ʻInteger :: parseInt --Bound ・ ・ ・ ʻInstant.now () :: isAfter

• Non lié ・ ・ ・ String :: toLowerCase
• Constructeur de classe ・ ・ ・ TreeMap <K, V> :: nouveau --Constructeur de tableaux ・ ・ ・ ʻint [] :: new` --Si la référence de méthode est plus courte et plus claire, utilisez la référence de méthode, sinon utilisez le lambda.

Point 44: utiliser une interface fonctionnelle standard

--java.util.Function a 43 interfaces, dont toutes ne peuvent pas être mémorisées, mais tant que vous vous souvenez des 6 interfaces de base, le reste des interfaces peut être dérivé si nécessaire. L'interface --ʻOperator` représente une fonction dont le type résultant est le même que l'argument.

• L'interface Predicate prend un argument et renvoie un booléen.
• L'interface Function renvoie un type différent de l'argument.
• L'interface Fournisseur ne prend aucun argument et renvoie une valeur. (Fournir des résultats)
• L'interface Consumer prend un argument et ne renvoie rien. (Consommer des arguments)

Point 45 Utilisez le flux avec précaution

• En fonction du processus, il y a des cas où il est préférable de le faire dans un flux et des cas où il est préférable de le faire en boucle. Dans de nombreux cas, il est préférable de combiner les deux méthodes.
• Si vous n'êtes pas sûr qu'il vaut mieux le faire dans un flux ou une boucle, essayez les deux.

Élément 46 Sélectionnez une fonction qui n'a pas d'effets secondaires dans le flux

• L'essence de la programmation de pipeline de flux est un objet de fonction sans effets secondaires.
• L'opération de terminaison forEach doit être utilisée uniquement pour afficher le résultat, pas pour effectuer le calcul.
• Les usines de collecte importantes sont toSet, toMap, groupingBy, join.

Élément 47 Sélectionnez Collection over Stream comme valeur de retour

• Lors de l'écriture d'une méthode qui renvoie une séquence d'éléments, certains utilisateurs peuvent vouloir la traiter comme un flux, d'autres peuvent vouloir faire une boucle. Essayez de vous adapter aux deux utilisateurs. --Retourne une collection standard, telle qu'une ArrayList, si elle contient déjà des éléments dans la collection ou si le nombre d'éléments dans la séquence est suffisamment petit pour justifier la création d'une nouvelle collection. Sinon, envisagez d'implémenter une collection spéciale.
• Si vous ne pouvez pas retourner une collection, renvoyez Stream ou Iterable, selon ce qui vous semble le plus naturel.

Point 48 Faites attention lors de la parallélisation des flux

--Au moment de la sortie de Java, il avait la synchronisation et attendre / notifier, et un support de thread intégré. --Java5 a introduit la bibliothèque java.util.concurrent avec des collections simultanées et un framework d'exécuteur. --Java7 a introduit un framework fork-join haute performance pour le fractionnement en parallèle.

• En Java8, les flux sont introduits et peuvent être parallélisés en appelant une fois la méthode parallel.
• Le pipeline de flux ne doit pas être parallélisé à moins qu'il n'y ait de bonnes raisons de croire qu'il maintiendra l'exactitude et améliorera les performances.
• Assurez-vous que votre code reste correct lorsqu'il est exécuté en parallèle et mesurez soigneusement les performances dans des conditions réelles.
• Le nombre de threads par défaut pour .parallel () est nombre de cœurs sur la machine-1.

Parallélisation du pipeline de flux pour compter les nombres premiers

    static long pi(long n) {
        return LongStream.rangeClosed(2, n)
                .parallel()
                .mapToObj(BigInteger::valueOf)
                .filter(i -> i.isProbablePrime(50))
                .count();
    }