[JAVA] Point 30: Méthodes génériques Favar

30. Sélectionnez une méthode générique

• Les méthodes algorithmiques (recherche et tri binaires) dans les collections sont des méthodes génériques.
• L'écriture d'une méthode générique est similaire à l'écriture d'un type générique. Si vous écrivez en type brut comme ci-dessous, un avertissement apparaîtra.

// Uses raw types - unacceptable! (Item 26)
public static Set union(Set s1, Set s2) {
    Set result = new HashSet(s1);
    result.addAll(s2);
    return result;
}

Pour supprimer l'avertissement et le rendre sûr de type, écrivez le paramètre type entre le modificateur de méthode et la valeur de retour de la méthode comme suit.

// Generic method
public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
    Set<E> result = new HashSet<>(s1);
    result.addAll(s2);
    return result;
}

• Vous pouvez avoir besoin d'un objet immuable mais qui peut s'adapter à de nombreux types différents. Puisque les génériques sont implémentés par effacement, un objet peut gérer tous les paramètres de type requis, mais il est nécessaire d'écrire une méthode de fabrique statique qui crée à plusieurs reprises un objet du type requis. Ce modèle est appelé une fabrique de singleton générique et est utilisé pour générer des objets de fonction (Item42).
• Si vous avez besoin d'une fonction qui se renvoie elle-même, vous pouvez utiliser la méthode Fuction.identity, mais c'est parfait pour l'explication, je vais donc la décrire ci-dessous. identity_fnÀunaryoperator<t>Je reçois un avertissement lorsque je lanceidentity関数は引数À変更せずに返却するので、warningÀ抑制することができる。

package tryAny.effectiveJava;

import java.util.function.UnaryOperator;

public class GenericsTest7 {
    public static void main(String[] args) {
        String[] strings = { "jute", "hemp", "nylon" };
        UnaryOperator<String> sameString = identityFunction();
        for (String s : strings)
            System.out.println(sameString.apply(s));
        Number[] numbers = { 1, 2.0, 3L };
        UnaryOperator<Number> sameNumber = identityFunction();
        for (Number n : numbers)
            System.out.println(sameNumber.apply(n));

    }

    // Generic singleton factory pattern
    private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;

    @SuppressWarnings("unchecked")
    public static <T> UnaryOperator<T> identityFunction() {
        return (UnaryOperator<T>) IDENTITY_FN;
    }

}

• Lorsqu'un paramètre de type est défini par une représentation qui inclut sa propre variable de type, il est appelé une frontière récursive. Les frontières récursives sont associées à l'interface `` Comparable ''.

public interface Comparable<T> {
    int compareTo(T o);
}

• Les méthodes de réarrangement, de tri et de dérivation maximum / minimum Collection '' utilisent des éléments qui implémentent Comparable ''. Ces méthodes nécessitent des éléments qui peuvent être comparés les uns aux autres, qui sont exprimés comme suit.

// Using a recursive type bound to express mutual comparability
public static <E extends Comparable<E>> E max(Collection<E> c);

<e extends comparable<e>>Représente «chaque élément e comparable à lui-même». Voici la méthode max utilisant des limites récursives.

package tryAny.effectiveJava;

import java.util.Collection;
import java.util.Objects;

public class GenericsTest8 {
    // Returns max value in a collection - uses recursive type bound
    public static <E extends Comparable<E>> E max(Collection<E> c) {
        if (c.isEmpty())
            throw new IllegalArgumentException("Empty collection");
        E result = null;
        for (E e : c)
            if (result == null || e.compareTo(result) > 0)
                result = Objects.requireNonNull(e);
        return result;
    }

}

La méthode ci-dessus déclenche une IllegalArgumentException lorsque la liste est vide. Une bonne alternative est d'avoir une valeur de retour de ```Optional `` `.

• Les limites récursives peuvent être plus complexes, mais rares. Si vous comprenez les expressions idiomatiques traitées dans ce chapitre, l'utilisation des caractères génériques (Item31) et l'auto-type simulé (Item2), vous pouvez gérer la plupart des limites récursives auxquelles vous faites face.