[이펙티브 자바] Item28. 배열보다는 리스트를 사용하라.

 

[이펙티브 자바] Item28. 배열보다는 리스트를 사용하라. 

배열과 제네릭 타입에는 중요한 두가지 차이점이 있다. 

 

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

공변, 불공변 말이 어려운데 우선 공변은 '함께 변한다' 라는 뜻이다. 

// 공변
Object[] anything = new String[10]; // String 타입을 Object 타입에 담을 수 있다. (호환이 되기 때문에)
anything[0] = 1; // 컴파일 에러가 나지 않지만 문제가 있는 코드다.  (문자열 배열인데 숫자를 넣고 있으므로 버그다..!)

배열에서는 Sub이 Super의 하위 타입이라면 배열 Sub[]은 Super[]의 하위 타입이 된다. 

위에 따라서 Object는 String의 상위 타입이기 때문에 Object[]에 String[]을 담을 수 있다. 

 

       // 불공변
      List<String> names = new ArrayList<>();
//    List<Object> objects = names; // List<String>을 List<Object>에 넣을 수 없다. compile error 발생

하지만 제네릭은 불공변으로 즉, 서로 다른 타입 Type1 과 Type2가 있을 때 List<Type1> 은 List<Type2>의 하위 타입도 아니고 상위 타입도 아니다. 

 

 

지금 예제에서 배열이든 리스트이든 String에 숫자를 넣을 수 없기 때문에 에러가 나는건 맞다.

그런데 배열에서는 컴파일 시점에 에러를 발견하지 못하고 런타임에서야 알 수 있지만, 리스트는 컴파일할 때 바로 알 수 있다. 

계~~속 얘기하는거지만 컴파일 시점에 에러를 발견하는게 훨씬 좋다 ㅎㅎ 

 

 

 

2️⃣ 배열은 실체화가 되고, 제네릭은 실체화 되지 않는다. (소거) 

배열은 실체화가 된다는 것은 배열은 런타임에도 자신이 담기로 한 원소의 타입을 인지하고 확인하고 있다는 것이다. 

반면에 제네릭은 타입 정보가 런타임에는 소거가 된다. -> 원소 타입을 컴파일에만 검사하며 런타임에는 알 수 조차 없다는 뜻이다. 

public static void main(String[] args)
{
   // 컴파일하고 나면 제네릭이 사라진다. (소거) -> 하위 호환성을 위해서 소거의 방법을 사용하고 형변환 코드를 넣어줌
   List<String> names = new ArrayList<>();
   names.add("hyejin");
   String name = names.get(0);
   System.out.println("name = " + name);
}

byte code로 확인을 해보면 (IntelliJ 에서는 shift 두번 누르고 show bytecode 하면 확인할 수 있다.) 

List는 제네릭이 소거되고 로 타입인 것을 확인할 수 있고, 밑에서 String으로 cast 하고 있다. 

 

* 소거는 제네릭이 지원되기 전에 레거시 코드와 제네릭 타입을 함께 사용할 수 있게 해주는 메커니즘으로 자바 5가 제네릭으로 순조롭게 전환될 수 있도록 해줬다. 

 

 

이런 차이로 인해 배열과 제네릭은 잘 어우러지지 못한다. 

배열은 제네릭 타입, 매개변수화 타입, 타입 매개변수로 사용할 수 없다. -> 즉, new List<E>[], new List<String>[], new E[] 이런식으로 사용하지 못한다는 것이다. 이런식으로 작성하면 컴파일할 때 제네릭 배열 생성 오류를 일으킨다. 

-> 제네릭 배열을 생성하지 못하게 하는 이유는 타입 안전하지 않기 때문이다!  이를 허용하면 컴파일러가 자동 생성한 형변환 코드에서 런타임 오류가 발생할 수 있기 때문으로 런타임이 발생하는 일을 막아주겠다는 제네릭 타입 시스템의 취지에 맞지 않기 때문이다. 

 

 

public class Chooser_Array // 배열 기반 Chooser
{
   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)];
   }
   
   public static void main(String[] args)
   {
      List<Integer> intList = List.of(1, 2, 3, 4, 5, 6);
      Chooser_Array chooser = new Chooser_Array(intList);
      
      for (int i = 0; i < 10; i++)
      {
         Number choice = (Number) chooser.choose();
         System.out.println("choice = " + choice);
      }
   }
}

-> 생성자에서 컬렉션을 받는 Chooser_Array 클래스가 있다. 

이 클래스에서는 컬렉션 안의 원소 중 하나를 무작위로 선택해 반환하는 choose 메서드를 제공한다. 

일단 Choose_Array 클래스는 제네릭을 사용하지 않고 배열을 사용한 가장 간단한 버전이다. 

 

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

Number choice = (Number) chooser.choose();

근데 이때 혹시나 타입이 다른 원소가 들어 있다면 런타임에 형변환 오류가 날 것이다. 

 

 

public class Chooser_List<T> // 리스트 기반 Chooser
{
   private final List<T> choiceList;
   
   public Chooser_List(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)
   {
      // 리스트 기반 chooser는 훨씬 더 안전한 코드가 된다.
      List<Integer> intList = List.of(1, 2, 3, 4, 5, 6);
      Chooser_List<Integer> chooser = new Chooser_List<>(intList);
      
      for (int i = 0; i < 10; i++)
      {
         Number choice = chooser.choose();
         System.out.println("choice = " + choice);
      }
   }
}

이 클래스는 이제 배열 대신 리스트를 사용한 클래스로 타입 안정성과 상호운용성이 훨씬 좋아진다. 

 

 

 

📚 정리

배열과 제네릭은 두가지 다른 타입 규칙이 적용된다. 

배열은 공변이고 실체화되는 반면, 제네릭은 불공변이고 타입 정보가 소거된다. 그 결과 배열은 런타임에는 타입 안전하지만 컴파일타임에는 그렇지 않다. 제네릭은 그 반대고,, 

따라서 이 둘은 섞어 쓰기가 어렵다. 따라서 배열보다는 리스트를 사용하는 것이 더 좋다!!