30. Select a generic method

Algorithmic methods (binary search and sorting) in Collections are generic methods.
Writing a generic method is similar to writing a generic type. If you write in raw type as below, warning will appear.

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

To remove the warning and make it type-safe, write the type parameter between the method qualifier and the return value of the method as follows.

// 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;
}

You may need an object that is immutable but can adapt to many different types. Since generics are implemented by erasure, one object can handle all required type parameters, but it is necessary to write a static factory method that repeatedly creates an object of the required type. This pattern is called a generic singleton factory and is used for function object (Item42) generation.
If you need a function that returns itself, you can use the Fuction.identity method, but it's perfect for explanation, so I'll describe it below. identity_fnTounaryoperator<t>I get a warning when I cast toidentity関数は引数To変更せずに返却するので、warningTo抑制することができる。

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;
    }

}

When a type parameter is defined by a representation that includes its own type variable, it is called a recursive boundary. Recursive boundaries are associated with the Comparable interface.

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

The `Collection` rearrangement, sorting, and maximum / minimum derivation methods use elements that implement `` `Comparable```. These methods require elements that can be compared with each other, which are expressed as follows.

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

<e extends comparable<e>>Represents "every element e comparable to itself". The following is the max method using recursive boundaries.

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;
    }

}

The above method raises an IllegalArgumentException when the list is empty. A good alternative is to have a return value of ```Optional ` ``.

Recursive boundaries can be more complex, but rare. If you understand the idioms covered in this chapter, the use of wildcards (Item31), and the simulated self-type (Item2), you can handle most of the recursive boundaries you actually face.

[JAVA] Item 30: Favar generic methods

30. Select a generic method