<div id="readability-page-1" class="page"><div><h2>아이템 32 - 제네릭과 가변인수를 함께 쓸 때는 신중하라 - 핵심 정리</h2>
<h5>이 글은 백기선 님의 이펙티브 자바 강의와 이펙티브 자바 3 / E 편을 참고하여 작성하였습니다.</h5>
<hr>
가변인수 <code>...</code> 는 매서드를 사용하는 클라이언트에서 파라미터를 몇개 보낼지 선택하는 것이다.
<pre><code>// 제네릭 varargs 배열 매개변수에 값을 저장하는 것은 안전하지 않다. (191-192쪽)
public class Dangerous {
 // 코드 32-1 제네릭과 varargs를 혼용하면 타입 안전성이 깨진다! (191-192쪽)
 static void dangerous(List&lt;String&gt;... stringLists) {
 List&lt;Integer&gt; intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
 }

 public static void main(String[] args) {
 dangerous(List.of("There be dragons!"));
 }
}</code></pre>
클라이언트가 넘기고 싶은 인수를 마음껏 넘길 수 있다.
이 가변인수를 제네릭 타입과 같이 사용하면 문제가 발생한다.
제네릭은 성격상 배열과 맞지 않는다.
때문에 제네릭 타입의 배열을 정의하는 걸 컴파일러가 막아준다.
그러나 가변인자에서는 내부적으로는 제네릭의 배열이 만들어지는 경우 가 있다.
가변인자와 제네릭을 같이 사용하면 제네릭 타입의 배열 이 내부적으로 만들어진다.
<pre><code>static void dangerous(List&lt;String&gt;... stringLists) {
 List&lt;Integer&gt; intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
 }</code></pre>
위와같이 <code>(List&lt;String&gt;... stringLists)</code> 로 선언을 하면 컴파일 에러는 아니지만 경고가 발생한다.
제네릭을 사용한 가변인자 떄문에 힙 메모리 가 오염될 수 있다는 메세지이다.
<pre><code> List&lt;Integer&gt; intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException</code></pre>
실제로 위의 코드는 컴파일 에러는 발생하지 않지만 굉장히 위험한 코드이다.
<code>List</code> 의 배열을 <code>Object</code> 에 할당한다.
배열은 공변이기 때문에 <code>List</code> 의 배열을 <code>Object</code> 배열에 할당할 수 있다.
<code>objects[0] = intList</code> 처럼 <code>Object</code> 배열이기 때문에 <code>List&lt;Integer&gt;</code> 를 할당할 수 있다.
<code>stringLists[0].get(0)</code> 코드를 실행할 때 에러가 발생한다.
<code>stringLists[0].get(0)</code> 코드 실행시 컴파일 시 <code>String</code> 으로 캐스팅하는 코드를 넣어준다.
<code>stringLists</code> 는 <code>List&lt;String&gt;...</code> 타입이기 떄문이다.
제네릭을 사용하는 이유는 컴파일 타입부터 런타임까지 타입 안정성 을 확보하는 것이다.
하지만 위와같은 경우는 런타임에 타입 안정성 이 깨지게된다.
때문에 제네릭을 사용한 가변인자 를 권하지 않는다.
<pre><code>static void dangerous(List&lt;String&gt;... stringLists) {
 List&lt;Integer&gt; intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
 }</code></pre>
위의 코드는 의도적으로 <code>List&lt;Integer&gt;</code> 를 넣음으로써 힙 오염을 발생시켰다.
이런 일을 하지 않고 정상적으로 문자열을 넣으면 안전하게 사용할 수 있다.
<pre><code>// 코드 32-3 제네릭 varargs 매개변수를 안전하게 사용하는 메서드 (195쪽)
public class FlattenWithVarargs {

 @SafeVarargs
 static &lt;T&gt; List&lt;T&gt; flatten(List&lt;? extends T&gt;... lists) {
 List&lt;T&gt; result = new ArrayList&lt;&gt;();
 for (List&lt;? extends T&gt; list : lists)
 result.addAll(list);
 return result;
 }

 public static void main(String[] args) {
 List&lt;Integer&gt; flatList = flatten(
 List.of(1, 2), List.of(3, 4, 5), List.of(6,7));
 System.out.println(flatList);
 }
}</code></pre>
위의 코드처럼 가변인자를 안전하게 사용하는 경우에는 자바 7버전 부터 추가된 <code>@SafeVarargs</code> 를 사용하면 
가변인자는 안전하게 사용되고 있다. 라는 뜻이된다.
그 이외의 경고 메세지가 발생해도 컴파일 타임에 확인할 수 있다.
<code>@SuppressWarnings("unchecked")</code> 를 사용하면 다른 <code>unchecked</code> 경고 역시 무시되기 떄문에
제네릭 가변인자 와 관련된 경고 메세지는 <code>@SafeVarargs</code> 를 사용하여 무시하는 걸 권장한다.
제네릭 가변인자 를 안전하게 사용하는 경우는 다음 두가지가 있다.
<ul>
<li>제네릭 가변인자 에 아무것도 넣지 않는다.</li>
</ul>
<pre><code> @SafeVarargs
 static &lt;T&gt; List&lt;T&gt; flatten(List&lt;? extends T&gt;... lists) {
 List&lt;T&gt; result = new ArrayList&lt;&gt;();
 for (List&lt;? extends T&gt; list : lists)
 result.addAll(list);
 return result;
 }</code></pre>
위의 코드처럼 가변인자로 받은 파라미터에 아무것도 저장하지 않고,
전달받은 그대로 메서드를 호출하거나 다른 리스트에 넣는다면 안전하게 사용하고 있는 것이다.
<ul>
<li>제네릭 가변인자 를 컴파일러가 내부적으로 만든 제네릭 배열을 밖에 노출하면 안된다. </li>
</ul>
제네릭 가변인자 를 절대로 밖으로 노출하면 안된다.
<pre><code>// 미묘한 힙 오염 발생 (193-194쪽)
public class PickTwo {
 // 코드 32-2 자신의 제네릭 매개변수 배열의 참조를 노출한다. - 안전하지 않다! (193쪽)
 static &lt;T&gt; T[] toArray(T... args) {
 return args;
 }

 static &lt;T&gt; T[] pickTwo(T a, T b, T c) {
 switch(ThreadLocalRandom.current().nextInt(3)) {
 case 0: return toArray(a, b);
 case 1: return toArray(a, c);
 case 2: return toArray(b, c);
 }
 throw new AssertionError(); // 도달할 수 없다.
 }

 public static void main(String[] args) { // (194쪽)
 String[] attributes = pickTwo("좋은", "빠른", "저렴한");
 System.out.println(Arrays.toString(attributes));
 }
}</code></pre>
위의 코드는 가변인자로 전달받은 제네릭 배열 을 그대로 리턴한다.
<pre><code> static &lt;T&gt; T[] toArray(T... args) {
 return args;
 }</code></pre>
컴파일러는 <code>toArray</code> 의 리턴타입을 <code>Object</code> 로 판단한다.
<pre><code> public static void main(String[] args) { // (194쪽)
 String[] attributes = pickTwo("좋은", "빠른", "저렴한");
 System.out.println(Arrays.toString(attributes));
 }</code></pre>
결과적으로 리턴타입은 <code>Object</code> 가 되지만 값은 <code>String</code> 으로 받고있기 때문에 에러가 발생한다.
이 문제에 대한 근본적인 원인은 <code>toArray</code> 에서 제네릭 배열 을 리턴했기 떄문이다.
위와같은 상황은 안전학지 않은 상황이기 떄문에 <code>@SafeVarargs</code> 를 사용하면 안된다.
<pre><code>// 배열 대신 List를 이용해 안전하게 바꿘 PickTwo (196쪽)
public class SafePickTwo {
 static &lt;T&gt; List&lt;T&gt; pickTwo(T a, T b, T c) {
 switch(ThreadLocalRandom.current().nextInt(3)) {
 case 0: return List.of(a, b);
 case 1: return List.of(a, c);
 case 2: return List.of(b, c);
 }
 throw new AssertionError();
 }

 public static void main(String[] args) {
 List&lt;String&gt; attributes = pickTwo("좋은", "빠른", "저렴한");
 System.out.println(attributes);
 }
}</code></pre>
안전하게 사용하기 위해 가변인자 대신 <code>List.of</code> 를 사용했다.
<pre><code> static &lt;E&gt; List&lt;E&gt; of(E e1, E e2) {
 return new ImmutableCollections.List12&lt;&gt;(e1, e2);
 }</code></pre>
<code>List.of</code> 내부에서는 매개변수를 받아 새로운 <code>List</code> 를 만들어 리턴하도록 되어있다.
<pre><code>// 코드 32-3 제네릭 varargs 매개변수를 안전하게 사용하는 메서드 (195쪽)
public class FlattenWithVarargs {

 @SafeVarargs
 static &lt;T&gt; List&lt;T&gt; flatten(List&lt;? extends T&gt;... lists) {
 List&lt;T&gt; result = new ArrayList&lt;&gt;();
 for (List&lt;? extends T&gt; list : lists)
 result.addAll(list);
 return result;
 }

 public static void main(String[] args) {
 List&lt;Integer&gt; flatList = flatten(
 List.of(1, 2), List.of(3, 4, 5), List.of(6,7));
 System.out.println(flatList);
 }
}</code></pre>
위의 코드도 안전하게 사용하기 위해 아래와 같이 수정한다.
<pre><code>// 코드 32-4 제네릭 varargs 매개변수를 List로 대체한 예 - 타입 안전하다. (195-196쪽)
public class FlattenWithList {
 static &lt;T&gt; List&lt;T&gt; flatten(List&lt;List&lt;? extends T&gt;&gt; lists) {
 List&lt;T&gt; result = new ArrayList&lt;&gt;();
 for (List&lt;? extends T&gt; list : lists)
 result.addAll(list);
 return result;
 }

 public static void main(String[] args) {
 List&lt;Integer&gt; flatList = flatten(List.of(
 List.of(1, 2), List.of(3, 4, 5), List.of(6,7)));
 System.out.println(flatList);
 }
}</code></pre>
가변 인자 대신 <code>List&lt;List&lt;? extends T&gt;&gt;</code> 를 사용하도록 변경한다.
<code>flatten</code> 는 값을 받아 어딘가에 넣어주는 프로듀서 이기 떄문에 <code>&lt;? extends T&gt;</code> 를 사용한다.
이렇게 가변 인자 대신 <code>List</code> 를 사용하면 <code>@SafeVarargs</code> 를 사용할 일이 없어진다.
또한 실수로 안전하지 않는 코드에 <code>@SafeVarargs</code> 를 붙이는 일도 없어지므로 코드가 상당히 안전 해진다.
그리고 경고 메세지가 발생함으로 나오는 고민이 없어진다.
단점으로는 <code>List&lt;List&lt;? extends T&gt;&gt;</code> 와 같이 코드가 조금은 복잡해보이는 점 하나가 있다.
가변 인자 대신 <code>List</code> 를 사용하는 것이 단점보다는 장점이 많으므로 가변 인자 보다는 <code>List</code> 를 더 잘 활용하도록 하자.
제네릭 타입 의 가변인자를 리턴하는 것이 항상 문제가 되지는 않는다.
이러한 상황으로는 <code>@SafeVarargs</code> 가 붙어있는 가변 인자 를 안전하게 사용하는 곳이거나
가변 인자 를 매개변수로 받지 않는 일반적인 메서드에 전달한다면 안전한 상황이지만 
힙 오염 이 발생할 여지는 있기 때문에 제네릭 타입 의 가변인자를 전달하지 않는 것이 좋다.
더 나아가 가변 인자 대신 <code>List</code> 를 사용하는 것이 가장 안전하고 <code>List&lt;List&lt;? extends T&gt;&gt;</code> 를 사용하는게
타입 안정성을 확보하는 좋은 방법이다.</div></div>

개발 인생

아이템 32 - 제네릭과 가변인수를 함께 쓸 때는 신중하라 - 핵심 정리
이 글은 백기선 님의 이펙티브 자바 강의와 이펙티브 자바 3 / E 편을 참고하여 작성하였습니다.
가변인수 ... 는 매서드를 사용하는 클라이언트에서 파라미터를 몇개 보낼지 선택하는 것이다.
// 제네릭 varargs 배열 매개변수에 값을 저장하는 것은 안전하지 않다. (191-192쪽)
public class Dangerous {
 // 코드 32-1 제네릭과 varargs를 혼용하면 타입 안전성이 깨진다! (191-192쪽)
 static void dangerous(List<String>... stringLists) {
 List<Integer> intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
 }
 public static void main(String[] args) {
 dangerous(List.of("There be dragons!"));
 }
}
클라이언트가 넘기고 싶은 인수를 마음껏 넘길 수 있다.
이 가변인수를 제네릭 타입과 같이 사용하면 문제가 발생한다.
제네릭은 성격상 배열과 맞지 않는다.
때문에 제네릭 타입의 배열을 정의하는 걸 컴파일러가 막아준다.
그러나 가변인자에서는 내부적으로는 제네릭의 배열이 만들어지는 경우 가 있다.
가변인자와 제네릭을 같이 사용하면 제네릭 타입의 배열 이 내부적으로 만들어진다.
static void dangerous(List<String>... stringLists) {
 List<Integer> intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
 }
위와같이 (List<String>... stringLists) 로 선언을 하면 컴파일 에러는 아니지만 경고가 발생한다.
제네릭을 사용한 가변인자 떄문에 힙 메모리 가 오염될 수 있다는 메세지이다.
 List<Integer> intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
실제로 위의 코드는 컴파일 에러는 발생하지 않지만 굉장히 위험한 코드이다.
List 의 배열을 Object 에 할당한다.
배열은 공변이기 때문에 List 의 배열을 Object 배열에 할당할 수 있다.
objects[0] = intList 처럼 Object 배열이기 때문에 List<Integer> 를 할당할 수 있다.
stringLists[0].get(0) 코드를 실행할 때 에러가 발생한다.
stringLists[0].get(0) 코드 실행시 컴파일 시 String 으로 캐스팅하는 코드를 넣어준다.
stringLists 는 List<String>... 타입이기 떄문이다.
제네릭을 사용하는 이유는 컴파일 타입부터 런타임까지 타입 안정성 을 확보하는 것이다.
하지만 위와같은 경우는 런타임에 타입 안정성 이 깨지게된다.
때문에 제네릭을 사용한 가변인자 를 권하지 않는다.
static void dangerous(List<String>... stringLists) {
 List<Integer> intList = List.of(42);
 Object[] objects = stringLists;
 objects[0] = intList; // 힙 오염 발생
 String s = stringLists[0].get(0); // ClassCastException
 }
위의 코드는 의도적으로 List<Integer> 를 넣음으로써 힙 오염을 발생시켰다.
이런 일을 하지 않고 정상적으로 문자열을 넣으면 안전하게 사용할 수 있다.
// 코드 32-3 제네릭 varargs 매개변수를 안전하게 사용하는 메서드 (195쪽)
public class FlattenWithVarargs {
 @SafeVarargs
 static <T> List<T> flatten(List<? extends T>... lists) {
 List<T> result = new ArrayList<>();
 for (List<? extends T> list : lists)
 result.addAll(list);
 return result;
 }
 public static void main(String[] args) {
 List<Integer> flatList = flatten(
 List.of(1, 2), List.of(3, 4, 5), List.of(6,7));
 System.out.println(flatList);
 }
}
위의 코드처럼 가변인자를 안전하게 사용하는 경우에는 자바 7버전 부터 추가된 @SafeVarargs 를 사용하면 
가변인자는 안전하게 사용되고 있다. 라는 뜻이된다.
그 이외의 경고 메세지가 발생해도 컴파일 타임에 확인할 수 있다.
@SuppressWarnings("unchecked") 를 사용하면 다른 unchecked 경고 역시 무시되기 떄문에
제네릭 가변인자 와 관련된 경고 메세지는 @SafeVarargs 를 사용하여 무시하는 걸 권장한다.
제네릭 가변인자 를 안전하게 사용하는 경우는 다음 두가지가 있다.
제네릭 가변인자 에 아무것도 넣지 않는다.
 @SafeVarargs
 static <T> List<T> flatten(List<? extends T>... lists) {
 List<T> result = new ArrayList<>();
 for (List<? extends T> list : lists)
 result.addAll(list);
 return result;
 }
위의 코드처럼 가변인자로 받은 파라미터에 아무것도 저장하지 않고,
전달받은 그대로 메서드를 호출하거나 다른 리스트에 넣는다면 안전하게 사용하고 있는 것이다.
제네릭 가변인자 를 컴파일러가 내부적으로 만든 제네릭 배열을 밖에 노출하면 안된다. 
제네릭 가변인자 를 절대로 밖으로 노출하면 안된다.
// 미묘한 힙 오염 발생 (193-194쪽)
public class PickTwo {
 // 코드 32-2 자신의 제네릭 매개변수 배열의 참조를 노출한다. - 안전하지 않다! (193쪽)
 static <T> T[] toArray(T... args) {
 return args;
 }
 static <T> T[] pickTwo(T a, T b, T c) {
 switch(ThreadLocalRandom.current().nextInt(3)) {
 case 0: return toArray(a, b);
 case 1: return toArray(a, c);
 case 2: return toArray(b, c);
 }
 throw new AssertionError(); // 도달할 수 없다.
 }
 public static void main(String[] args) { // (194쪽)
 String[] attributes = pickTwo("좋은", "빠른", "저렴한");
 System.out.println(Arrays.toString(attributes));
 }
}
위의 코드는 가변인자로 전달받은 제네릭 배열 을 그대로 리턴한다.
 static <T> T[] toArray(T... args) {
 return args;
 }
컴파일러는 toArray 의 리턴타입을 Object 로 판단한다.
 public static void main(String[] args) { // (194쪽)
 String[] attributes = pickTwo("좋은", "빠른", "저렴한");
 System.out.println(Arrays.toString(attributes));
 }
결과적으로 리턴타입은 Object 가 되지만 값은 String 으로 받고있기 때문에 에러가 발생한다.
이 문제에 대한 근본적인 원인은 toArray 에서 제네릭 배열 을 리턴했기 떄문이다.
위와같은 상황은 안전학지 않은 상황이기 떄문에 @SafeVarargs 를 사용하면 안된다.
// 배열 대신 List를 이용해 안전하게 바꿘 PickTwo (196쪽)
public class SafePickTwo {
 static <T> List<T> pickTwo(T a, T b, T c) {
 switch(ThreadLocalRandom.current().nextInt(3)) {
 case 0: return List.of(a, b);
 case 1: return List.of(a, c);
 case 2: return List.of(b, c);
 }
 throw new AssertionError();
 }
 public static void main(String[] args) {
 List<String> attributes = pickTwo("좋은", "빠른", "저렴한");
 System.out.println(attributes);
 }
}
안전하게 사용하기 위해 가변인자 대신 List.of 를 사용했다.
 static <E> List<E> of(E e1, E e2) {
 return new ImmutableCollections.List12<>(e1, e2);
 }
List.of 내부에서는 매개변수를 받아 새로운 List 를 만들어 리턴하도록 되어있다.
// 코드 32-3 제네릭 varargs 매개변수를 안전하게 사용하는 메서드 (195쪽)
public class FlattenWithVarargs {
 @SafeVarargs
 static <T> List<T> flatten(List<? extends T>... lists) {
 List<T> result = new ArrayList<>();
 for (List<? extends T> list : lists)
 result.addAll(list);
 return result;
 }
 public static void main(String[] args) {
 List<Integer> flatList = flatten(
 List.of(1, 2), List.of(3, 4, 5), List.of(6,7));
 System.out.println(flatList);
 }
}
위의 코드도 안전하게 사용하기 위해 아래와 같이 수정한다.
// 코드 32-4 제네릭 varargs 매개변수를 List로 대체한 예 - 타입 안전하다. (195-196쪽)
public class FlattenWithList {
 static <T> List<T> flatten(List<List<? extends T>> lists) {
 List<T> result = new ArrayList<>();
 for (List<? extends T> list : lists)
 result.addAll(list);
 return result;
 }
 public static void main(String[] args) {
 List<Integer> flatList = flatten(List.of(
 List.of(1, 2), List.of(3, 4, 5), List.of(6,7)));
 System.out.println(flatList);
 }
}
가변 인자 대신 List<List<? extends T>> 를 사용하도록 변경한다.
flatten 는 값을 받아 어딘가에 넣어주는 프로듀서 이기 떄문에 <? extends T> 를 사용한다.
이렇게 가변 인자 대신 List 를 사용하면 @SafeVarargs 를 사용할 일이 없어진다.
또한 실수로 안전하지 않는 코드에 @SafeVarargs 를 붙이는 일도 없어지므로 코드가 상당히 안전 해진다.
그리고 경고 메세지가 발생함으로 나오는 고민이 없어진다.
단점으로는 List<List<? extends T>> 와 같이 코드가 조금은 복잡해보이는 점 하나가 있다.
가변 인자 대신 List 를 사용하는 것이 단점보다는 장점이 많으므로 가변 인자 보다는 List 를 더 잘 활용하도록 하자.
제네릭 타입 의 가변인자를 리턴하는 것이 항상 문제가 되지는 않는다.
이러한 상황으로는 @SafeVarargs 가 붙어있는 가변 인자 를 안전하게 사용하는 곳이거나
가변 인자 를 매개변수로 받지 않는 일반적인 메서드에 전달한다면 안전한 상황이지만 
힙 오염 이 발생할 여지는 있기 때문에 제네릭 타입 의 가변인자를 전달하지 않는 것이 좋다.
더 나아가 가변 인자 대신 List 를 사용하는 것이 가장 안전하고 List<List<? extends T>> 를 사용하는게
타입 안정성을 확보하는 좋은 방법이다.

이펙티브 자바 아이템 32 - 제네릭과 가변인수를 함께 쓸 때는 신중하라 - 핵심 정리

댓글