배열보다는 리스트를 사용하라 - [5장. 제네릭(아이템28)]

1. 배열과 제네릭 타입의 차이 🦗

📗 1. 배열은 공변이고, 제네릭은 불공변이다.

• 배열은 공변(Convariant)이다.
  Sub가 Super의 하위 타입이라면 Sub[]는 배열 Super[]의 하위 타입이다.
• 제네릭은 불공변(Invariant)이다.
  서로 다른 타입 Type1과 Type2가 있을 때, List<Type1>은 List<Type2>의 하위 타입도 아니고 상위 타입도 아니다.

 

  공변과 불공변 중 어느 쪽이 문제가 있을까? 코드를 통해 알아보자.

public static void main(String[] args) {
    // 배열
    Object[] objectArray = new Long[1];
    objectArray[0] = "타입이 달라서 넣을 수 없다."; // ArrayStoreException (런타임에 발생)

    // 제네릭
    List<Object> objectList = new ArrayList<Long>(); // 호환되지 않는 타입이다. (컴파일에 발생)
    objectList.add("타입이 달라서 넣을 수 없다.");
}

  배열과 제네릭 모두 Long용 저장소에 String을 넣을 수 없다. 다만 배열에서는 그 실수를 런타임에 알게 되지만, 리스트를 사용하면 컴파일할 때 바로 알 수 있다.

  런타임에 실수를 알아차리는 것보다 컴파일 시점에 실수를 알아차리는 게 더 나을 것이다.

 

📗 2. 배열은 실체화(reify)되고, 제네릭은 타입 정보가 소거된다.

  배열은 실체화(reify)된다. 배열은 런타임에도 자신이 담기로 한 원소의 타입을 인지하고 확인한다. 그렇기 때문에 Long배열에 String을 넣으려고 하면 ArrayStoreException이 발생한다.

public static void main(String[] args) {
    Object[] objectArray = new Long[1];
    objectArray[0] = "타입이 달라서 넣을 수 없다."; // ArrayStoreException (런타임에 발생)
}

  반면에 제네릭은 타입 정보가 런타임에는 소거(erasure)된다. 원소 타입을 컴파일타임에만 검사하면 런타임에는 알 수조차 없게 된다.

 

 

2. 제네릭 배열은 사용할 수 없다. 🐝

  위에서 살펴본 배열과 제네릭의 차이점으로 인해서 배열과 제네릭은 잘 어우러지지 못한다. 그래서 둘을 섞어 쓰기가 쉽지 않다.

  배열은 제네릭 타입, 매개변수화 타입, 타입 매개변수로 사용할 수 없다. 즉, 코드를 new List<E>[], new List<String>[], new E[] 식으로 작성하면 컴파일할 때 제네릭 배열 생성 오류가 발생한다.

 

  제네릭 배열을 만들지 못하게 막은 이유는 타입이 안전하지 않기 때문이다.

  제네릭 배열을 만들도록 허용하게 되면 컴파일러가 자동 생성한 형변환 코드에서 런타임에 ClassCastException이 발생할 수 있다. 이것은 런타임에 ClassCastException이 발생하는 일을 막아주겠다는 제네릭 타입의 취지에 어긋나는 것이다.

  코드를 통해 제네릭 배열을 허용하면 어떻게 되는지 살펴보자.

List<String>[] stringLists = new List<String>[1]; // (1)

List<Integer> intList = List.of(42); // (2)
Object[] objects = stringLists; // (3)

objects[0] = intList; // (4)

String s = stringLists[0].get(0); // (5)

1. (1)이 허용된다고 가정해 보자.
2. (2)는 원소가 하나인 List<Integer>를 생성한다.
3. (3)은 (1)에서 생성한 List<String>의 배열을 Object 배열에 할당한다. 배열은 공변이기 때문에  Object 배열에 List<String> 배열을 할당할 수 있다.
4. (4)는 (2)에서 생성한 List<Integer>의 인스턴스를 Object 배열의 첫 원소로 저장한다. 제네릭은 소거 방식으로 구현되기 때문에 이것 또한 가능하다.
5. (5)에서 문제가 발생한다. (1)~(4)의 과정을 거치면서 (1)에서 List<String>만 담으려고 했던 배열에 List<Integer>가 담겨 있는 것이다. 그래서 (5)에서 컴파일러는 꺼낸 원소를 자동으로 String으로 형변환하는데, 이 원소는 Integer이므로 런타임에 ClassCastException이 발생한다.

  그렇기 때문에 처음부터 제네릭 배열이 생성되지 않도록 (1)에서 컴파일 오류가 나야 한다.

 

 

3. 배열을 리스트로 대체하는 방법 🐞

  컬렉션 안의 원소 중 하나를 무작위로 선택해 반환하는 choose 메서드를 제공하는 클래스를 살펴보자.

public class Chooser_Array {

    private final Object[] choiceList;

    public Chooser_Array(Collection choices) {
        choiceList = choices.toArray();
    }

    public Object choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceList[rnd.nextInt(choiceList.length)];
    }
}

  이 클래스를 사용하려면 choose 메서드를 호출할 때마다 반환된 Object를 원하는 타입으로 형변환해야 한다.

public static void main(String[] args) {
    List<Integer> intList = List.of(1, 2, 3, 4, 5);
    Chooser_Array chooser = new Chooser_Array(intList);

    for(int i = 0; i < intList.size(); i++){
        Number choice = (Number) chooser.choose(); // 올바르게 형변환을 한 경우
        System.out.println(choice);
    }
}

  하지만 위와 같이 올바르게 형변환 할 수도 있지만, 아래와 같이 올바르지 않게 형변환 할 수도 있다.

public static void main(String[] args) {
    List<String> intList = List.of("amenable", "choi");
    Chooser_Array chooser = new Chooser_Array(intList);

    for(int i = 0; i < intList.size(); i++){
        Number choice = (Number) chooser.choose(); // 올바르지 않게 형변환을 한 경우
        System.out.println(choice);
    }
}

 

  이런 상황을 예방하기 위해서 제네릭을 사용할 수 있다.

public class Chooser_Array<T> {
    private final Object[] choiceList;

    @SuppressWarnings("unchecked")
    public Chooser_Array(Collection<T> choices) {
        choiceList = (T[]) choices.toArray(); // Unchecked cast: 'java.lang.Object[]' to 'T[]'
    }

    @SuppressWarnings("unchecked")
    public Object choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceList[rnd.nextInt(choiceList.length)];
    }
}

public static void main(String[] args) {
    List<Integer> intList = List.of(1, 2, 3, 4, 5);

    Chooser_Array chooser = new Chooser_Array(intList);

    for(int i = 0; i < intList.size(); i++){
        Number choice = (Number) chooser.choose();
        System.out.println(choice);
    }
}

  'choiceList = (T[]) choices.toArray();'에서 타입 안전성을 컴파일러가 보장하지 못하기 때문에 경고가 뜬다. 믈론 코드에 있는 것처럼 @SuppressWarnings를 이용해서 경고를 없앨 수 있다.

 

  하지만, 아예 경고가 뜨지 않도록 하는 더 좋은 방법은 배열이 아닌 리스트를 사용하는 것이다.

public class Chooser_Array<T> {
    private final List<T> choiceList;

    public Chooser_Array(Collection<T> choices) {
        choiceList = new ArrayList<>(choices);
    }

    public T choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceList.get(rnd.nextInt(choiceList.size()));
    }
}

public static void main(String[] args) {
    List<Integer> intList = List.of(1, 2, 3, 4, 5);

    Chooser_Array<Integer> chooser = new Chooser_Array<>(intList);

    for(int i = 0; i < intList.size(); i++){
        Number choice = chooser.choose(); // 형변환을 할 필요가 없다.
        System.out.println(choice);
    }
}

  이렇게 하면 경고 없이 컴파일된다. 또한, choose 메서드를 호출할 때 형변환을 할 필요도 없어진다.

  그래서 만약 배열과 제네릭을 섞어 쓰다가 컴파일 오류나 경고를 만나면, 가장 먼저 배열을 리스트로 대체하는 방법을 적용해 보도록 하자.

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 참고하였습니다.