ch13. 컬렉션 프레임워크

ch13. 컬렉션 프레임워크

13-1. 컬렉션 프레임워크

[컬렉션 프레임워크]

: 자료구조 개념 이용하여 객체들을 효율적으로 관리하고자

           java.util 패키지에서 제공하는 인터페이스, 구현 클래스들을 총칭함

: 인터페이스(사용 방법 정의) + 구현 클래스(실체)

   = 컬렉션 인테페이스 (List/Set/Map) + 컬렉션 클래스(구현 클래스)

🟩[List 컬렉션] : List 인터페이스

: 객체들을 인덱스로 관리

: 저장 용량 자동 증가, 자동 인덱스 부여

: 객체 자체를 저장 X 객체의 번지를 참조 O

<특징>

• 객체 저장 순서 유지
• 객체 중복 저장 O
• null 저장 O

[List 컬렉션 메소드]

객체 추가

• 맨 끝에 객체 추가 : add(객체);
• 지정 인덱스에 객체 추가 : add(인덱스, 객체);
• 지정 인덱스 객체 교체 : set(인덱스, 객체);

객체 검색

• 객체 존재 여부 조사 : contains(객체);
• 지정 인덱스의 객체 리턴 : get(인덱스);
• 저장된 전체 객체 수 리턴 : size();
• 빈 컬렉션인지 조사 : inEmpty();

객체 삭제

• 모든 객체 삭제 : clear();
• 지정 인덱스 객체 삭제 : remove(인덱스);
• 지정 객체 삭제 : remove(객체);

[List 컬렉션 저장 모든 객체 대상 하나씩 처리]

(1) 인덱스 이용하는 방법

List<타입> list = ...;

for (int i=0; i< **list.size()**; i++) {

객체타입 변수 = **list.get(i)**;

}

(2) 향상된 for문 이용하는 방법

List<타입> list = ...;

**for(객체타입 변수 : list)** { //list 컬렉션 내부 돌면서 객체 하나씩 타입변수 저장, for내부 실행

}

[List 인터페이스의 구현 클래스]

(1) [[ArrayList]] : 배열 방식으로 객체 저장

: 기본 생성자로 ArrayList객체 생성 시 초기 용량 : 10개 객체 저장 O

ArrayList 생성

List<타입> list = new ArrayList<타입> ();

List<타입> list = new ArrayList<>(); // 생략 시 왼쪽 타입 따름

(2) [[Vector]] : 동기화된 메소드로 구성

: 멀티 스레드가 동시에 Vector의 메소드 실행 불가능

: 스레드 안전

Vector 생성

List<타입> list = new Vector<타입>();

List<타입> list = new Vector<>(); //생략 시 왼쪽 타입 따름

(3) [[LinkedList]] : 인접참조 링크로 체인처럼 관리

: 특정 인덱스 제거/삽입 시 이음새만 변경. 앞뒤 링크만 수정

: 중간 인덱스 빈번히 변경 일어나면 LinkedList 효율적

: 처음 생성 시 내부는 빈 상태

LinkedList 생성

List<타입> list = new LinkedList<타입>();

List<타입> list = new LinkedList<>(); //생략 시 왼쪽 타입 따름

🟩[Set 컬렉션] : Set 인터페이스

<특징>

• 객체 저장 순서 유지X
• 객체 중복 저장 X
• 하나의 null만 저장 O

[Set 컬렉션 메소드]

객체 추가

• 중복 객체 아닌 경우 저장 : add(객체); // 중복객체 -> F리턴

객체 검색

• 객체 존재 여부 검사 : contains(객체);
• 빈 컬렉션인지 조사 : isEmpty();
• 저장된 한 번씩 가져오는 반복자 리턴 : Iterator<타입> iterator();
• 저장된 전체 객체 수 리턴 : size();

객체 삭제

• 모든 객체 삭제 : clear();
• 지정 객체 삭제 : remove(객체);

[Set 컬렉션 저장 모든 객체 대상 하나씩 처리]

(1) 반복자를 이용하는 방법

Set<String> set = ...;   //컬렉션 내부 생성 
Iterator<String> iterator = set.iterator(); //반복자 메소드 호출 
  while(iterator.hasNext() ) {  // 가져올 객체 존재하는 동안 반복 
      String str = iterator.next(); // 다음 객체 가져와서 변수 저장 
}

(2) 향상된 for문 이용하는 방법

Set<String> set = ... ; 
for(String str : set) {
}

[Set 인터페이스의 구현클래스]

[[HashSet]]

: 객체 순서없이 저장하며 중복 저장X

: 객체 저장 전 hashCode(), equals() 메소드 이용 -> 중복 객체 판별 후 저장

HashSet 생성

Set<타입> set = new Hashset<타입> ();

🟩[Map 컬렉션] : Map 인터페이스

: 키와 값으로 구성된 Map.Entry 객체 저장하는 구조

: 키와 값 모두 객체

: 키 중복 X, 값 중복 O

: 기존 저장 키와 동일 키에 다른 값 넣어 저장 시 -> 기존 존재하는 키에 다른 값 변경 저장

[Map 컬렉션 메소드]

객체 추가

• 지정 키로 지정 값 저장 : put(키 , 값 ) ;

객체 검색

• 지정 키 존재 여부 검사 : containsKey( 키) ;
• 지정 값 존재 여부 겁사 : contatinsValue( 값) ;
• 지정 키의 값 객체 리턴 : get(키);
• 빈 컬렉션 여부 검사 : isEmpty();
• Set에 모든 Map.Entry 객체 담아 리턴

Set<Map.Entry<K, V> entrySet();

• Set에 모든 키 객체 담아 리턴

Set keySet();

객체 삭제

• 모든 객체 삭제 : clear();
• 키값 일치하는 Map.Entry객체 삭제 : remove(키);

[Map 컬렉션 저장 모든 객체 대상 하나씩 처리]

(1) keySet() 메소드 : 모든 키를 Set컬렉션으로 얻은 후

→ 반복자 이용해서 다시 키를 하나씩 얻고 -> get() 메소드 : 값 얻는 방법

Map<K , V> map = ...;
Set<K> keySet = map.keySet();
Iterator<K> keyIterator = keySet.iterator();
while (keyIterator.hasNext() ) {
 K key = keyIterator.next();
 V value = map.get(key);
}

(2) entrySet() 메소드 : 모든 Map.Entry를 Set 컬렉션으로 얻은 후

→ 반복자 통해 다시 Map.Entry 객체 하나씩 얻고

→ getKey(), getValue() 메소드로 키, 값 얻는 방법

Set <Map.Entry < K, V > > entrySet = map.entrySet();
Iterator<Nao.Entry< K , V> entryIterator = entrySet.iterator();
while(entryIterator.hasNext()) {
 Map.Entry<K , V> entry = entryIterator.next(); 
 K key = entry.getKey();
 V value = entry.getValue();

[Map 인터페이스의 구현 클래스]

(1) [[HashMap]]

: 키로 사용할 객체는 hashCode(), equals() 메소드 재정의하여 동등 객체 조건 정함

: 객체가 달라도 동등 객체라면 같은 키로 간주 -> 중복 저장X

동등 객체 = hashCode값 같고, 내부값도 같은 객체

HashMap 생성

Map <키타입, 값타입> map = new HashMap<키타입, 값타입> ();

(2) [[Hashtable]] : 동기화된 메소드로 구성

: 멀티 스레드가 동시에 실행 불가능 안전한 스레드 환경 구축

Hashtable 생성

Map<키타입, 값타입> map = new Hashtable< 키타입, 값타입> ();

(3) [[Properties]]

13-2. LIFO와 FIFO 컬렉션

🟩[Stack 클래스]

: LIFO(후입선출) 자료구조 제공 클래스

: 맨 위에서만 삽입, 호출, 제거가 일어나는 구조

Stack 객체 생성

Stack <타입> stack = new Stack <타입> ();

<메소드>

객체 삽입 : push(객체); // 맨 위에 삽입

객체 호출 : peek(); // 맨 위 객체 호출 반환

객체 제거 : pop(); // 맨 위 객체 삭제

🟩[Queue 인터페이스]

: FIFO(선입선출) 자료구조 제공 인터페이스

: 삽입은 뒤에서, 제거는 앞에서 일어나는 구조

: LinkedList : Queue 인터페이스 대표 구현 클래스 + List 인터페이스 구현 클래스

Queue 생성 : LinkedList 구현 객체 생성하여 Queue 인터페이스 타입 변환

Queue<타입> 변수 = new LinkedList<타입> () ;

<메소드>

객체 삽입 : offer(객체) // 뒤에서 삽입

객체 호출 : peek(); // 앞에서 호출

객체 제거 : poll(); // 앞에서 제거