[이펙티브 자바] Item31. 한정적 와일드카드를 사용해 API의 유연성을 높이라.

 

 

[이펙티브 자바] Item31. 한정적 와일드카드를 사용해 API의 유연성을 높이라.

 

 

 

1️⃣ Chooser와 Union API 개선

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

    @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;
        return result;
    }

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

    // 와일드카드 타입을 사용하지 않은 pushAll 메서드 -> 결함이 있다!
//    public void pushAll(Iterable<E> src) {
//        for (E e : src) {
//            push(e);
//        }
//    }

    // 생산자(producer) 매개변수에 와일드카드 타입 적용
    public void pushAll(Iterable<? extends E> src) {
        for (E e : src) {
            push(e);
        }
    }

    // 와일드카드 타입을 사용하지 않은 popAll 메서드 -> 결함이 있다!
//    public void popAll(Collection<E> dst) {
//        while (!isEmpty()) {
//            dst.add(pop());
//        }
//    }

    // 소비자(consumer) 매개변수에 와일드카드 타입 적용
    public void popAll(Collection<? super E> dst) {
        while (!isEmpty()) {
            dst.add(pop());
        }
    }


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

    public static void main(String[] args) {
        Stack<Number> numberStack = new Stack<>();
        Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
        numberStack.pushAll(integers);

        Iterable<Double> doubles = Arrays.asList(3.0, 1.0);
        numberStack.pushAll(doubles);

        Collection<Object> objects = new ArrayList<>();
        numberStack.popAll(objects);

        System.out.println("objects = " + objects);
    }
}

PECS

: Producer-Extends , Consumer-super

 

Producer-Extends

public void pushAll(Iterable<E> src) {
    for (E e : src) {
        push(e);
    }
}

Stack<Number> numberStack = new Stack<>();
Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
numberStack.pushAll(integers);

한정적 와일드카들를 사용하지 않은 pushAll 메서드에서는 Iterable<Number> 만 받을 수 있기 때문에 Iterable<Integer>를 pushAll 하려고 하면 에러가 난다. 

그런데 생각해보면 Stack의 Number에 Integer 를 담아도 괜챃기 때문에... 한정적 와일드 카드를 사용해서 좀 더 유연하게 만들 수 있다. 

 

public void pushAll(Iterable<? extends E> src) {
    for (E e : src) {
        push(e);
    }
}

이렇게 ? extends E 로 선언하면 Number를 상속받는 어떤 타입이든 와도 상관없다는 뜻이 되기 때문에 

 

Stack<Number> numberStack = new Stack<>();
Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
numberStack.pushAll(integers);

Iterable<Double> doubles = Arrays.asList(3.0, 1.0);
numberStack.pushAll(doubles);

Iterable<Integer>, Iterable<Double> 모두 pushAll 할 수 있다. 

 

-> Producer-Extends 는 Object 컬렉션에 Number, Integer를 넣을 수 있고, Number의 컬렉션에 Integer를 넣을 수 있다. 

 

 

Consumer-Super

public void popAll(Collection<E> dst) {
    while (!isEmpty()) {
        dst.add(pop());
    }
}

Collection<Object> objects = new ArrayList<>();
numberStack.popAll(objects);

한정적 와일드카드 타입을 사용하지 않은 popAll 메서드에 대해서 Collection<Object>를 numberStack의 popAll에 넣으려고 하면 에러가 난다.

왜냐하면 popAll은 Collection<Number>만 받을 수 있기 때문이다..! 

근데 Number의 컬렉션 객체를 꺼내서 Object 컬렉션에 담아도 문제 없기 때문에 여기서도 한정적 와일드 카드를 사용하면 좀 더 유연하게 만들 수 있다. 

 

public void popAll(Collection<? super E> dst) {
    while (!isEmpty()) {
        dst.add(pop());
    }
}

이렇게 <? super E> 로 매개변수 타입을 받으면 E보다 높은 상위 클래스를 매개변수로 받을 수 있다. 

 

-> Consumer-Super는 Integer 컬렉션의 객체를 꺼내서 Number의 컬렉션에 담을 수 있고, Number나 Integer의 컬렉션의 객체를 꺼내서 Object 컬렉션에 담을 수 있다. 

 

 

public class Chooser<T> { // T 생성자 매개변수에 와일드 카드 타입 적용
    private final List<T> choiceList;
    private final Random rnd = new Random();

    // producer
    public Chooser(Collection<? extends T> choices) {
        choiceList = new ArrayList<>(choices);
    }

    public T choose() {
        return choiceList.get(rnd.nextInt(choiceList.size()));
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3, 4, 5, 6);
        Chooser<Number> chooser = new Chooser<>(intList);
        for (int i = 0; i < 10; i++) {
            Number choose = chooser.choose();
            System.out.println("choose = " + choose);
        }
    }
}

Chooser은 받아서 담고 있기 때문에 Producer이다. 따라서 <? extends T> 이다. 

 

public class Union {
    // producer
    public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2) {
        Set<E> result = new HashSet<>(s1);
        result.addAll(s2);
        return result;
    }

    public static void main(String[] args) {
        Set<Integer> integers = new HashSet<>();
        integers.add(1);
        integers.add(3);
        integers.add(5);

        Set<Double> doubles = new HashSet<>();
        doubles.add(2.0);
        doubles.add(4.0);
        doubles.add(6.0);

        Set<Number> numbers = union(integers, doubles);

        System.out.println("numbers = " + numbers);
    }

}

Union 역시 받아서 addAll 즉, 담고 있기 때문에 Producer로 <? extends E> 이다. 

 

 

 

2️⃣ Comparator와 Comparable은 소비자 

package chapter04.item31.example;

public class Box<T extends Comparable<T>> implements Comparable<Box<T>> {

    private final T value;

    public Box(T value) {
        this.value = value;
    }

    @SuppressWarnings("unchecked")
    @Override
    public int compareTo(Box o) {
        return this.value.compareTo((T) o.value);
    }

    @Override
    public String toString() {
        return "Box{" +
                "value=" + value +
                '}';
    }
}

package chapter04.item31.example;

public class IntegerBox extends Box<Integer> {

    private final String message;

    public IntegerBox(int value, String message) {
        super(value);
        this.message = message;
    }

    @Override
    public String toString() {
        return "IntegerBox{" +
                "message='" + message + '\'' +
                '}';
    }
}

public class RecursiveTypeBound { // 와일드카드 타입 한정을 이용해 상호 비교할 수 있음을 표현 

    // 컬렉션에서 최대값을 반환하는 메서드 
    public static <E extends Comparable<? super E>> E max(List< ? extends E> list) {
        if (list.isEmpty()) {
            throw new IllegalArgumentException("collection is empty");
        }

        E result = null;

        for (E e : list) {
            if (result == null || e.compareTo(result) > 0) {
                result = e;
            }
        }

        return result;
    }

    public static void main(String[] args) {
        List<IntegerBox> list = new ArrayList<>();
        list.add(new IntegerBox(1, "hyejin"));
        list.add(new IntegerBox(2, "park"));
        System.out.println("list = " + max(list));
    }
    
}

IntegerBox는 Comparable을 직접 구현하지 않았지만 Box를 상속받고 있는데 상위타입인 Box가 Comparable을 구현하고 있는 상태이다. 

-> 이때 Comparable을 직접 구현하지 않고, 직접 구현한 다른 타입을 확장한 타입을 지원하려면 한정적 와일드카드가 필요하다. 

 

 

 

📖 와일드카드 활용 팁 

public class Swap {
     public static void swap(List<?> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }

    public static void main(String[] args) {
        List<String> argList = Arrays.asList(args);
        swap(argList, 0, argList.size() - 1);
        System.out.println("argList = " + argList);
    }
}

public class Swap {
    public static <E> void swap(List<E> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }


    public static void main(String[] args) {
        List<String> argList = Arrays.asList(args);
        swap(argList, 0, argList.size() - 1);
        System.out.println("argList = " + argList);
    }
}

위의 와일드카드를 사용한 경우와 특정 타입 을 사용한 경우는 같다고 생각할 수 있지만 다르다.

위의 ?만 사용한 경우가 비한정적 와일드 카드로 정의한 것인데 이는 null을 제외한 아무것도 넣을 수 없기 때문에 list.set할 때 에러가 난다. 

왜냐하면 ?는 어떤 타입과도 매칭이 안되기 때문이다. 

 

private static <E> void swapHelper(List<E> list, int i, int j) {
    list.set(i, list.set(j, list.get(i)));
}

따라서 비한정적 와일드 카드를 사용하는 경우에는 와일드 카드를 실제 타입으로 바꿔주는 헬퍼 메서드가 또 필요하게 되는데... 

약간 굳이..? 싶긴 하다. 

 

보통 와일드 카드는 한정적 와일드 카드로 주로 사용하기는 하는데 비한정적 와일드 카드는 넣을 때는 아무 타입과 매칭되지 않기 때문에 null 만 넣을 수 있지만, 꺼낼때는 상관없기 때문에 꺼내기만 한다면 비한정적 와일드 카드만 사용해도 되긴 한다.