18-1.제네릭

18-1-1.제네릭 컬렉션

자바 5 이전에는 컬렉션에 Object 타입을 저장했다. Object는 가장 일반적인 타입이어서 모든 후손 객체를 다 저장할 수 있다. 그러나 선언된 타입과 실제 저장된 타입이 일치하지 않아 여러 가지 불편과 위험이 따른다. 동적 배열인 ArrayList를 타입 인수없이 사용해 보자. 요즘은 제네릭을 쓰지만 역호환성 때문에 아직도 이런 코드를 지원한다.

rawarraylist	실행결과
import java.util.*; class JavaTest { public static void main(String[] args) { ArrayList arNum = new ArrayList(); arNum.add(1); arNum.add("문자열"); int value = (int)arNum.get(0); // int temp = (int)arNum.get(1); System.out.println(value); } }	1

arNum 배열을 하나 생성하고 숫자 1과 문자열을 저장했다. 컴파일은 무사히 잘 되지만 경고가 5개나 발생한다. 숫자나 문자열이나 다 Object의 후손이므로 ArrayList에 같이 저장할 수 있지만 요소를 꺼낼 때 일일이 캐스팅해야 하는 불편함이 있다. 0번째의 정수 1을 꺼내기 위해 (int)로 캐스팅했는데 이 캐스팅을 빼면 에러 처리된다.

int value = arNum.get(0);

arNum에 저장된 데이터는 Object 타입이어서 정수형 변수에 바로 대입할 수 없다. 개발자가 정수를 저장했다는 것을 분명히 알고 있지만 좌우의 타입이 달라 반드시 캐스팅해야 한다. 불편한 것은 물론이고 캐스팅을 잘못하면 실행중에 예외가 발생한다. 위 예제에 주석 처리된 다음 코드의 주석을 풀어 보자.

int temp = (int)arNum.get(1);

배열의 1번째에 문자열을 저장해 놓고 개발자가 잠시 착각하여 정수형으로 캐스팅해서 읽었다. 문자열이 정수가 될 수 없으니 실행중에 예외를 일으키며 다운되어 버린다. 이 코드가 위험한 이유는 컴파일중에 잘못을 발견할 수 없다는 것이다. arNum에 임의의 데이터를 넣을 수 있지만 해당 요소가 어떤 타입일지 알 수 없어 컴파일러는 위험을 예측하지 못한다.

타입 불일치에 의한 캐스팅의 불편과 잘못된 캐스팅으로 인한 위험을 제거하기 위해 자바 5에 새로 등장한 개념이 제네릭이다. 제네릭은 클래스를 인수화하여 임의의 타입에 대해 동작하는 일반적인 알고리즘을 구현한다. 이 예제를 제네릭 버전으로 바꿔 보자.

genarraylist	실행결과
import java.util.*; class JavaTest { public static void main(String[] args) { ArrayList<Integer> arNum = new ArrayList<Integer>(); arNum.add(1); //arNum.add("문자열"); int value = arNum.get(0); System.out.println(value); } }	1

ArrayList 타입 대신 ArrayList<Integer> 타입으로 arNum 객체를 생성하여 이 배열은 정수형만 저장한다는 것을 명시한다. 제네릭의 타입 인수는 참조형만 가능하여 int 타입 대신 Integer 타입을 사용한다. 그러나 값을 저장하거나 꺼낼 때는 자동 박싱이 지원되어 정수 리터럴을 사용해도 무방하다.

이 배열에는 정수형만 저장할 수 있으며 다른 타입의 데이터를 저장하면 컴파일 타임에 에러 처리된다. 주석 처리된 문장의 주석을 풀어 보면 문자열 타입은 저장할 수 없다는 에러 메시지가 출력된다.

The method add(Integer) in the type ArrayList<Integer> is not applicable for the arguments (String)

컬렉션에 어떤 데이터가 저장될지 컴파일 타임에 미리 알 수 있어 잘못된 타입을 애초에 허용하지 않는다. 컴파일중에 실수를 미리 알 수 있다는 것은 굉장히 중요한 장점이며 코드의 안전성 및 생산성 향상 큰 기여를 한다.

배열에 저장되는 모든 데이터가 정수형임이 확실하니 요소를 읽을 때 캐스팅할 필요 없어 편리하며 잘못 캐스팅할 위험도 없어 안전하다. 제네릭을 사용할 때의 이점은 다음 두 가지이다.

① 컴파일시 타입을 체크할 수 있다.

② 캐스팅할 필요가 없어 편의성과 안전성이 향상된다.

제네릭의 주 활용처가 컬렉션이며 컬렉션을 위해 제네릭 문법이 등장했다고 해도 과언이 아니다. 사용만을 목적으로 한다면 여기까지만 알아도 무방하다. 또한 자바를 처음 공부하고 있다면 이하의 내용은 다소 학술적이므로 차후에 자바에 대한 경험을 어느 정도 쌓은 후에 공부하는 것이 좋다. 제네릭 클래스를 직접 만들거나 좀 더 깊은 곳까지 알고 싶다면 계속 읽어 보자.

18-1-2.제네릭 타입

제네릭 타입의 동작 방식과 내부를 알아보기 위해 제네릭 클래스를 직접 만들어 보고 제네릭이 왜 필요한지 연구해 보자.

intbox

실행결과

class IntBox { int value; IntBox(int value) { this.value = value; } int get() { return value; } void set(int value) { this.value = value; } } class DoubleBox { double value; DoubleBox(double value) { this.value = value; } double get() { return value; } void set(double value) { this.value = value; } } class JavaTest { public static void main(String[] args) { IntBox bi = new IntBox(1234); int biv = bi.get(); System.out.println(biv); DoubleBox bd = new DoubleBox(56.78); double bdv = bd.get(); System.out.println(bdv); } }

1234 56.78

~Box 클래스는 특정 타입의 변수 하나를 저장하는 래퍼로서 값을 저장하는 필드와 생성자, 액세서로 구성되어 있다. 예제에서는 편의상 하나의 값만 저장했는데 내부 필드를 배열로 바꾸면 여러 개의 값을 저장할 수 있다. 크기가 1로 고정된 컬렉션인 셈인데 이 클래스를 확장하고 관리 메서드를 추가하면 실제로 컬렉션이 된다.

정수 박스에 정수를 넣고 실수 박스에 실수를 넣은 후 다시 읽어 출력했다. 원래 넣었던 값이 잘 출력된다. 이 예제의 IntBox는 자바의 Integer 래퍼와 유사하다. 정수형을 저장하는 IntBox에는 정수만 저장할 수 있으며 실수를 저장하면 에러 처리된다.

IntBox bi = new IntBox(12.34);

값을 실제 저장하는 value 필드의 타입과 생성자가 받아 들이는 실인수의 타입이 다르기 때문이다. 그래서 저장하는 값에 따라 매 타입별로 클래스를 일일이 만들어야 하는데 클래스 개수가 무한대여서 현실적으로 이것은 불가능하다. 이 문제에 대한 과거의 해결책은 가장 최상위의 Object 타입을 활용하여 임의의 데이터를 저장하는 것이었다.

objectbox

실행결과

class ObjectBox { Object value; ObjectBox(Object value) { this.value = value; } Object get() { return value; } void set(Object value) { this.value = value; } } class JavaTest { public static void main(String[] args) { ObjectBox bi = new ObjectBox(1234); int biv = (int)bi.get(); System.out.println(biv); ObjectBox bd = new ObjectBox(56.78); double bdv = (double)bd.get(); System.out.println(bdv); } }

1234 56.78

Object는 정수와 실수는 물론이고 문자열까지 대입할 수 있는 가장 최상위의 루트여서 모든 데이터를 다 저장할 수 있다. 그러나 보다시피 읽을 때 캐스팅이 필요하고 실제 저장된 타입과 다르게 캐스팅하면 예외가 발생하는 위험이 있다. 값을 저장한다는 본연의 기능에는 충실하지만 타입 안정성이 없다. 이런 문제를 해결하기 위해 도입된 것이 바로 제네릭이다.

genbox	실행결과
class Box<T> { T value; Box(T value) { this.value = value; } T get() { return value; } void set(T value) { this.value = value; } } class JavaTest { public static void main(String[] args) { Box<Integer> bi = new Box<Integer>(1234); int biv = bi.get(); System.out.println(biv); Box<Double> bd = new Box<Double>(56.78); double bdv = bd.get(); System.out.println(bdv); } }	1234 56.78

Box라는 클래스를 정의하되 타입 인수 T를 받아들여 클래스 선언문에 이 타입을 사용하고 객체를 선언할 때 실제 타입을 밝힌다. 정수 박스는 Box<Integer> 타입을 사용하고 실수 박스는 Box<Double> 타입을 사용한다. 제네릭 타입을 정의해 두면 Box<Short>, Box<Human> 등 임의의 타입에 대해 적용할 수 있다.

제네릭이란 일반적이라는 뜻이며 타입 인수로 전달된 임의의 타입에 대해 잘 동작한다. 값을 꺼낼 때 캐스팅하지 않아도 되며 잘못 캐스팅하면 컴파일 에러로 처리되어 안전하다. 실습 편의상 주로 클래스를 만들어 보고 설명도 클래스 위주로 하는데 제네릭 클래스에 적용되는 모든 문법은 제네릭 인터페이스에도 동일하게 적용된다.

18-1-3.타입 인수

메서드의 인수처럼 제네릭의 타입 인수도 두 가지가 있다. 정의할 때는 짧고 간단한 이름을 쓰고 선언할 때 실제 적용할 타입을 전달한다.

l 형식 타입 인수(Type Parameter) : 제네릭을 정의할 때 임의의 타입을 받을 수 있음을 표기하는 인수이며 클래스명 뒤의 < > 괄호 안에 쓴다. 클래스명과 분명히 구분하기 위해 대문자 하나로 된 간략한 이름을 사용한다. 인수의 의미에 따라 주로 다음과 같은 이름이 사용된다.

인수명	설명
T	Type
E	Element
K	Key
V	Value
N	Number

l 실 타입 인수(Type Argument) : 제네릭 클래스의 객체를 생성할 때 전달하는 타입이며 클래스명 뒤의 < > 괄호 안에 실제 타입을 기술한다. 클래스 선언문의 형식 타입 인수 개수대로 실 타입 인수를 전달하며 실 타입 인수가 형식 타입 인수 자리에 대체된다.

앞에서 만든 Box 제네릭은 형식 타입 인수로 T를 사용했는데 임의 타입을 받아 들인다는 뜻으로 짧게 썼다. 클래스 본체에서 이 타입을 적용하는 모든 곳에 형식 타입 인수를 쓴다. value 필드의 타입, 생성자의 인수, get의 리턴값, set의 인수 등에 형식 타입 인수 T를 사용했다.

제네릭 클래스로부터 객체를 생성할 때 클래스 이름 뒤에 < > 괄호와 실 타입 인수를 전달하면 형식 타입 인수가 실 타입 인수로 대체된다. 마치 메서드의 형식 인수를 통해 실인수의 값이 전달되는 것과 같다. 예를 들어 Box<Integer> 타입의 객체 a를 생성하면 다음 클래스를 선언하는 것과 개념적으로 유사하다.

제네릭의 모든 T가 실 타입 인수로 대체되어 정수형을 저장하는 클래스가 된다. 이처럼 제네릭을 적용한 Box<Integer>를 파라미터화된 타입(Parameterized type)이라고 하며 하나의 타입으로 간주한다. Double이나 Human을 전달하여 선언한 Box<Double>, Box<Human>도 파라미터화된 타입이다.

자바의 제네릭에 대응되는 C++의 개념은 템플릿이며 도입 목적이 같고 사용 방법도 유사하다. 그러나 이 둘은 큰 차이가 있는데 템플릿은 실 인수에 따라 클래스의 복사본을 생성하는데 비해 제네릭은 그렇지 않다. 자바의 제네릭 타입은 딱 한 번만 컴파일되어 하나의 클래스 파일로 저장된다. 일반 클래스와 컴파일되는 방법이 같다. 과연 그런지 다음 예제로 테스트해 보자.

gencompile	실행결과
class Box<T> { T value; Box(T value) { this.value = value; } T get() { return value; } void set(T value) { this.value = value; } } class JavaTest { public static void main(String[] args) { Box<Integer> bi = new Box<Integer>(1234); Box<Double> bd = new Box<Double>(56.78); System.out.println(bi.getClass() == bd.getClass()); } }	true

정수형 박스 bi와 실수형 박스 bd를 생성하고 두 객체의 클래스를 비교하면 같은 것으로 조사된다. 즉 실 타입 인수가 무엇이든 Box<T>의 코드는 딱 하나 뿐이다. 그래서 C++에 비해 메모리 낭비가 없다. 제네릭 클래스도 참조형이므로 객체를 생성할 때 new 연산자를 사용한다. 이때 객체의 타입과 new 연산자의 타입은 보통 일치한다. 다음 선언문을 보자.

Box<Integer> bi = new Box<Integer>(1234);

bi가 Box<Integer> 타입이므로 new 연산자의 타입도 Box<Integer>이다. 너무 당연하지만 길고 복잡해서 몇 가지 간편한 표기법이 지원된다. 이 선언문에서 뒤쪽의 실 타입 인수 Integer는 꼭 필요치 않다. 그래서 자바 7 부터실 타입 인수를 생략할 수 있으며 타입 인수 자리에 빈 괄호만 써 주면 된다.

Box<Integer> bi = new Box<>(1234);

이렇게 써도 Box<> 괄호에 들어갈 타입을 컴파일러가 추론하여 Integer를 써 넣는다. <> 빈괄호만 적어 놓는 방법을 다이아몬드 표기법이라고 한다. 타입 인수가 여러 개이고 복잡할 때 무척 편리하다. 타입을 생략할 수 있다고 해서 아예 < > 괄호까지 생략해 버리면 안된다.

Box<Integer> bi = new Box(1234); // 경고

이렇게 되면 Box를 로타입(Raw Type)으로 인식하여 경고가 발생한다. 반드시 빈 괄호를 써서 이 자리에 타입이 필요함을 밝혀야 한다. 자바 10 이후에는 지역변수의 타입을 추론하는 기능이 추가되어 변수의 타입을 var라고 더 짧게 쓸 수 있다.

var bi = new Box<>(1234);

초기값의 리터럴이 정수형이니 <> 괄호 안의 실타입 인수는 Integer임을 추론할 수 있고 new 연산자의 대상이 Box<Integer>이니 bi의 타입도 자동으로 Box<Integer>일 수밖에 없다. 컴파일러가 점점 똑똑해져 표기법은 간편해졌지만 아직까지는 호환성에 불리하다.

메서드의 인수 개수에 제약이 없듯이 제네릭의 타입 인수 개수에도 제약이 없다. 보통 하나의 타입만 취하지만 여러 개의 타입 인수를 받아들일 수 있다. 자바 라이브러리의 해시맵이 2개의 타입 인수를 받는다.

public class HashMap<K,V>

해시는 키와 값의 쌍을 저장하는데 두 타입이 각각 다를 수 있어 타입 인수도 2개여야 한다. 3개 이상도 얼마든지 가능하지만 현실적으로는 2개 정도만 사용된다.

18-1-4.로타입

제네릭은 코드가 복잡해지는 단점이 있지만 타입 안정성이 높고 사용 편의성도 훌륭하다. 그러나 이 좋은 제네릭에도 치명적인 약점이 있다. 자바의 초기 버전부터 지원되던 것이 아니라 자바 5부터 비교적 늦게 도입되어 제네릭 이전의 코드와 이후의 코드가 혼재하는 상황이다.

제네릭 이전에 ArrayList를 잘 써 먹고 있었는데 제네릭이 도입되었으니 모두 ArrayList<T>로 바꾸라고 강제할 수는 없다. 그래서 자바는 역 호환성을 위해 타입 인수를 빼고 클래스명만 사용하는 로타입(Raw Type) 개념을 도입했다. ArrayList<T>의 로타입은 ArrayList이며 이 둘을 같이 사용할 수 있다. 과연 그런지 우리가 직접 만든 Box<T> 타입으로 테스트해 보자.

rawtype	실행결과
class Box<T> { T value; Box(T value) { this.value = value; } T get() { return value; } void set(T value) { this.value = value; } } class JavaTest { public static void main(String[] args) { Box rb = new Box(1234); int rbv = (int)rb.get(); System.out.println(rbv); } }	1234

클래스 선언문에는 Box<T> 제네릭으로 선언했지만 실제 사용할 때는 그냥 Box 타입으로 객체 rb를 생성했다. 컴파일은 되지만 안전하지 않다는 경고가 발생한다. Box는 제네릭인데 왜 로타입으로 사용하느냐는 뜻이며 타입 인수를 사용하라고 권한다.

Box is a raw type. References to generic type Box<T> should be parameterized

로타입은 타입 인수가 없어 제네릭 이전의 클래스와 같은 특성을 보인다. 위 예제의 Box는 타입에 대한 정보가 없어 Object를 저장하며 따라서 값을 읽을 때 캐스팅이 필요하다. 또한 캐스팅을 잘못하면 다운되는 위험성도 있다. 다음 코드는 예외를 일으킨다.

String a = (String)rb.get();

보다시피 로타입은 캐스팅도 해야 하고 실수하면 예외를 일으킨다. 그러나 이런 위험한 코드를 에러로 처리하지 않고 가벼운 경고로 처리할 수 밖에 없는 이유는 Box<T> 이전의 Box 타입을 사용하던 코드도 컴파일되어야 하기 때문이다. 논리적으로 위험하지만 과거의 소스를 위해 어쩔 수 없는 선택이다.

더 골치 아픈 문제는 로타입과 제네릭을 섞어서 사용할 수 있어야 한다는 점이다. 과거 소스의 일부에 제네릭을 적용할 수 있고 최신 소스도 과거의 모듈과 자료를 주고 받기 위해 로타입을 써야 한다. 그래서 자바는 두 형식을 섞어서 사용하는 규칙을 마련했다. 앞으로 제네릭만 사용할 것이라면 이하의 내용은 골치만 아플뿐 실용성이 없어 몰라도 상관없다.

로타입의 객체와 제네릭 타입의 객체를 상호 대입할 수 있는데 경우에 따라 경고 발생 여부가 다르다. 대입할 수 있다는 것은 곧 인수로 전달할 수 있다는 뜻이다. 먼저 로타입의 객체로 제네릭 타입의 객체를 대입받아 보자.

rawtype2	실행결과
class Box<T> { T value; Box(T value) { this.value = value; } T get() { return value; } void set(T value) { this.value = value; } } class JavaTest { public static void main(String[] args) { Box raw = new Box(1234); Box<Integer> para = new Box<Integer>(5678); raw = para; int value = (int)raw.get(); System.out.println(value); } }	5678

raw 타입의 변수에 para 타입의 객체를 대입했다. 타입이 다르지만 잘 대입되며 심지어 경고도 발생하지 않는다. 왜냐하면 para 객체에 저장 가능한 모든 데이터는 raw 객체에도 저장할 수 있기 때문이다. 단, raw 객체는 타입 정보가 없어 읽을 때 반드시 캐스팅해야 한다.

그러나 캐스팅을 잘못하면 예외를 일으키며 다운된다. 로타입을 쓴 개발자는 이런 불편함을 이미 알고 있지만 호환성 때문에 어쩔 수 없이 쓴 것이어서 컴파일러가 더 개입할 필요가 없다. 다음은 반대의 경우를 보자.

rawtype3	실행결과
class Box<T> { T value; Box(T value) { this.value = value; } T get() { return value; } void set(T value) { this.value = value; } } class JavaTest { public static void main(String[] args) { Box raw = new Box(1234); Box<Integer> para = new Box<Integer>(5678); para = raw; int value = para.get(); System.out.println(value); } }	1234

para 타입의 변수에 raw 타입의 객체를 대입했다. 에러는 발생하지 않지만 이 경우는 다음과 같은 경고가 발생한다.

Type safety: The expression of type Box needs unchecked conversion to conform to Box<Integer>

Box 로타입 객체에 대해서는 변환시 체크할 수 없어 안전하지 않다는 경고이다. raw 안에 애초에 뭐가 저장되어 있었는지 확실하지 않다. para는 타입 정보가 있어 캐스팅하지 않고도 값을 읽을 수 있으며 raw에 저장된 값이 정상적으로 잘 출력된다.

그러나 만약 Box에 문자열이 저장되어 있었다면 어떻게 될까? raw의 생성자로 문자열을 저장해 보자. raw는 Object를 저장하므로 정수나 문자열이나 다 저장할 수 있으며 컴파일중에는 에러를 발견할 수 없다.

Box raw = new Box("문자열");

그러나 이 객체를 대입받은 para는 자신이 가리키는 객체에 정수가 들어 있다고 철썩같이 믿고 있어 변환시 타입 체크를 생략한다. 제대로 만든 파라미터 타입 객체라면 타입을 체크할 필요가 전혀 없다. 그러나 태생적으로 불안정한 로타입을 대입받아 위험해졌으며 예외를 일으키고 다운되어 버린다.

그래서 위험하다는 경고가 발생하는 것이다. 만약 이 경고가 귀찮다면 설정에서 꺼 버릴 수도 있다. 로타입은 역호환성을 위해 불가피하게 지원하는 것일 뿐이며 구형 코드를 위해서 아직도 가끔 필요한 경우가 있다. 앞으로는 사용을 자재하고 가급적이면 제네릭 타입을 사용해야 한다.

18-1-5.제네릭 메서드

제네릭 메서드는 타입 파라미터를 받아 들인다. 제네릭 클래스와 개념은 유사하지만 타입 파라미터의 범위가 메서드 내부로 국한된다는 점이 다르다. 생성자를 포함하여 정적, 비정적 메서드 모두 제네릭일 수 있다. 제네릭 메서드의 타입 인수는 리턴 타입 앞의 < > 괄호 안에 표기하며 호출할 때도 타입을 밝힌다. 다음 예제로 제네릭 메서드의 선언 방식과 개념을 살펴보자.

genmethod	실행결과
class JavaTest { static <T> void print(T a) { System.out.println(a); } public static void main(String[] args) { JavaTest.<Integer>print(1234); JavaTest.<String>print("문자열"); } }	1234 문자열

print 메서드는 임의의 T 타입에 대한 인수 a를 전달받아 이 값을 콘솔로 출력하는 간단한 동작을 한다. 인수 a의 타입은 메서드를 호출할 때 실 타입 인수로 결정된다. 정수나 문자열이나 다 잘 출력된다.

호출 구문의 실타입 인수 지정문이 복잡하고 어색해 보인다. 다행히 메서드로 전달되는 실인수의 타입으로부터 유추할 수 있어 생략 가능하며 보통 메서드와 같이 자연스럽게 호출할 수 있다. 정적 메서드끼리의 호출이므로 JavaTest.도 생략 가능하다.

JavaTest.print(1234);

JavaTest.print("문자열");

제네릭 메서드의 본체는 인수로 전달되는 모든 타입에 대해 동작하는 코드만 작성해야 한다. 위 예제는 println 메서드가 임의의 타입을 받으므로 이상 없이 잘 동작하지만 간단한 연산자만 사용해도 컴파일이 안된다. 다음 코드를 보자.

static <T> T abs(T a) {

if (a > 0) {

return a;

} else {

return -a;

}

}

<T> T max(T a, T b) {

if (a > b) {

return a;

} else {

return b;

}

}

절대값을 찾거나 둘 중 큰 값을 조사하는 메서드를 제네릭으로 작성했는데 > 연산자가 모든 타입에 대해 동작하지 않아 제네릭이 될 수 없다. C++은 템플릿이 인스턴스화되기 전까지 문법 점검을 미루어 일단 컴파일 가능하다. 그러나 잘못된 타입을 쓰면 실행중 에러가 발생하며 개발자가 알아서 메서드 본체와 호환되는 타입을 사용해야 한다.

반면 자바는 파라미터를 제한하지 않는 한 모든 타입에 대해 동작 가능한 코드만 인정하여 더 엄격하다. 그래서 제네릭 메서드의 타입 인수는 메서드 본체에서 직접 사용되는 경우가 흔하지 않으며 주로 인수의 타입을 결정하는 용도로 사용된다.

genarg

실행결과

import java.util.ArrayList; class JavaTest { static <T> void dumpArray(ArrayList<T> ar) { for (T a : ar) { System.out.println(a); } } public static void main(String[] args) { ArrayList<String> yoil = new ArrayList<String>(); yoil.add("일요일"); yoil.add("월요일"); JavaTest.<String>dumpArray(yoil); ArrayList<Integer> score = new ArrayList<Integer>(); score.add(98); score.add(72); JavaTest.<Integer>dumpArray(score); } }

일요일 월요일 98 72

dumpArray 메서드는 ArrayList<T> 타입을 전달받아 콘솔로 덤프한다. 메서드 본체에서는 배열을 순회하며 요소를 꺼내 출력한다. 인수로 받을 배열의 요소 타입이 제각각이어서 타입 인수가 필요하며 호출할 때 어떤 타입의 배열인지 밝혀야 한다.