#009 제네릭 두번째

제네릭 메소드를 애용하자

// 원천 타입을 사용 - 바람직하지 않다! (항목 23)
public static Set union(Set s1, Set s2) {	// 경고 - Set is a raw type. References to generic type Set should be parameterized
	Set result = new HashSet(s1);	// 경고 - HashSet is a raw type. References to generic type HashSet should be parameterized
	result.addAll(s2);			// 경고 - Type safety: The method addAll(Collection) belongs to the raw type Set. References to generic type Set should be parameterized
	return result;
}

위의 코드는 컴파일은 되지만 경고 메시지가 나온다. 이 경고 메세지를 없애고 메소드가 타입 안전하게 만들려면, 아래와 같이 코딩한다.

import java.util.*; 

public class Union {

    // 제네릭 메소드
    public static  Set union(Set s1, Set s2) {
        Set result = new HashSet(s1);
        result.addAll(s2);
        return result;
    }

    // 제네릭 메소드를 사용하는 간단한 프로그램
    public static void main(String[] args) {
        Set guys = new HashSet(
            Arrays.asList("Tom", "Dick", "Harry"));
        Set stooges = new HashSet(
            Arrays.asList("Larry", "Moe", "Curly"));
        Set aflCio = union(guys, stooges);
        System.out.println(aflCio);
    }
}

---------- execute ----------
[Moe, Harry, Tom, Curly, Larry, Dick]

union 메소드는 세 Set(메소드 인자 2개와 반환값 1개) 모두의 타입이 같아야 한다는 제약을 갖는데, 이를 더 유연하게 만들고 싶으면 바운드 와일드 카드 타입(bounded wildcard types)을 사용하면 된다.

바운드 와일드 카드를 사용해서 API의 유연성을 높이자
메소드 API에 와일드 카드 타입을 사용하면, 코드 작성이 조금 어려워지긴 하지만 훨씬 유연한 API를 만들 수 있다.
만일 폭넓게 사용할 라이브러리를 작성한다면, 와일드 카드 타입을 올바르게 사용하도록 해야한다.

 import java.util.*;

public class Stack {
    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 Stack() {
        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);
    }

     // Wildcard type for parameter that serves as an E producer
    public void pushAll(Iterable src) {
        for (E e : src)
            push(e);
    }

    // Wildcard type for parameter that serves as an E consumer
    public void popAll(Collection dst) {
        while (!isEmpty())
            dst.add(pop());
    }

    // Little program to exercise our generic Stack
    public static void main(String[] args) {
        Stack numberStack = new Stack();
        Iterable integers = Arrays.asList(3, 1, 4, 1, 5, 9);
        numberStack.pushAll(integers);

        Collection