반응형

 

1. Map인터페이스란?

 

 - Map인터페이스는 키(key)와 값(value)을 하나의 쌍으로 묶어서 저장하는 컬렉션 클래스를 구현하는 데 사용됩니다.

   키는 중복될 수 없지만 값은 중복을 허용합니다. 왜냐하면 값을 추출하기 위해서는 key객체에 대응하는 value객체를 반환하는데

   중복된 key객체가 있을 경우 어떠한 key객체를 찾아야하는지 모르기 때문입니다.

  

 - 기존에 저장된 데이터와 중복된 키와 값을 저장하면 기존의 값은 없어지고 마지막에 저장된 값이 남게 됩니다.

   다음은 Map인터페이스의 상속계층도입니다.

 

<사진 1.1> Map인터페이스의 상속계층도

 

2. HashMap컬렉션 클래스

 

 - HashMap<K,V>컬렉션은 java.util패키지에 속한 컬렉션 클래스이다. HashMap은 내부에 '키'와 '값'을 저장하는 자료 구조를 가지고,

   다음과 같이 put()메서드와 get()메서드를 이용하여 요소를 삽입하거나 검색합니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        HashMap<StringString> hm = new HashMap<StringString>();
        hm.put("apple""사과");
        hm.put("banana""바나나");
        
        System.out.println(hm.get("apple"));
        System.out.println(hm.get("banana"));
        
    }    
}
cs

<사진 1.2> HashMap컬렉션 클래스의 put(), get()메서드 사용 방법

 

 - 8~9번째 코드가 실행되고 나면 HashMap에서는 아래와 같은 형태로 데이터가 저장됩니다.

<사진 1.2 코드 표>

 

 - put(key, value)메서드를 사용하여 "appple"이라는 이름을 갖는 key와 "사과"라는 이름을 갖는 value를 저장합니다.

   그리고 get(key)메서드를 사용하여 key에 대응하는 value 값을 반환합니다. 만약 해시맵에 없는 '키'로 get()을 호출하면 null값을 리턴합니다.

   다음은 결과 화면입니다.

 

1
2
3
hm.put("a","1");
hm.put("b","2");
hm.put("b","3");
cs

 

 - 만약 위와 같은 코드가 실행되고 나면 HashMap에는 아래와 같은 형태로 데이터가 저장됩니다.

 

 

 - 3개의 데이터 쌍을 저장했지만 실제로는 2개 밖에 저장되지 않은 이유는 중복된 키가 있기 때문입니다. 세 번째로 저장한 데이터의 키인

   'b'는 이미 존재하기 때문에 새로 추가되는 대신 기존의 값을 덮어씁니다. 그래서 키 'b'에 연결된 값은 '3'이 됩니다.

 

<사진 1.2 결과 화면>

 

2-1 HashMap의 장단점

 

 장점 :

  1) 요소의 삽입, 삭제 시간이 매우 빠릅니다. 요소의 위치를결정하는 해시 함수가 간단한 코드로 이루어지며, Vector나 ArrayList 컬렉션 클래스처럼

     요소의 삽입 삭제 시 다른 요소들의 위치 이동이 필요 없기 때문입니다.

  2) 요소 검색은 더욱 빠릅니다. HashMap의 get(key)메서드가 호출되면 해시 함수가 ket가 저장된 위치를 단번에 찾아내므로,

      Vector나 ArrayList 컬렉션 클래스처럼 모든 요소들을 하나씩 비교하는 시간 낭비가 전혀 없기 때문이다.

 단점 :

  1) HashMap은 인덱스를 이용하여 요소에 접근할 수 없고 오직  '키'로만 검색해야 합니다. 그러므로 HashMap은 빠른 삽입과 검색이

     필요한 응용에 적합합니다.

 

2-2 HashMap 생성

 

 - HashMap<K, V>에서 K는 '키'로 V에는 '값'으로 사용할 구체적인 타입을 지정하여 사용합니다. 다음은 키와 값을 모두 String 타입으로 지정한

   코드입니다.

 

1
HashMap<StringString> hm = new HashMap<StringString>();
cs

<사진 1.3> HashMap 생성

 

2-3 HashMap 주요 메서드

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        HashMap<StringString> hm = new HashMap<StringString>();
        hm.put("apple""사과"); // "apple"은 키, "사과"는 값
        hm.put("banana""바나나");
        hm.put("grape""포도");
        System.out.println("첫 번째 요소 :"+hm.get("apple")); // "apple"키에 대응하는 값을 반환
        System.out.println("두 번째 요소 :"+hm.get("banana"));
        System.out.println("hm 내에 있는 요소의 개수 :"+hm.size()); // 현재 hm 내에 있는 요소의 개수 리턴
        hm.remove("apple"); // "apple"키를 갖는 키와 값을 삭제
        System.out.println("첫 번째 요소를 삭제한 결과:"+hm.get("apple"));
    }    
}
cs

<사진 1.4> HashMap컬렉션 클래스 주요 메서드

 

 - 요소 삽입, 추출, 크기 확인, 삭제의 기능을 가진 메서드입니다. 다음은 결과 화면입니다.

 

<사진 1.4 결과 화면>

반응형
반응형

 

 

 - Enumeration, Iterator, ListIterator는 모두 컬렉션에 저장된 요소를 접근하는데 사용되는 인터페이스입니다.

   Enumeration은 Iterator의 구버전이며, ListIterator는 Iterator의 기능을 향상 시킨 것입니다. 자, 이제 하나씩 자세히 살펴보겠습니다.

 

1. Iterator 인터페이스

 

 - Vector 컬렉션 클래스, ArrayList 컬렉션 클래스, LinkedList 컬렉션 클래스와 같이 요소가 순서대로 저장된 컬렉션에서 요소를 순차적으로 검색할 때는

   java.util 패키지에 속한 Iterator 인터페이스를 사용하면 편리합니다.

 

 - List인터페이스 뿐만 아니라, Set인터페이스를 구현한 컬렉션에도 사용 가능합니다. 다음은 Iterator인터페이스의 주요 메서드입니다.

 

 

<사진 1.1> Iterator인터페이스 메서드

 

 - hasNext()메서드와 next()메서드는 Iterator의 핵심 메서드입니다.

 - remove()메서드의 설명에 '선택적 기능'이란 Iterator인터페이스를 구현할 때 remove()메서드가 필수 기능이 아니므로 구현하지

   않아도 괜찮다는 뜻 입니다. 

 - 다음은 ArrayList에 저장된 모든 요소들을 출력하기 위한 코드입니다.

 

1
2
3
4
5
6
List lit = new ArrayList();
 
Iterator it = list.iterator();
while(it.hasNext()) {
    System.out.println(it.next());
}
cs

<사진 1.2>

 

- ArrayList컬렉션 클래스 대신에 List인터페이스를 구현한 다른 컬렉션 클래스(Vector, LinkedList 등)에 대해서도 이와 동일한 코드를

  사용할 수 있습니다. 첫 줄에서 ArrayList대신에 List인터페이스를 구현한 다른 컬렉션 클래스의 객체를 생성하도록 변경하기만 하면 됩니다.

** Map인터페이스는 Collection인터페이스의 자손이 아니므로 iterator()메서드가 존재하지 않습니다.

   Map인터페이스를 구현한 컬렉션 클래스(HashMap, SortedMap 등)는 키(Key)와 값(Value)을 쌍(pair)으로 저장하고 있기 때문에

   iterator()를 직접 호출할 수 없습니다. 그 대신 keySet()이나 entrySet()과 같은 반환 타입이 Set컬렉션인 메서드를 통해서

   키와 값을 각각 따로 Set의 형태로 얻어 온 후에 Set컬렉션에는 iterator()가 존재하므로 iterator()를 호출하여 Iterator를 얻을 수 있습니다.

 

- 다음은 ArrayList에 있는 요소들을 Iterator를 사용하여 읽어 오는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("1");
        al.add("2");
        al.add("3");
        al.add("4");
        al.add("5");
        
        Iterator it = al.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }    
}
 
cs

<사진 1.3>

 

 다음은 결과 화면입니다.

 

<사진 1.3 결과 화면>

 

 

2. Enumeration 인터페이스

 

 - Enumeration인터페이스는 컬렉션 프레임웍이 만들어지기 이전에 사용하던 것으로 Iterator의 구버전이라고 생각하면 됩니다.

   이전 버전으로 작성된 소스와의 호환을 위해서 남겨 두고 있을 뿐이므로 가능하면 Enumeration대신 Iterator를 사용하도록 합시다.

 

 - 다음은 Enumeration인터페이스의 메서드입니다. Enumeration은 Iterator와 메서드 이름만 다를 뿐 기능은 같습니다.

 

<사진 1.4> Enumeration인터페이스의 메서드

 

 

3. ListIterator 인터페이스

 

 - ListIterator인터페이스는 Iterator를 상속받아서 기능을 추가한 것입니다. 컬렉션의 요소에 접근할 때 Iterator는 단방향으로만 이동할 수

   있지만 ListIterator는 양방향으로 이동이 가능하다는 장점이 있습니다. 또한 ArrayList나 LinkedList처럼 List인터페이스를 구현한 컬렉션

   클래스에서만 사용할 수 있습니다.

 

 - 다음은 ListIterator인터페이스의 메서드입니다.

 

<사진 1.5> ListIterator인터페이스의 메서드

 

 

 - 다음은 ListIterator인터페이스의 양방향 접근이 가능한 previous()메서드를 호출하여 이전 요소로 접근해보는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("1");
        al.add("2");
        al.add("3");
        al.add("4");
        al.add("5");
        
        ListIterator li = al.listIterator(); // 순방향으로 진행하면서 요소를 읽어옵니다.
        
        while(li.hasNext()) {
            System.out.println(li.next());
        }
        System.out.println("-----------");
        
        while(li.hasPrevious()) { // 역방향으로 진행하면서 요소를 읽어옵니다.
            System.out.println(li.previous());
        }
        
        
    }    
}
cs

<사진 1.6> ListIterator인터페이스의 previous()메서드 사용

 

 - Iterator인터페이스는 단방향으로만 이동하기 때문에 컬렉션의 마지막 요소에 다다르면 더 이상 사용할 수 없지만,

   ListIterator인터페이스는 양방향으로 이동하기 때문에 각 요소간의 이동이 자유롭습니다. 다만 이동하기 전에 hasNext()메서드나

   hasPrevious()메서드를 호출하여 이동할 수 있는지 확인해야합니다.

반응형
반응형

 

1. Vector클래스란?

 

 - Vector 클래스는 ArrayList클래스와 같이 컬렉션 프레임웍에서 가장 많이 사용되는 컬렉션 클래스 일 것입니다.

   이 둘은List 인터페이스를 구현하기 때문에 List인터페이스의 특징인

   1. 저장순서를 유지하며

   2. 중복을 허용합니다.

   라는 특징을 가지고 있습니다.

 

 - Vector클래스의 기능을 개선 한 것이 ArrayList클래스입니다. Vector 클래스는 기존에 작성된 소스와의 호환성을 위해서 계속 남겨 두고 있을

   뿐이기 때문에 가능하면 Vector클래스보다 ArrayList클래스를 사용하는 것이 바람직하다고 할 수 있습니다.

   다음은 Vector클래스와 ArrayList클래스의 공통점과 차이점을 나타내는 표입니다.

 

<사진 1.1> Vector클래스와 ArrayList클래스의 비교

 

2. 벡터 생성하는 방법

 

 - 벡터를 생성할 때, Vector<E>의 E에 요소로 사용할 타입을 지정하면 됩니다. 예를 들어, 정수 값만 삽입 가능한 벡터를 만들고자 한다면

   다음과 같이 E 요소에 Integer를 지정하여 벡터를 생성하면 됩니다.

 

       Vector<Integer> v = new Vector<Integer>();

 

   만약 문자열만 삽입 가능한 벡터를 만들고 싶으면 다음과 같이 벡터를 생성하면 됩니다.

 

       Vector<String> v = new Vector<String>();.

 

   만일 Vector<E>에서 E 요소에 구체적인 타입을 지정하지 않는다면 컴파일러가 경고 메시지를 출력합니다.

 

3. Vector 클래스의 주요 메서드

 

 1) 벡터에 요소 삽입

 

   - add() 메서드를 사용하여 벡터의 끝이나 중간에 요소를 삽입할 수 있습니다. 다음은 정수 1, 2, 3을 순서대로 벡터에 삽입하는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
    }    
}
cs

<사진 1.2> add() 메서드 사용

 

   - 벡터 v에는 Integer 외의 다른 타입의 객체를 삽입할 수 없습니다. 현재 제네릭이 Integer로 선언되어 있는데

     add() 메서드의 인자 값으로 정수형이 아닌 다른 타입을 삽입할 경우에는 오류가 발생합니다.

 

<사진 1.3>

 

   - 초기에 선언한 Integer 타입이 아닌 문자열 3을 삽입하였으니 빨간 줄이 생기면서 컴파일 오류가 발생하였습니다.

   - 참고로 벡터에는 null값을 삽입할 수 있기 때문에, 벡터를 검색할 때 null값이 존재할 수 있음을 염두해 두어야 합니다.

 

   - 다음은 add()메서드를 사용하여 벡터의 중간에 객체를 삽입해보겠습니다. 다음은 현재 벡터 v에 [1, 2, 3]이 저장 되어 있지만

     인덱스 1번 위치에 100 요소를 삽입해보는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        
        v.add(1,100);
    }    
}
 
cs

<사진 1.4>

 

 - v.add(1,100); 는 인덱스 1의 위치에 정수 100을 삽입한다는 코드입니다. 다음은 결과 화면입니다.

 

<사진 1.4 결과 화면>

 

 - 결과를 보면 기존의 인덱스 1 위치에 있던 2와 그 뒤에 있던 3이 모두 한 자리씩 뒤로 이동했습니다.

   만약 벡터에 1개의 요소(인덱스 0의 위치)만 들어있는 상태인데 2의 위치에 요소를 삽입할 경우엔 예외가 발생합니다. 왜냐하면

   인덱스 1이 빈 공간이 되기 때문입니다.

 

 2) 벡터 내의 요소 알아내기

 

   - 벡터 내에 존재하는 요소를 알아내기 위해서는 get() 메서드와 elementAt() 메서드를 사용합니다. 다음은 get()메서드를 사용한 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        v.add(4);
        v.add(5);
        
        for(int i=0; i<v.size(); i++) {
            System.out.println(v.get(i));
        }
    }    
}
 
cs

<사진 1.5>

 

 - 벡터 v에 정수 1, 2, 3, 4, 5를 삽입했습니다. 벡터 v에 있는 모든 요소들을 순서대로 출력하기 위해 for문을 사용했습니다.

 - v.get(0)이 실행될 경우 벡터 v가 가리키고 있는 0번째 인덱스의 값을 추출합니다.

 

 - 다음은 현재 벡터 v의 상태를 그림으로 표현했습니다.

 

<사진 1.6>

 

 - 벡터 v는 0x100(임의의 주소로 아무렇게나 정한 것입니다)이라는 주소 값을 갖고 있는 위치를 가리키고 있습니다.

   현재 0x100위치에는

   0번 인덱스에 1,

   1번 인덱스에 2,

   2번 인덱스에 3,

   3번 인덱스에 4,

   4번 인덱스에 5라는 값을 저장하고 있습니다. 그래서 v.get(0)메서드를 호출할 경우 벡터 v가 가리키고 있는 0번째 인덱스 값인 1을 반환합니다.

   다음은 <사진 1.5> 코드의 결과 화면입니다.

 

<사진 1.5 결과 화면>

 

 - 벡터 v가 가리키고 있는 모든 요소들을 출력했습니다.

 

 3) 벡터에서 요소 삭제

 

 - 벡터 내의 임의의 인덱스에 있는 요소를 삭제할 수 있습니다. remove() 메서드를 사용하면 됩니다.

 

       v.remove(1); // 벡터 v가 가리키고 있는 1번째 인덱스의 값을 삭제하는 코드입니다.

 

 - 다음은 remove() 메서드를 사용한 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        v.add(4);
        v.add(5);
        
        v.remove(1);
        
        for(int i=0; i<v.size(); i++) {
            System.out.println(v.get(i));
        }
    }    
}
 
cs

<사진 1.7>

 

 - 현재 벡터 v는 정수 1, 2, 3, 4, 5를 배열로 저장하고 있는 상태에서 14번째 줄 코드에서 remove()메서드를 사용하여 인덱스 1 위치에 있는 요소를

   삭제하고 벡터 v가 저장하고 있는 모든 요소들을 출력하고자 합니다. 다음은 결과 화면입니다.

 

<사진 1.7 결과 화면>

 

 - 인덱스 1 위치에 있던 정수 2를 삭제 하여 뒤에 있던 요소들이 한 자리씩 앞으로 이동하였습니다.

 

 - 벡터의 모든 요소를 삭제하고자 한다면 v.removeAllElements(); 를 호출하면 됩니다.

반응형

+ Recent posts