Item 29: Favor generic types

29. Use generic types

• Consider the simple stack implementation covered in Item7.

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.EmptyStackException;

//Object-based collection - a prime candidate for generics
public class Stack1 {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack1() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        Object result = elements[--size];
        elements[size] = null; // Eliminate obsolete reference
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if (elements.length == size)
            elements = Arrays.copyOf(elements, 2 * size + 1);
    }

}

• To genericize a class, first add type parameters to the class. The above stack requires a one-type parameter, which is an element of the stack, so we customarily name it E (Item68).
• Then replace all Object types with the appropriate type parameters so they can be compiled.
• One of the workarounds when an array of non-reifiable type is created is to create a new array with Object and cast it, but this is generally not type-safe. In this case, the problem is the source in the constructor, but the elements field is private and no value can be entered from anything other than the push method, so the reality is guaranteed to be E. Therefore, the warning should be erased by giving `@ SuppressWarning (" unchecked ")` in the minimum range and with a comment.

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.EmptyStackException;

//Initial attempt to generify Stack - won't compile!
public class Stack2<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    // The elements array will contain only E instances from push(E).
    // This is sufficient to ensure type safety, but the runtime
    // type of the array won't be E[]; it will always be Object[]!
    @SuppressWarnings("unchecked")
    public Stack2() {
        elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(E e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public E pop() {
        if (size == 0)
            throw new EmptyStackException();
        E result = elements[--size];
        elements[size] = null; // Eliminate obsolete reference
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if (elements.length == size)
            elements = Arrays.copyOf(elements, 2 * size + 1);
    }

}

• Another solution when an array of non-reifiable type is created is to declare the array with Object. Even in this case, an error will occur in the pop method as it is, so cast it. If you cast it, you will get a warning, but for the same reason as above, it is obvious that you can cast to E again, so add `@ SuppressWarning (" unchecked ")` in the minimum range (Item27).

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.EmptyStackException;

public class Stack3<E> {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack3() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(E e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public E pop() {
        if (size == 0)
            throw new EmptyStackException();
        // push requires elements to be of type E, so cast is correct
        @SuppressWarnings("unchecked")
        E result = (E) elements[--size];
        elements[size] = null; // Eliminate obsolete reference
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if (elements.length == size)
            elements = Arrays.copyOf(elements, 2 * size + 1);
    }

}

• Regarding the above two methods, the former is easier to read and the cast only needs to be done once at the time of instance creation, so the former is generally used more often. However, heap pollution (Item32), that is, the type of the array at runtime and the type at compile time are different, so some programmers are frustrated with choosing the latter.
• The above example contradicts Item28's advice to use list rather than array, but Java doesn't support list by nature and you have to use array somewhere in the generic type. For example, ArrayList uses an array. In addition, HashMap etc. use arrays for performance.
• Basically anything can be specified for the type parameter in the above example, but if you specify a primitive type such as Stack or Stack , a compile error will occur. If you want to use a primitive type, specify the boxed one in the type parameter (Item61).
• Some generic types impose restrictions on type parameters. For example, the DelayQueue class uses bounded parameters as follows:

class DelayQueue<E extends Delayed> implements BlockingQueue<E>