Java_컬렉션 제네릭

컬렉션(Collection)

• 요소(element) 객체들의 저장소
   - 객체들의 컨테이너
   - 요소의 개수에 따라 크기 자동 조절
   - 요소의 삽입, 삭제에 따른 요소의 위치 자동 이동
• 고정 크기의 배열을 다루는 어려움 해소
• 다양한 객체들의 삽입, 삭제, 검색 등의 관리 용이
• 컬렉션은 제네릭(generics) 기법으로 구현됨
  // 제네릭
   - 모든 종류의 데이터 타입을 다룰 수 있도록 일반화된 타입 매개 변수로 클래스나 메소드를 작성하는 기법
   - 타입 매개 변수 : <E>, <K>, <V>     // ex. Vector<E> -> Vector<Integer>
• 컬렉션의 요소는 객체만 가능
   - 기본적인 int, char, double 등의 기본 타입 사용 불가 ( JDK1.5부터 박싱/언박싱으로 기본 타입을 객체로 자동 변환 )

배열(array)	컬렉션(collection)
- 고정 크기 이상의 객체를 관리할 수 없다.  - 배열의 중간에 객체가 삭제되면 응용프로그램에서 자리를 옮겨야 한다.	- 가변 크기로서 객체의 개수를 염려할 필요 없다.  - 컬렉션 내의 한 객체가 삭제되면 컬렉션이 자동으로 자리를 옮겨준다.

컬렉션 인터페이스 - Collection<E>, Set<E>, List<E>, Queue<E>, Map<K, V>
컬렉션 클래스 - HashSet<E>, ArrayList<E>, Vector<E>, Stack<E>, LinkedLisk<E>, HashMap<K, V>

 

컬렉션과 자동 박싱 / 언박싱

// JDK 1.5 이전 // 기본 타입 데이터를 Wrapper 클래스로 사용 Vector<Integer> v = new Vector<Integer>(); v.add(Integer.valueOf(4)); Integer n = (Integer)v.get(0); int k = n.intValue();

// JDK 1.5 부터 // 자동 박싱/언박싱 작동 Vector<Integer< v - new Vector<Integer>(); v.add(4); // 4 -> Integer.valueOf(4) 자동 박싱 int k = v.get(0); // Integer 타입이 int 타입으로 자동 언박싱

 

컬렉션의 순차검색을 위한 Iterator

• Iterator<E> 인터페이스
   - Vector<E>, ArrayList<E>, LinkedList<E>가 상속받는 인터페이스
   - 리스트 구조의 컬렉션에서 요소의 순차 검색을 위한 메소드 포함
• Iterator<E> 인터페이스 메소드

메소드	설명
boolean hasNext()	방문할 요소가 남아 있으면 true 리턴
E next()	다음 요소 리턴
void remove()	마지막으로 리턴된 요소 제거

• iterator()메소드 : Iterator 객체 반환
   - iterator 객체를 이용하여 인덱스 없이 순차적 검색 가능

// Iterator
Vector<Integer> v = new Vector<Integer>();
Iterator<Integer> it = v.iterator();	// 첫 번째 데이터 가리킴
while(it.hasNext()){	// 모든 요소 방문
    int n = it.next();	// 다음 요소 방문
	...
}

// 예제
import java.util.*;

public class IteratorEx{
	public static void main(String args){
    	// 정수 값만 다루는 제네릭 벡터 생성
        Vector<Integer> v = new Vector<Integer>();
        v.add(5);	// 삽입
        v.add(4);
        v.add(-1);
        v.add(2, 100);	// 5, 4, 100, -1
        
        // Iterator 이용한 모든 정수 출력
        Iterator<Integer> it = v.iterator();
        while(it.hasNext()){
        	int n = it.next();
            System.out.println(n);
        }
        
        // Iterator 이용해 모든 정수 더하기
        int sum=0;
        it = v.iterator()	// Iterator 객체 얻기
        while(it.hasNext()){
        	int n = it.next();
            sum += n;
        }
        System.out.println("백터에 있는 정수 합: " + sum);
    }
}

 

Vector<E>

• java.util.Vector
   - <E>에서 E 대신 요소로 사용할 특정 타입으로 구체화
• 여러 객체들을 삽입, 삭제, 검색하는 컨테이너 클래스
   - 배열의 길이 제한 극복
   - 원소의 개수가 넘쳐나면 자동으로 길이 조절
• Vector 삽입
   - 객체, null 삽입 가능
   - 기본 타입은 Wrapper객체로 만들어 저장
   - 벡터 맨 뒤에 객체 추가
   - 벡터 중간에 객체 삽입
• Vector 객체 삭제
   - 임의의 위치에 있는 객체 삭제 가능 : 객체 삭제 후 자동 자리 이동
• 스레드 동기화
   - 항상 동기화되서 멀티 스레드 환경에서 안전하게 객체를 추가, 삭제 가능 

메소드	설명
boolean add(E element)	벡터의 맨 뒤에 element 추가
void add(int index, E element)	인덱스 index에 element를 삽입
int capacity()	벡터의 현재 용량 리턴
boolean addAll(Collection<? extends E> c)	컬렉션 c의 모든 요소를 벡터의 맨 뒹에 추가
void clear()	벡터의 모든 요소 삭제
boolean contains(Object o)	벡터가 지정된 객체 o를 포함하고 있으면 true 리턴
E elementAt(int index)	인덱스 index의 요소 리턴
E get(int index)	인덱스 index의 요소 리턴
int indexOf(object o)	o와 같은 첫 번째 요소의 인덱스 리턴, 없으면 -1 리턴
boolean isEmpty()	벡터가 비어 있으면 true 리턴
E remove(int index)	인덱스 index의 요소 삭제
boolean remove(Object o)	객체 o와 같은 첫 번째 요소를 벡터에서 삭제
void removeAllElements	벡터의 모든 요소를 삭제하고 크기를 0으로 만듦
int size()	벡터가 포함하는 요소의 개수 리턴
Object[] toArray()	벡터의 모든 요소를 포함하는 배열 리턴

// 정수만 다루는 백터 생성, 활용
import java.util.Vector;

public class VectorEx{
	public static void main(String[] args){
    		Vector<Integer> v = new Vector<Integer>();
        v.add(5);	// 요소 삽입
        v.add(4);
        v.add(-1);
        v.add(2, 100);	// 요소 중간에 삽입
        // 5, 4, 100, -1
        
        System.out.println("백터 내의 요소 객체 수 : " + v.size());	// 4
        System.out.println("백터의 현재 용량 : " + v.capacity());	// 10
        
        //모든 정수 요소 출력하기
        for(int i=0; i<v.size(); i++){
        	int n = v.get(i);
            System.out.println(n);
        }
        
        // 백터 속의 모든 정수 더하기
        int sum = 0;
        for(int i=0; i<v.size(); i++){
        	int n = v.elementAt(i);
            sum += n;
        }
        System.out.println("백터에 있는 정수 합 : " + sum);	// 108
    }
}

// point 클래스만 다루는 백터
import java.util.*;

class Point{
	private int x, y;
    public Point(int x, int y){	// 생성자
    	this.x = x;
        this.y = y;
    }
    public String toString(){
    	return "(" + x + "," + y + ")";
    }
}

public class PointVectorEx{
	public static void main(String[] args){
    	Vector<Point> v = new Vector<Point>();
        // Point 객체 삽입
        v.add(new Point(2, 3));
        v.add(new Point(-5, 20));
        v.add(new Point(30, -8));
        
        v.remove(1);	// 인덱스 1의 Point(-5, 20) 객체 삭제
        
        // 벡터에 있는 Point 객체 모두 검색하여 출력
        for(int i=0; i<v.size(); i++){
        	Point p = v.get(i);
            System.out.println(p);	// p.toString()을 이용하여 객체 p 출력
        }	// (2,3)\n(30,-8)
    }
}

// 컬렉션을 매개변수로 받는 메소드의 원형
public void printVector(Vector<Integer> v){
	for(int i=0; i<v.size(); i++){
    	int n = v.get(i);
        System.out.println(n);
    }
}

public static void main(String[] args){
	Vector<Integer> v = new Vector<Integer>();	// Integer 백터 생성
    pirntVector(v);	// 메소드 호출
}

 

ArrayList<E>

• java.util.ArrayList, 가변 크기 배열을 구현한 클래스
   - <E>에서 E 대신 요소로 사용할 특정 타입으로 구체화
• ArrayList에 삽입/ 삭제
   - 객체, null 삽입 가능
   - 기본 타입은 박싱/언박싱으로 Wrapper 객체로 만들어 저장
   - 리스트의 맨 뒤에 객체 추가
   - 리스트의 중간에 객체 삽입
   - 임의의 위치에 있는 객체 삭제 기능
• 백터와 달리 스레드 동기화 기능 없음
   - 다수 스레드가 동시에 ArrayList에 접근할 때 동기화되지 않음
   - 개발자가 스레드 동기화 코드 작성

메소드	설명
boolean add(E element)	ArrayList의 맨 뒤에 element 추가
void add(int index, E element)	인덱스 index 위치에 element 삽입
boolean addAll(Collection<? extends E> c)	컬렉션 c의 모든 요소를 ArrayList의 맨 뒤에 추가
void clear()	ArrayList의 모든 요소 삭제
boolean contains(Object o)	ArrayList가 지정된 객체를 포함하고 있으면 true 리턴
E elementAt(int index)	index 인덱스의 요소 리턴
E get(int index)	index 인덱스의 요소 리턴
int indexOf(Object o)	o와 같은 첫 번째 요소의 인덱스 리턴, 없으면 -1 리턴
boolean isEmpty()	Arraylist가 비어있으면 true 리턴
E remove(int index)	index 인덱스의 요소 삭제
boolean remove(Object o)	o와 같은 첫 번째 요소를 ArrayList에서 삭제
int size()	ArrayList가 포함하는 요소의 개수 리턴
Object[] toArray()	ArrayList의 모든 요소를 포함하는 배열 리턴

import java.util.*;

public class ArrayListEx{
	public static void main(String[] args){
    	ArrayList<String> a = new ArrayList<String>();
        // var a = new ArrayList<String>();
        // ArrayList<String> a = new ArrayList<>(); 모두 가능
        
        // 키보드로부터 4개의 이름 입력받아 ArrayList에 삽입
        Scanner sc = new Scanner(System.in);
        for(int i=0; i<4; i++){
        	System.out.println("이름을 입력하세요 > ");
            String s = sc.next();
            a.add(s);
        }
        
        // ArrayList에 들어 있는 모든 이름 출력
        for(int i=0; i<a.size(); i++){
        	String name = a.get(i);
            System.out.print(name + " ");
        }
        
        // 가장 긴 이름 출력
        int longindex = 0;
        for(int i=0; i<a.size(); i++){
        	if(a.get(longindex).length() <a.get(i).length())
            	longindex = i;
        }
        System.out.println("\n가장 긴 이름은 : " + a.get(longindex));
    }
    scanner.close();
}

 

LinkedList<E>

• java.util.LinkedList
   - E에 요소로 사용할 타입 지정하여 구체화
• List 인터페이스를 구현한 컬렉션 클래스
   - Vector, ArrayList 클래스와 매우 유사하게 작동
• 요소 객체들은 양뱡향으로 연결되어 관리됨
   - 요소 객체는 맨 앞, 맨 뒤에 추가 가능
   - 요소 객체는 인덱스를 이용하여 중간에 삽입 가능
   - 맨 앞이나 맨 뒤에 요소를 추가하거나 삭제할 수 있어 스택이나 큐로 사용 가능

 

HashMap<K, V>

• 키(key)와 값(value)의 쌍으로 구성되는 요소를 다루는 컬렉션
   - java.util.HashMap
   - K는 키로 사용할 요소 타입, V는 값으로 사용할 요소의 타입 지정
   - 키와 값이 한 쌍으로 삽입
   - 키는 해시맵에 삽입되는 위치 결정에 사용
   - 값을 검색하기 위해서는 반드시 키 이용
• 삽입, 삭제, 검색이 빠른 특징
   - 요소 삽입 : put() 메소드
   - 요소 검색 : get() 메소드
• ex. HahsMap<String, String> 생성, 요소 삽입, 요소 검색

HashMap<String, String> h = new HashMap<String, String>();
h.put("apple", "사과");	// "apple" 키와 "사과" 값의 쌍을 해시맵에 삽입
String kor = h.get("apple");	// "apple" 키로 값 검색. kor = "사과"

 

메소드	설명
void clear()	해시맵의 모든 요소 삭제
boolean containsKey(Object key)	지정된 키(key)를 포함하고 있으면 true 리턴
boolean containsValue(Object value)	지정된 값(value)에 일치하는 키가 있으면 true 리턴
V get(Object key)	지정된 키(key)의 값 리턴, 키가 없으면 null 리턴
boolean isEmpty()	해시맵이 비어 있으면 true 리턴
Set<K> keySet()	해시맵의 모든 키를 담은 Set<K> 컬렉션 리턴
V put(K key, V value)	key와 value 쌍을 해시맵에 저장
V remove(Object key)	지정된 키(key)를 찾아 키와 값 모두 삭제
int size()	HashMap에 포함된 요소의 개수 리턴

// (영어, 한글) 단어 쌍의 저장 검색 (exit 입력시 프로그램 종료)
import java.util.*;
public class HashMapDicEx{
	public static void main(String[] args){
    	HashMap<String, String> dic = new HashMap<String, String>();
        dic.put("baby", "아기");
        dic.put("love", "사랑");
        dic.put("apple", "사과");
        
        Scanner sc = new Scanner(System.in);
        while(true){
        	System.out.print("찾고 싶은 단어는? ");
            String en = sc.next();
            if(en.equals("exit")){
            	System.out.println("종료합니다.");
                break;
            }
            String ko = dic.get(en);
            if(ko == null)
            	System.out.println(en + "는 없는 단어 입니다.");
            else
            	System.out.println(ko);
        }	// while
        sc.close();
    }
}

// 자바 과목의 이름과 점수 관리
import java.util.*;

public class HashMapScoreEx{
	public static void main(String[] args){
    	HashMap<String, Integer> jc = new HashMap<String, Integer>();
        jc.put("김", 97);
        jc.put("이", 88);
        jc.put("박", 98);
        jc.put("최", 80);
        jc.put("정", 99);

        System.out.println("HashMap의 요소 개수 : " + jc.size());
        // 모든 사람의 점수 출력
        Set<String> keys = jc.keySet();
        Iterator<String> it = keys.iterator();
        while(it.hasNext()){
            String k = it.next();
            System.out.println(k + " : " + jc.get(k));
        }// while
    }// main
}

// 객체 저장, 학생 정보 관리
// id와 전화번호로 구성되는 Student클래스=v, 이름=k인 해시맵
import java.util.*;

class Student{
	private int id;
    private String tel;
    
    public Student(int id, String tel){
    	this.id = id;
        this.tel = tel;
    }
    public int getId(){
        return id;
    }
    public String getTel(){
        return tel;
    }
}

public class HashMapStudentEx{
	public static void main(String[] args){
    	HashMap<String, Student> map = new HashMap<String, Student>();
        map.put("철수", new Student(1, "010-1111-1111"));
        map.put("영희", new Student(2, "010-2222-2222"));
        map.put("명은", new Student(3, "010-3333-3333"));
        
        Scanner sc = new Scanner(System.in);
        while(true){
        	System.out.print("검색할 이름? ");
            String n = sc.next();
            if(n.equals("exit")) break;
            
            Student s = map.get(n);
            if(s == null)
            	System.out.println(n + "은 없는 사람입니다.");
            else
            	System.out.println("id : " + s.getId() + ", 전화 : " + s.getTel());
        }
        sc.close();
    }
}

 

Collections 클래스의 활용

• java.util 패키지에 포함
• 컬렉션에 대한 연사을 수행하고 결과로 컬레션 리턴
• 모든 메소드는 static 타입
• 주요 메소드
   - sort() : 컬렉션에 포함된 요소들을 정렬
   - reverse() : 요소의 순서를 반대로 하는 메소드
   - max(), min() : 요소들의 최대, 최솟값을 찾는 메소드
   - binarySearch() : 특정 값을 검색

import java.util.*;

public class CollectionsEx {
	static void printList(LinkedList<String> I){
    	Iterator<String> it = I.iterator();
        while(it.hasNext()){
        	String s = it.next();
            String separator = it.hasNext()? "->" : "\n";
            System.out.print(e + separator);
        }
    }
    
    public static void main(String[] args){
    	LinkedList<String> myList = new LinkedList<String>();
        myList.add("트랜스포머");
        myList.add("스타워즈");
        myList.add("매트릭스");	// 트랜스포머, 스타워즈, 매트릭스
        myList.add(0, "터미네이터");	// 터미네이터, 트랜스포머, 스타워즈, 매트릭스
        myList.add(2, "아바타");	// 터미네이터, 트랜스포머, 아바타, 스타워즈, 매트릭스
        
        Collections.sort(myList);	// 요소 정렬
        printList(myList);	// 매트릭스->스타워즈->아바타->터미네이터->트랜스포머
        
        Collections.revers(myList);	// 요소 반대로
        printList(myList);	// 트랜스포머->터미네이터->아바타->스타워즈->매트릭스
        
        int index = Collections.binarySearch(myList, "아바타") + 1;
        System.out.println("아바타는 " + index + "번째 요소입니다.");
    }
}