6 ███████████

1. 6 6 ███████████

2. 3rd Edition 소설같은 자바 since 2001 최 영 관 Powered by http://www.jabook.org 6장 배열, 제너릭, 컬렉션

3. 6.1 배경

4. 6.1.1 데이터 저장 공간 • 프로그래밍의 기본 • 데이터 저장 공간을 이해하는 것 • 데이터 저장공간 • 기본 데이터 타입의 변수 • 일반적인 클래스의 객체 • 배열(Array) 클래스 • 단순 용량적인 측면에서의 데이터 저장공간 • 컬렉션(Collection)류나 맵(Map)류의 클래스 • 자료구조적인 측면에서의 데이터 저장공간

5. 6.1.2 용량적인 저장 공간 • 10개의 int형 변수 선언 • int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9; • 배열을 이용한 10개의 int형 변수 선언 • int[] ar = new int[10]; • Top 클래스 • class Top { • //...클래스의 내용 • } • Top 클래스 객체 10개 선언 • Top t0, t1, t2, t3, t4, t5, t6, t7, t8, t9; • 배열을 이용한 Top 클래스 객체 10개 선언 • Top[] t = new Top[10]; a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9] t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9]

6. 6.1.3 자료구조적인 저장 공간 • 단순 저장공간의 문제 • 자료를 처리하는 방식의 문제(자료구조적인 측면) • 동적인 공간의 문제(메모리 공간) • 빠른 검색의 문제 • 배열 • 양적인 저장 공간 • 배열의 검색 • 사용자가 직접 전체 데이터를 확인해서 검색해야 한다. • 해결책 • 컬렉션류나 맵류의 클래스 사용

7. 6.2 배열

8. 6.2.1 배열의 소개 • 배열의 종류 • 기본 데이터 타입 배열 • 객체 배열 • 배열의 특징 • 같은 데이터 타입의 변수를 한꺼번에 여러 개 생성할 수 있다. • 배열의 검색 • 배열은 첨자를 통해서 배열 내에 존재하는 모든 변수를 검색할 수 있다. • 배열의 단점 • 배열을 생성할 때 첨자를 이용해서 배열의 크기를 정해버리면 배열의 크기를 변경할 수 없다.

9. 6.2.2 배열의 특징 • 배열의 특징 I • 같은 데이터 타입의 변수를 한꺼번에 여러 개 생성할 수 있다. • 배열의 크기는 배열의 첨자로 결정된다. • 첨자에 해당하는 만큼의 같은 데이터 타입을 가진 변수가 생성된다. • 배열의 특징 II • 배열의 요소는 변수이다. • 배열의 메모리는 연속적으로 잡히게 된다. • 배열의 특징 III • 배열의 이름은 연속된 변수들을 참조하기 위한 참조값이다. • 배열 자체는 객체이다. • int형 변수 10개를 만드는 구문(int형 배열의 생성) • int[] ar = new int[10]; • 배열을 위한 데이터 타입 • int[]는 데이터 타입이다. • int[]는 배열 클래스형이다. • 배열의 데이터 타입 • 배열 데이터 타입 = 기존의 데이터 타입 + [] • 기본 데이터 타입을 이용한 배열 클래스의 예 • byte[] • int[] • long[] • float[] • double[] • 클래스를 이용한 배열 클래스의 예 • String[] • Image[]

10. 6.2.3 배열의 분석 • 배열의 생성 • int[] ar = new int[10]; • 기본 데이터 타입 배열 • 기본 데이터 타입으로 배열을 선언하면 메모리의 생성을 의미한다. • 기본 데이터 타입은 변수의 선언과 동시에 메모리가 생성되기 때문에 기본 데이터 타입으로 배열을 선언하면 배열의 전체 메모리가 생성된다. • 배열의 정의 • 배열은 객체다. • 배열의 특징 • 배열의 첨자는 배열의 크기를 의미한다. • 배열의 이름은 참조값이다. • 배열끼리의 할당은 참조값 값복사다. • 배열의 개수를 확인하는 멤버 • 배열의 개수는 length 멤버를 이용해서 알 수 있다. • int[] ar = new int[10]; • int size = ar.length; // size는 10이 된다. 배열의 분석 배열 클래스 참조 변수 메모리 생성 연산자 배열 개수 지정 int[] ar = new int[10]; 데이터 타입 배열의 이름 배열의 생성 첨자 ar[0] 변수 ar[1] 변수 ar[2] 변수 참조 변수 ar[3] ar 변수 배열의 개수 = 첨자 int[] ar[4] 변수 배열 클래스명 변수 ar[5] ar[6] 변수 ar[7] 변수 ar[8] 변수 ar[9] 변수

11. 배열의 선언과 할당의 분리 int[] ar = new int [10]; ar[0] = 100; ar[1] = 200; ar[2] = 343; ar[3] = 325; ar[4] = 5; ar[5] = 2; ar[6] = 7; ar[7] = 30; ar[8] = 35; ar[9] = 43; 각각의 변수에 하나씩 값할당 배열의 선언과 동시에 초기화 int[] ar = new int[] {100, 200, 343, 325, 5, 2, 7, 30, 35, 43}; int[] ar = {100, 200, 343, 325, 5, 2, 7, 30, 35, 43}; 1 2 이 방법들은 선언과 초기화를 동시에 하는 방법이다. 위의 방법 둘 다 사용할 수 있다. 6.2.4 배열의 초기화 • 배열의 생성과 배열의 접근을 테스트하는 예제 • public class ArrayMain{ • public static void main(String[] args){ • int[] ap = new int[]{0,1,2,3,4,5,6,7,8,9}; • int[] aw = {10,11,12,13,14,15,16,17,18,19}; • int[] ad = new int[10]; //선언과 할당의 분리 • ad[0] = 20; ad[1] = 21; ad[2] = 22; ad[3] = 23; • ad[4] = 24; ad[5] = 25; ad[6] = 26; ad[7] = 27; • ad[8] = 28; ad[9] = 29; • //1. int[] ap 출력 • for(int i=0; i<ap.length; i++){ • System.out.print(ap[i] + "\t"); • } • //2. int[] aw 출력 • for(int i=0; i<aw.length; i++){ • System.out.print(aw[i] + "\t"); • } • //3. int[] ad 출력 • for(int i=0; i<ad.length; i++){ • System.out.print(ad[i] + "\t"); • } • } • }

12. 6.2.5 배열의 복사 • 부분 배열 복사를 위한 System.arraycopy() • int[] source = new int[]{5, 4, 6, 9, 7, 9}; • int[] target = {100, 200, 300, 400, 500, 600,700}; • //부분 배열 복사의 예 • System.arraycopy(source, 2, target, 3, 4); • for(int i=0; i<target.length; i++) { • System.out.println("target["+i+"]:" + target[i]); • } 배열의 참조값 값복사 int[] ar1 = new int[]{0,1,2,3,4,5,6,7,8,9}; int[] ar2 = ar1; 3 메모리 영역 4 Index Table new int[]{0,1,2,3,4,5,6,7,8,9} ar1[0] = 0; ar1[1] = 1; ar1[2] = 2; ar1[3] = 3; ar1[4] = 4; ar1[5] = 5; ar1[6] = 6; ar1[7] = 7; ar1[8] = 8; ar1[9] = 9; 참조값 실제 메모리 주소 1 객체의 실제 주소 2 10001 FFFF:07CA 배열의 실제 메모리 참조값 (해시코드) 실제 주소 • clone()을 이용한 메모리 차원의 배열복사 • int[] source = new int[]{5, 4, 6, 9, 7, 9}; • //clone()을 이용한 메모리 복사 • int[] target = (int[])source.clone(); • for(int i=0; i<target.length; i++){ • System.out.println("target["+i+"] : " + target[i]); • }

13. 6.2.6 객체 배열 • class Dog { • private String name; • private String kind; • public Dog(String name, String kind) { • this.name = name; • this.kind = kind; • } • public String toString() { • return kind + ":" + name; • } • } • public class ObjectArrayMain { • public static void main(String[] args) { • //1. 객체배열의 생성 • Dog[] dog = new Dog[5]; • for(int i=0; i<dog.length; i++) • System.out.println("Dog[" + i + "] : " + dog[i]); • //2. 객체배열의 참조 변수에 메모리할당 • dog[0] = new Dog("쫑쫑이","불독"); • dog[1] = new Dog("워리","똥개"); • dog[2] = new Dog("개똥이","진도개"); • dog[3] = new Dog("발리","푸들"); • dog[4] = new Dog("투덜이","잡종"); • for(int i=0; i<dog.length; i++) • System.out.println("Dog[" + i + "] : " + dog[i]); • } • } • 객체 배열 • 객체 배열을 선언했을 때 첨자의 수만큼 참조 변수가 만들어진다. • 각각의 참조 변수에 대한 객체의 메모리는 생성되지 않는다. • 기본 데이터 타입 배열 vs 객체 배열 • 기본 데이터 타입 배열은 배열 생성과 동시에 메모리가 생성된다. • 객체 배열은 객체 변수(참조 변수)의 이름들만 생성되고, 객체들의 실제 메모리는 생성되지 않는다.

14. 6.2.7 결론 • 자바의 배열 • 배열의 이름은 참조 변수다. • 자바에서 배열은 객체이다. • int[]까지가 배열 데이터 타입이다. • 자바의 배열 표기법 • int[] ar = new int[10]; • int ar[] = new int[10]; • 배열의 복사 • System.arraycopy()를 이용한 부분 배열 복사 • clone()을 이용한 배열 통복사 • NullPointerException • 객체 변수에 메모리가 없다.

15. 6.3 배열의 참조

16. 6.3.1 배열의 참조 매개변수의 참조값 값복사 • 배열끼리의 할당 • int[] ar1 = new int[]{0,1,2,3,4,5,6,7,8,9}; • int[] ar2 = ar1; • 객체의 참조값 • 객체의 참조값만 있으면 해당 객체를 핸들할 수 있다. int[] ar = new int[]{0,1,2,3,4,5,6,7,8,9}; 배열 매개변수로 메서드 호출 4 참조 값복사가 발생 3 메모리 영역 sum(ar); ar 에 10001의 참조값 temp 에 10001의 참조값 int[] temp = ar; 참조값 값복사 발생 new int[]{0,1,2,3,4,5,6,7,8,9} Index Table ar[0] = 0; ar[1] = 1; ar[2] = 2; ar[3] = 3; ar[4] = 4; ar[5] = 5; ar[6] = 6; ar[7] = 7; ar[8] = 8; ar[9] = 9; 참조값 실제 메모리 주소 5 2 배열의 실제 메모리 1 int sum ( int[] temp ) { //배열의 총합계산 } 객체의 실제 주소 10001 FFFF:07CA 메서드의 원형 참조값 실제 주소

17. 직접할당을 이용한 참조값 값복사 int[] aref = new int[]{0,1,2,3}; int[] bref = aref; int[] cref = bref; 메모리 영역 3 Index Table new int[]{0,1,2,3} 참조값 실제 메모리 주소 ar[0] = 0; ar[1] = 1; ar[2] = 2; ar[3] = 3; 배열의 실제 메모리 2 4 객체의 실제 주소 10001 1 FFFF:07CA 참조값 실제 주소 5 6.3.2 배열 할당의 참조 • int[]형의 배열 생성 • int[] aref = new int[]{0,1,2,3}; • 참조값 값복사(참조값 할당) • int[] bref = aref; • int[] cref = bref; • 주의할 점 • 배열의 이름은 참조 변수다. • 배열끼리 할당할 때 데이터 타입은 같아야 한다. • 위의 배열들은 데이터 타입이 모두 int[]이다.(aref, bref, cref)

18. 6.3.3 객체의 참조 • class Baby{ • private String name; • public void setName(String name){ • this.name = name; • } • public void cry() { • System.out.println(name + " 가(이) 응애응애"); • } • } • public class BabyRefMain { • public static void main(String[] args) { • Baby b = new Baby(); • b.setName("둘리"); • b.cry(); • Baby s = b; //참조값 값복사 발생 • s.setName("아기공룡"); • s.cry(); • b.cry(); • } • }

19. 6.3.4 매개변수로서의 배열 • class ArrayParam { • public int[] copyArray( int[] src) {//배열 복사를 위한 메모리를 메서드 내에서 생성 • int[] des = new int[src.length]; //새로운 배열 생성 • for(int i=0; i<src.length; i++) • des[i] = src[i]; //값복사 • return des; • } • public void copyArray (int[] src, int[]des) {//배열 복사를 위한 메모리를 매개변수로 받음 • for(int i=0; i<src.length; i++) • des[i] = src[i]; //값복사 • } • } • int[] source = new int[]{1,2,3,4,5}; //배열 생성 • ArrayParam p = new ArrayParam(); //객체 생성 • 1. copyArray(int[] src) 호출 • int[] result = p.copyArray(source); • for(int i=0; i<result.length; i++){ • System.out.println("result["+i+"] : " + result[i]); • } • 2. copyArray(int[] src, int[] des) 호출 • int[] target = new int[source.length]; • p.copyArray(source, target); • for(int i=0; i<target.length; i++) { • System.out.println("target["+i+"] : " + target[i]); • }

20. 2차원 배열의 선언과 초기화를 동시에 int[][] ar = new int[][]{{100, 200, 300}, {400,500,600}}; int[][] ar = {{100, 200, 300}, {400,500,600}}; 1 선언과 동시에 초기화 (배열의 개수는 자동으로 [2][3]이 된다) 클래스명 2 선언과 동시에 초기화 (배열의 개수는 자동으로 [2][3]이 된다) 클래스명 이 방법들은 선언과 초기화를 동시에 하는 방법입니다. 위의 방법 둘 다 사용할 수 있습니다. 2차원 배열의 선언과 할당의 분리 배열 클래스 참조 변수 메모리 생성 연산자 배열 개수 지정 int[][] ar = new int[2][3]; ar[0][0] = 100 ar[0][1] = 200 ar[0][2] = 300 변수 변수 참조 변수 ar int[][] 변수 배열의 개수 = 2 X 3 배열 클래스명 ar[1][0] = 400 ar[1][1] = 500 ar[1][2] = 600 변수 변수 변수 6.3.5 다차원 배열 • int[][] src = new int[][]{{100,200,300}, {400,500,600}}; • int[][] tar = {{701,702,703}, {704,705,706}}; • //int[][] src의 정보출력 • System.out.print("src.length:" + src.length + "\t"); • System.out.print("src[0].length:" + src[0].length + "\t"); • System.out.println("src[1].length:" + src[1].length); • //int[][] tar의 정보출력 • System.out.print("tar.length:" + tar.length + "\t"); • System.out.print("tar[0].length:" + tar[0].length + "\t"); • System.out.println("tar[1].length:" + tar[1].length); • //2차원 배열의 출력 • for(int i=0; i<src.length; i++) • for(int j=0; j<src[i].length; j++){ • System.out.print("src[" + i + "][" + j + "]=" + src[i][j] + "\t"); • System.out.print("tar[" + i + "][" + j + "]=" + tar[i][j] + "\n"); • } • //for문에 블록이 없으면 한 줄에 영향을 준다.

21. 2차원 배열의 분석(배열의 배열) 참조변수 배열 클래스 메모리 생성 연산자 배열 개수 지정 int[][] ar = new int[2][3]; 배열의 이름 배열의 생성 첨자 첨자 데이터 타입 배열 1차원 배열 ar ar[0] ar[0][0] = 100 1차원 배열 변수 참조변수 참조변수 ar[0][1] = 200 변수 배열의 배열 원소는 3개 원소는 2개 ar[0][2] = 300 변수 배열의 개수 = 2 X 3 배열 1차원 배열 ar[1] 변수 ar[1][0] = 400 참조변수 배열의 배열 2차원 배열은 배열의 배열입니다. ar의 원소는 ar[0], ar[1] 변수 원소는 3개 ar[1][1] = 500 변수 ar[1][2] = 600 2차원 배열의 분석(배열의 배열)

22. 6.3.6 배열의 배열과 참조의 참조 • 배열끼리의 직접할당 & 객체끼리의 직접할당 • 배열의 메모리가 복사되지 않고 참조값 값복사가 이루어진다. • 객체의 메모리가 복사되지 않고 참조값 값복사가 이루어진다. • Top 클래스 • class Top{ • public String s; • public String p; • } • 참조 변수의 참조 변수 • Top t = new Top(); • t.s = new String("Hello"); • t.p = new String("Hi"); • 참조 변수의 참조 변수와 배열의 배열 • 참조 변수의 참조 변수의 원리는 배열의 배열과 유사한 원리로 되어 있다. Top t = new Top(); Hello String s String p Hi

23. 6.4 Generic(자바 5.0)

24. 6.4.1 제너릭(Generic)이란? • Generic 이란 • 클래스에 사용할 타입을 디자인시에 지정하는 것이 아니라 클래스를 사용할 때 지정한 후 사용하는 기술을 말한다. • Object형을 매개변수로 사용한 예 • class Top{ • private Objectdata = null; • public void setData(Object data){ • this.data = data; • } • public Object getData(){ • return this.data; • } • } • Generic을 매개변수로 사용한 예 • class Top<T>{ • private T data = null; • public void setData(T data){ • this.data = data; • } • public T getData(){ • return this.data; • } • } Object형은 어떠한 형으로도 캐스팅가능하기 때문에 형을 알 수 없을 때에는 Object형을 사용하였다. String str = "Hello Object 방식"; Top t = new Top(); t.setData(str); String str2 = (String)t.getData(); 사용할 형을 컴파일러에게 알려준다. String str = "Hello Generic 방식"; Top<String> t = new Top<String>(); t.setData(str); String str2 = t.getData(); Top<String>을 사용했기 때문에 getData() 메서드는 String형을 리턴한다. T라는 타입은 아직 정해지지 않았으며 사용할 때 결정한 후 사용한다.

25. 6.4.2 C++의 제너릭의 원리 • C++의 경우 • 제너릭을 사용하는 순간 컴파일러는 해당 제너릭에 대한 형을 새로 만든다. • Top<String> t1 = new Top<String>(); • Top<Integer> t2 = new Top<Integer>(); Top<String> Top<Integer> class Top<Integer>{ privateIntegerdata = null; public void setData(Integer data){ this.data = data; } public IntegergetData(){ return this.data; } } class Top<String>{ privateString data = null; public void setData(String data){ this.data = data; } public StringgetData(){ return this.data; } } Top<String>과 Top<Integer>를 사용했기 때문에 컴파일러는 이것을 보고 Top<String>과 Top<Integer>에 해당하는 형을 통째로 만든다.

26. 6.4.3 Java의 제너릭의 원리 • 자바의 제너릭 • 자바 컴파일러는 Top<String>이나 Top<Integer>를 만나게 되면 <String>과 <Integer>를 삭제(Erasure)한 후, 컴파일러는 적절한 곳에 캐스팅(casting)으로 대체한다. • 코드 내에서 Top<String>형 클래스의 사용 • Top<String>t = new Top<String>(); • t.setData(str); • String str2 = t.getData(); • 자바 컴파일러가 제너릭을 처리하는 방식 • Top t = new Top(); • t.setData(str); • String str2 = (String)t.getData(); Top<String>은 클래스의 형이 아니라 캐스팅을 판단하기 위한 표시이다. 자동으로 제거된다. 제너릭이 자동으로 붙여준다. C++에서는 제너릭이 하나의 형이지만 자바에서는 캐스팅을 판단하기 위한 표시이다. 그렇기 때문에 자바의 제너릭은 리플렉션이 적용되지 않는다. 이것은 자바의 제너릭이 타입(형)이 아니기 때문이다.

27. 6.4.4 제너릭의 Collection 적용 • 제너릭의 표현 • class Vector <E> • 요소(Element)를 제너릭 <E>로 표현한다. • class Hashtable <K, V> • 키(Key)를 제너릭 <K>로, 값(Value)을 제너릭 <V>로 표현한다. • 자바 5.0 이전 버전의 Vector 사용 • Vector v1 = new Vector(); • v1.add(new String("Hello World")); • String str1 = (String)v1.elementAt(0); • 자바 5.0 이상 버전의 Vector 사용 • Vector<String> v2 = new Vector<String>(); • v2.add(new String("Hello World")); • String str2 = v2.elementAt(0); 사용자가 직접 캐스팅을 해주어야 한다. 두개 중 어느것을 사용해도 상관 없다. 이전 버전과의 호환성이 중요하다면 제너릭을 사용하기 보다는 사용자가 직접 캐스팅하는 방법을 이용하기 바란다. 캐스팅을 해주지 않아도 된다.(컴파일러가 알아서 캐스팅 해줌)

28. 6.5 Collection과 Map

29. 6.5.1 배열의 발전된 형태 • 배열의 발전된 모델 • 컬렉션(Collection)과 맵(Map) 계열의 클래스 • 배열과 컬렉션이나 맵계열의 클래스와의 차이점 • 배열은 크기를 동적으로 늘릴 수 없지만 컬렉션이나 맵 계열의 클래스는 동적으로 메모리를 확장할 수 있다. • Collection류와 Map류의 클래스 • 자료구조적인 기능의 클래스 • Collection과 Map 인터페이스 • Collection과 Map은 인터페이스이기 때문에 메서드의 프로토타입만 존재한다. • Collection을 구현해서 사용하면 집합적인 저장공간으로서의 기능을 구현한 클래스가 된다. • Map을 구현해서 사용하면 검색적인 저장공간으로서의 기능을 구현한 클래스가 된다.

30. 6.5.2 Collection과 Map의 특징 • Collection과 Map 유형이 배열과 구분되는 점 • 동적 메모리 확장 • Collection과 Map류는 객체만을 저장의 대상으로 한다. • Collection의 삽입과 삭제를 위한 추상 메서드 • boolean add(Object o) • boolean remove(Object o) • Map의 삽입과 삭제를 위한 추상 메서드 • Object put(Object key, Object value) • Object remove(Object key) boolean add(E o) boolean remove(Object o) 자바 1.4까지 자바 5.0(자바 1.5)부터 V put(K key, V value) V remove(Object key) 자바 5.0(자바 1.5)부터 자바 1.4까지

31. 6.5.3 Collection과 Map의 상속구조 LinkedList 링크드리스트 Stack 스택자료구조 List Vector 순서가 있는 저장 공간 동기화 보장 Collection ArrayList 동기화 보장하지 않음 순서나 집합적인 저장공간 HashSet Set계열의 대표클래스 Set 집합적인 저장 공간 SortedSet 정렬을 위한 Set 계열의 클래스 Hashtable Map 동기화 보장하는 Map 계열의 클래스 HashMap TreeSet 키와 값으로 데이터 핸들 동기화 보장하지 않는 Map 계열의 클래스 SortedMap TreeMap 정렬을 위한 Map 계열의 클래스

32. 6.5.4 Collection 인터페이스 • Collection 인테페이스의 특징 • 이것을 구현한 클래스들은 모두 집합적인 저장공간으로서의 기능을 가진다. • Collection 인터페이스를 구현하고 있는 클래스 • Stack, Vector, LinkedList, TreeSet, HashSet • Collection 인터페이스의 데이터 삽입 삭제를 위한 추상 메서드 • boolean add(Object o); • 객체를 삽입하는 메서드 • boolean remove(Object o); • 특정 객체를 삭제하는 메서드 • Collection 인터페이스의 데이터 확인을 위한 추상 메서드(5.0이전 이후 동일) • boolean isEmpty(); • 비어 있는지 확인하는 메서드 • boolean contains(Object o); • 특정 객체가 포함되어 있는지 확인하는 메서드 • int size(); • 포함된 객체의 수를 리턴하는 메서드 • Collection 인터페이스의 데이터를 배열로 얻기 위한 추상 메서드 • Object[] toArray(); • 포함된 모든 객체들을 배열 형태로 리턴하는 메서드 boolean add(E o) boolean remove(Object o) 자바 5.0(자바 1.5)부터 자바 1.4까지 T[] toArray() 자바 5.0(자바 1.5)부터 자바 1.4까지

33. 6.5.5 Map 인터페이스 • Map 인터페이스의 특징 • Collection과 달리 Map은 검색적인 개념을 담고 있는 인터페이스 • Map으로 구현된 클래스 • Attributes, HashMap, Hashtable, TreeMap • Map 인터페이스의 데이터 삽입 삭제를 위한 추상 메서드 • Object put(Object key, Object value); • 데이터를 삽입하는 메서드 • Object remove(Object key); • 키(key)를 이용해서 데이터를 제거하는 메서드 • Object get(Object key); • 키(key)를 이용해서 데이터를 검색하는 메서드 • Map 인터페이스의 데이터 확인을 위한 추상 메서드(자바 5.0 이전 이후 동일) • boolean isEmpty(); • 비어 있는지 확인하는 메서드 • boolean containsKey(Object key); • 특정 키가 있는지 확인하는 메서드 • boolean containsValue(Object value); • 특정 데이터가 있는지 확인하는 메서드 • int size(); • 포함된 객체가 몇 개인지 확인하는 메서드 V put(K key, V value); V remove(Object key); V get(Object key); 자바 5.0(자바 1.5)부터 자바 1.4까지

34. 6.6 컬렉션 클래스 비교

35. LinkedList Stack Collection List Vector 동기화보장 ArrayList 동기화보장하지 않음 6.6.1 Vector와 ArrayList의 비교 • Vector와 ArrayList의 공통점 • 순서가 있는 Collection이다. • List 인터페이스를 구현하고 있다. • 데이터를 중복해서 포함할 수 있다. • Vector와 ArrayList의 차이점 • Vector는 자동으로 동기화를 보장해준다. • ArrayList는 동기화를 보장해주지 않는다. • ArrayList의 동기화 지원 방법 • List list = Collections.synchronizedList(new ArrayList(...)); • Vector와 ArrayList의 기능 • ArrayList는 배열에 동적 메모리 증가 기능을 구현한 클래스이다. • Vector는 ArrayList에 동기화가 보장되도록 최적화한 클래스이다.

36. Hashtable Map 동기화보장 HashMap 동기화보장하지 않음 SortedMap 6.6.2 Hashtable, HashMap의 비교 • Hashtable, HashMap의 공통점 • 내부적으로 모두 Hash 기법을 이용한다. • Map 인터페이스를 구현하고 있다. • 키(Key)와 값(Value)을 이용해서 데이터를 관리한다. • Hashtable과 HashMap • Hashtable은 동기화가 보장 되지만 HashMap은 동기화가 보장되지 않는다. • HashMap의 동기화 지원 방법 • Map m = Collections.synchronizedMap(new HashMap(...)); • Hashtable, HashMap과 HashSet과의 관계 • Hashtable과 HashMap은 둘다 Map 인터페이스를 구현하고 있다. • HashSet은 내부적으로 Hash기법을 사용하지만 Set 인터페이스를 구현하고 있다.

37. LinkedList Stack Collection List Vector ArrayList 순서의개념, 중복허용 집합의개념, 중복불허 HashSet Set SortedSet 6.6.3 ArrayList와 HashSet의 비교 • ArrayList와 HashSet의 공통점 • 객체의 저장공간이다. • 동기화를 보장하지 않는다. • ArrayList와 HashSet의 차이점 • ArrayList • List 인터페이스를 구현하는 클래스이다. • 순서의 개념이 있다. • 데이터의 중복을 허용한다. • HashSet • Set 인터페이스를 구현하는 클래스이다. • 순서의 개념이 아니라 집합의 개념이 있다. • 데이터의 중복을 허용하지 않는다. • ArrayList와 HashSet의 기능 • 순서가 중요한 의미를 가진다면 ArrayList를, 순서는 중요하지 않고 데이터가 중복되지 않기를 원한다면 HashSet을 이용하면 된다.

38. HashSet Collection Set SortedSet Map Hashtable TreeSet HashMap TreeMap SortedMap 6.6.4 Sorted와 Not Sorted의 비교 • Sorted를 지원하지 않음 • HashSet, HashMap • Sorted를 지원하는 함 • TreeSet과 TreeMap • TreeMap • Key와 Value로 데이터 관리 • Key를 기준으로 오름차순으로 정렬된다. • Map 인터페이스를 상속한 SortedMap 인터페이스를 구현한 클래스 • TreeSet • Set을 인터페이스를 상속한 SortedSet 인터페이스를 구현한 클래스 • 데이터들이 자동으로 오름차순으로 정렬된다. • Comparator 인터페이스 • TreeSet과 TreeMap은 사용자가 직접 정렬의 방식을 지정할 수 있다. • TreeSet과 TreeMap은 정렬을 위한 Comparator 인터페이스를 구현하면 된다.

39. 6.7 Collection 계열 클래스

40. 6.7.1 Stack • import java.util.*; • public class StackMain{ • public static void main(String[] args) { • Stack<String> stack = new Stack<String>(); • System.out.println(stack.empty()); • stack.push(new String("jabook")); • stack.push(new String("java")); • stack.push(new String("소설같은 자바")); • System.out.println(stack.empty()); • System.out.println(stack.peek()); • System.out.println(stack.pop()); • System.out.println(stack.peek()); • System.out.println(stack.search("jabook")); • } • } Collection List LinkedList Stack Vector ArrayList

41. LinkedList Stack Collection List Vector ArrayList 6.7.2 ArrayList • import java.util.*; • public class ArrayListMain{ • public static void main(String args[]) { • ArrayList<String> list = new ArrayList<String>(); • list.add("홍길동"); • list.add("김삿갓"); • list.add("이몽룡"); • list.add("성춘향"); • list.add("변사또"); • System.out.println(list); • System.out.println("Index 2 : " + list.get(2)); • System.out.println("Index 0 : " + list.get(0)); • String[] arList = new String[list.size()]; • list.toArray(arList); • System.out.println("Index 1 : " + arList[1]); • System.out.println("Index 3 : " + arList[3]); • } • }

42. 6.7.3 HashSet • import java.util.*; • public class HashSetMain{ • public static void main(String args[]) { • Set<String> set = new HashSet<String>(); • set.add("김삿갓"); • set.add("홍길동"); • set.add("춘향이"); • set.add("이도령"); • set.add("향단이"); • System.out.println("HashSet : " + set); • set.remove("이도령"); • System.out.println(set.contains("홍길동")); • Iterator<String> iter = set.iterator(); • while(iter.hasNext()){ • String temp = iter.next(); • System.out.print(temp + ", "); • } • System.out.println(); • } • } HashSet Collection Set SortedSet

43. LinkedList Stack List Collection Vector ArrayList 6.7.4 Vector I • public class VectorMain { • public static void main(String[] args) { • Vector<String> v = new Vector<String>();//Vector 객체 생성 • System.out.println("Vector 생성 직후의 size : " + v.size()); • v.addElement(new String("망아지")); • v.addElement(new String("송아지")); • v.addElement(new String("강아지")); • v.addElement(new String("병아리")); • System.out.println("Vector에 데이터 삽입 후의 size : " + v.size()); • for(int i=0; i< v.size(); i++){ • String temp = v.elementAt(i); • System.out.println("Vector v의 " + i + "번째 :" + temp); • } • } • } Vector v에 데이터가 삽입된 순서 Vector v = new Vector(); v.addElement(new String(”망아지")); v.addElement(new String("송아지")); v.addElement(new String("강아지")); v.addElement(new String("병아리")); 인덱스 : 0 인덱스 : 1 인덱스 : 2 인덱스 : 3 new String("망아지") new String(”송아지") new String(”강아지") new String(”병아리")

44. 6.7.5 Vector II • Vector<Object> v = new Vector<Object>(); //객체 생성 • v.addElement(new Character('A')); //Wrapper 클래스의 사용 • v.addElement(new String("굼뱅이")); • v.addElement(new Integer(100)); //Wrapper 클래스의 사용 • v.addElement(new Integer(200)); //Wrapper 클래스의 사용 • System.out.println("Vector의 size():" + v.size()); • v.insertElementAt(new Float(3.141592), 1); • System.out.println("insertElementAt()-size():" + v.size()); • v.setElementAt("Hello", 3); • System.out.println("setElement()-size():" + v.size()); • System.out.println("v의0번째:" + (Character)v.elementAt(0)); • System.out.println("v의1번째:" + (Float)v.elementAt(1)); • System.out.println("v의2번째:" + (String)v.elementAt(2)); • System.out.println("v의3번째:" + (String)v.elementAt(3)); • System.out.println("v의4번째:" + (Integer)v.elementAt(4)); • if(v.contains("Hello")){ //데이터가 있는지 확인 • int find = v.indexOf("Hello"); //데이터 위치 확인 • //위치(인덱스)를 이용한 데이터의 추출 • System.out.println("v의" + find + "번째:" + (String)v.elementAt(find)); • } Vector v에 객체삽입 1번째에 중간삽입, 1번째에 있던 데이터는 2번째가 된다. 3번째 존재하는 데이터를 수정 삽입한 데이터 타입이 다르기 때문에 하나씩 추출한 뒤 형변환 후 사용 "Hello" 검색

45. 6.7.6 AutoBoxing(자바 5.0) • 자바 1.4까지 • Vector v = new Vector(); //객체 생성 • v.addElement(new Integer(100)); //Wrapper 클래스의 사용 • v.addElement(new Integer(200)); //Wrapper 클래스의 사용 • Integer t0 = (Integer)v.elementAt(0); • Integer t1 = (Integer)v.elementAt(1); • 자바 5.0 이후 • Vector<Integer> v = new Vector<Integer>(); • v.addElement(100); //AutoBoxing 발생 • v.addElement(200); //AutoBoxing 발생 • int a0= v.elementAt(0);//AutoUnBoxing 발생 • int a1 = v.elementAt(1);//AutoUnBoxing 발생 자바 5.0 이상에서는 컴파일러가 내부에서 자동으로 객체를 적절한 상수값으로 변경시켜 준다. 자바 5.0 이상에서는 컴파일러가 내부에서 자동으로 Wrapper 클래스의 객체로 변경시켜 준다.

46. 6.8 Map 계열 클래스

47. 6.8.1 HashMap • import java.util.*; • public class HashMapMain{ • public static void main(String args[]) { • Map<String, Integer> map = new HashMap<String, Integer>(); • map.put("홍길동", new Integer(1)); • map.put("김삿갓", new Integer(2)); • map.put("이도령", new Integer(3)); • map.put("춘향이", new Integer(4)); • map.put("향단이", new Integer(5)); • System.out.println(map.get("홍길동")); • System.out.println(map.get("김삿갓")); • System.out.println(map.get("이도령")); • System.out.println(map.get("춘향이")); • System.out.println(map.get("향단이")); • } • } Key Value Hashtable HashMap SortedMap Map

48. 6.8.2 Hashtable • import java.util.Hashtable; • public class HashtableMain { • public static void main(String[] args) { • Hashtable<String, Object> h = new Hashtable<String, Object>(); • //Hashtable에 키와 데이터의 삽입 • h.put("Name", new String("홍길동")); • h.put("Age", new Integer(27)); • h.put("Tel", new String("02-1111-2222")); • h.put("Handphone", new String("017-777-9999")); • h.put("Etc", new String("I'm a boy")); • //키 값을 이용해서 객체 추출 • String name = (String)h.get("Name"); • Integer age = (Integer)h.get("Age"); • } • } Key Value Hashtable HashMap SortedMap Map

49. 6.9 Sorted 계열 클래스

50. 6.9.1 TreeSet과 TreeMap • HashSet을 이용한 TreeSet 생성 • Set<String> set = new HashSet<String>(); • set.add(new String("김삿갓")); • set.add(new String("홍길동")); • set.add(new String("춘향이")); • set.add(new String("이도령")); • set.add(new String("향단이")); • TreeSet<String> ts = new TreeSet<String>(); • ts.addAll(set); • HashMap을 이용해서 TreeMap 생성 • Map<String, Integer> map = new HashMap<String, Integer>(); • map.put("홍길동", new Integer(1)); • map.put("김삿갓", new Integer(2)); • map.put("이도령", new Integer(3)); • map.put("춘향이", new Integer(4)); • map.put("향단이", new Integer(5)); • Map<String, Integer>sortedMap = new TreeMap<String, Integer>(); • sortedMap.putAll(map); HashSet TreeSet Set sorted 기능을 이용하기 위해서 HashMap TreeMap Map sorted 기능을 이용하기 위해서