[JAVA] Collection Framework 정리

• 컬렉션(Collection)이란?
  • 여러 객체를 모아 놓은 것을 의미합니다.
• 프레임웍(Framework)이란?
  • 표준화, 정형화된 체계적인 프로그래밍 방식을 말합니다.

컬렉션 프레임웍(Collection Framework)

• 컬렉션을 다루기 위한 표준화된 프로그래밍 방식
• 컬렉션을 쉽고 편리하게 다룰 수 있는 다양한 클래스(Collection Class) 제공
  • 저장, 삭제, 검색, 정렬 등등
  • Collection Class에는 Vector, ArrayList, HashSet 등이 있다.
• java.util 패키지에 포함되어 있다. (JDK 1.2부터 제공)

Collection Framework의 핵심 인터페이스

List와 Set은 Collection 인터페이스의 자식 인터페이스이다.

•  List
  • 순서가 있는 데이터의 집합이며 데이터의 중복을 허용한다.
  • List를 구현한 클래스 : ArrayList, LinkedList, Stack, Vector 등등
• Set (집합)
  • 순서를 유지하지 않는 데이터의 집합이며, 데이터의 중복을 허용하지 않는다.
  • Set을 구현한 클래스 : HashSet, TreeSet 등등
• Map
  • 키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합이다.
  • 순서를 유지하지 않는 데이터의 집합이며, 키(key)의 중복은 허용하지 않지만 값(value)의 중복은 허용한다.
    • Map을 구현한 클래스 : HashMap, TreeMap, Hashtable, Properties 등등

Collection 인터페이스의 메서드

List와 Set는 Collection 인터페이스의 자식이기 때문에 아래 메서드들을 가지고 있다.

• 추가 기능 : 지정된 객체(o)또는 Collection(c)의 객체들을 Collection에 추가한다.
  • boolean add(Object o)
  • boolean addAll(Collection c)
• 삭제 기능 : 지정된 객체(o)또는 Collection(c)의 객체들을 Collection에 삭제한다.
  • boolean remove(Object o)
  • boolean removeAll(Collection c)
• 전체 삭제 기능 : Collection의 모든 객체를 삭제한다.
  • void clear()
• 검색 기능 : 지정된 객체(o)또는 Collection(c)의 객체들을 Collection에 포함되어 있는지 확인한다.
  • boolean contains(Object o)
  • boolean containsAll(Collection c)
• boolean equals(Object o) : 동일한 Collection인지 비교한다.
• int hashCode() : Collection의 hash code를 반환한다.
• boolean isEmpty() : Collection이 비어있는지 확인한다.
• Iterator iterator() : Collection의 iterator를 얻어서 반환한다.
  • 2022.08.18 - [JAVA] - [JAVA] Iterator Method 관련 내용

• boolean retainAll(Collection c) : 지정된 Collection(c)에 포함된 객체만을 남기고 다른 객체들은 삭제한다.
  • 이 작업으로 인해 변화가 있다면 true, 없다면 false를 반환한다.
• int size() : Collection에 저장된 객체의 개수를 반환한다.
• Object [] toArray() : Collection에 저장된 객체를 객체 배열(Object [])로 반환한다.
• Object [] toArray(Object [] a) : 지정된 배열에 Collection의 객체를 저장해서 반환한다.

List 인터페이스의 메서드

(복습) 순서가 있는 데이터의 집합이며, 데이터의 중복을 허용한다.

• 추가 : 지정된 위치(index)에 객체(element) 또는 컬렉션(c)에 포함된 객체들을 추가한다.
  • void add(int index, Object element)
  • boolean addAll(int index, Collection c)
• 읽기 : 지정된 위치(index)에 있는 객체를 반환한다.
  • Object get(int index)
• 검색
  • int indexOf(Object o)
    • 지정된 객체(o)의 위치를 반환한다. (첫 번째 요소부터 순방향으로 찾는다.)
  • int lastIndexOf(Object o)
    • 지정된 객체(o)의 위치를 반환한다. (마지막 요소부터 역방향으로 찾는다.)
• 삭제 : 지정된 위치(index)에 있는 객체를 삭제하고 삭제된 객체를 반환한다.
  • Object remove(int index)
• 수정 (변경) : 지정된 위치(index)에 객체(element)를 저장한다.
  
  • Object set(int index, Object element)
• 정렬
  • void sort(Comparator c)
    • 지정된 비 교자(Comparator)로 List를 정렬한다.
  • List subList(int fromIndex, int toIndex)
    • 지정된 범위(fromIndex  ~ toIndex)에 있는 객체를 반환한다.

Set 인터페이스의 메서드

(복습) 순서를 유지하지 않는 데이터의 집합이며, 데이터의 중복을 허용하지 않는다.

Set 인터페이스의 메서드는 Collection 메서드와 거의 유사하다.

• 집합과 관련된 메서드
  • boolean addAll(Collection c)
    • 지정된 Collection(c)의 객체들을 Collection에 추가한다.(합집합)
  • boolean containsAll(Collection c)
    • 지정된 Collection(c)의 객체들이 Collection에 포함되어 있는지 확인한다. (부분집합)
  • boolean removeAll(Collection c)
    • 지정된 Collection(c)에 포함된 객체를 삭제한다. (차집합)
  • boolean retainsAll(Collection c)
    • 지정된 Collection에 포함된 객체만을 남기고 나머지는 Collection에서 삭제한다. (교집합)

 

Map 인터페이스의 메서드

(복습) 순서를 유지하지 않는 데이터의 집합이며, 키(key)의 중복은 허용하지 않지만 값(value)의 중복은 허용한다.

• 추가
  • Object put(Object key, Object value)
    • Map에 value객체를 key객체에 연결(mapping)하여 저장한다.
  • void putAll(Map t)
    • 지정된 Map(t)의 모든 key-value쌍을 추가한다.
• 삭제
  • Object remove(Object key)
    • 지정된 key객체와 일치하는 key-value객체를 삭제한다.
• 읽기 
  • Set entrySet() : key와 value 모두 읽기
    • Map에 저장되어 있는 key-value쌍을 Map.entry타입의 객체로 저장한 Set으로 반환한다.
  • Set keySet() : key만 읽기
    • Map에 저장된 모든 key객체를 반환한다.
  • Collection values() : value만 읽기
    • Map에 저장된 모든 value객체를 반환한다.
• 검색
  • boolean containsKey(Object key)
    • 지정된 key객체와 일치하는 Map의 key객체가 있는지 확인한다.
  • boolean containsValue(Object value)
    • 지정된 value객체와 일치하는 Map의 value객체가 있는지 확인한다.
  • Object get(Object key)
    • 지정된 key객체에 대응하는 value객체를 찾아서 반환한다.
• 전체 삭제
  • void clear() : Map의 모든 객체를 삭제한다.
• boolean equals(Object o) : 동일한 Map인지 비교한다.
• int hashCode() : hash code를 반환한다.
• boolean isEmpty() : Map이 비어있는지 확인한다.
• int size() : Map에 저장된 key-value쌍의 개수를 반환한다.

ArrayList에 대해 알아보기

List 인터페이스의 구현 클래스이며, 순서가 있으며, 중복을 허용한다.

• ArrayList는 기존의 Vector를 개선한 것으로 구현원리와 기능적으로 동일
• ArrayList 자제적 동기화 x, Vector 자체적 동기화 o
• 데이터의 저장공간으로 배열을 사용한다. (배열 기반)

ArrayList의 메서드

• 생성자
  • ArrayList() : 기본 생성자
  • ArrayList(Collection c) : 지정된 Collection(c)로 생성
  • ArrayList(int initialCapacity) : 배열의 길이 지정
• 추가
  • boolean add(Object o)
  • void add(int index, Object element)
  • boolean addAll(Collection c)
  • boolean addAll(int index, Collection c)
• 삭제
  • boolean remove(Object o)
  • Object remove(int index)
    • 삭제 과정 알아보기 
    • 삭제할 데이터 다음 데이터를 한 칸씩 앞으로 복사해서 삭제할 데이터를 덮어쓴다.
      • 데이터가 마지막 값을 삭제하는 경우는 이 과정이 필요 없다.
    • 데이터가 모두 한 칸씩 복사됐으면 마지막 데이터는 null로 변경한다.
    • 데이터가 삭제되어 데이터의 개수가 줄었으므로 size의 값도 감소된다.
  • boolean removeAll(Collection c)
  • void clear()
• 검색
  • int indexOf(Object o) : 순방향으로 찾으며 없을 경우 -1을 반환한다.
  • int lastIndexOf(Object o) : 역방향으로 찾으며 없을 경우 -1을 반환한다.
  • boolean contains(Object o) : 존재 여부
  • Object get(int index) : 읽기
  • Object set(int index, Object element) : 수정(변경)
• 그 외
  • List subList(int fromIndex, int toIndex)
    • 리스트에서 fromIndex ~ toIndex까지 뽑아서 새로운 리스트를 만든다.
  • Object [] toArray() : 객체 배열 반환
  • Object [] toArray(Object [] a)
  • boolean isEmpty() : 비어있는지 확인
  • void trimToSize() : 빈 공간 제거
  • int size() : 저장된 객체의 개수

LinkedList에 대해 알아보기

List 인터페이스를 구현한 클래스이며 순서가 있고 데이터의 중복을 허용한다.

class Node{
    Node next; // 다음 노드
    Object obj; // 데이터
}

• 배열의 단점을 보완하기 위해 만들어졌다.
  • 배열의 장단점
    • 장점 : 구조가 간단하고 데이터를 읽는 데 걸리는 시간(접근시간)이 짧다.
    • 단점
      • 실행 중에 크기를 변경할 수 없다.
      • 비 순차적인(배열 중간에서 행해지는 것) 데이터 추가, 삭제에 시간이 많이 소요된다.
• LinkedList는 불연속적으로 존재하는 데이터를 연결한 것이다.
  • 단점으로는 데이터의 접근성이 나쁘다.
  • 데이터 삭제 : 단 한 번의 참조 변경 만으로 가능하다.
    
    • 이를 보완하기 위해 double LinkedList를 만들었다. ( 이중 연결 리스트, 접근성 향상) 

// 이중 연결 리스트
class Node{
    Node next; // 다음 요소
    Node previous; // 이전 요소
    Object obj; // 데이터
}

ArrayList와 LinkedList 비교해보기

기능	효율적인 List
순차적 추가하기	ArrayList
순차적 삭제하기	ArrayList
비 순차적으로 데이터 추가 및 삭제	LinkedList
접근시간	ArrayList

import java.util.*;

public class MyClass {
    public static void main(String args[]) {
        ArrayList list1 = new ArrayList(10);
        list1.add(new Integer(5));
        list1.add(new Integer(4));
        list1.add(new Integer(2));
        list1.add(new Integer(0));
        list1.add(new Integer(1));
        list1.add(new Integer(3));
        list1.add(7); // == new Integer(7) ( 컴파일 시 자동 변환된다 )
        // autoboxing에 의해 기본형이 참조형으로 자동 형변환된다.
        
        // 생성자에서 ArrayList(Collection c)를 사용한다.
        ArrayList list2 = new ArrayList(list1.subList(1,4));
        print(list1, list2);
        
        Collections.sort(list1); // 오름차순 정렬
        Collections.sort(list2); // 오름차순 정렬
        print(list1, list2);
        
        System.out.println("list1.containsAll(list2) = " + list1.containsAll(list2));
        // list1이 list2의 모든 객체를 포함하고 있는가? true
        // list2는 list1을 subList로 범위지정해서 새로만든 ArrayList이기 때문이다.
        System.out.println();
        
        list2.add("B");
        list2.add("C");
        list2.add(3,"A"); // 위치 지정하여 추가 ( 비순차적이기 때문에 효율성이 나쁘다. )
        print(list1, list2);
        
        list2.set(3, "G"); // 위치 지정하여 수정 (인덱스 3의 문자열을 "G"로 변경)
        print(list1, list2);
        
        list1.add(0,"1"); // 인덱스 0에 "1" 추가
        System.out.println("index = " + list1.indexOf("1"));
        // 순방향으로 가장 먼저 찾는 "1"의 인덱스 번호를 반환한다.
        list1.remove("1"); // 순방향으로 가장 먼저 찾는 "1"을 삭제한다.
        list1.remove(1); // 인덱스 1의 문자열을 삭제한다.
        list1.remove(new Integer(3)); // 순방향으로 객체값이 3인걸 삭제한다.
        print(list1, list2);
        
        System.out.println("list1.retainAll(list2) = " + list1.retainAll(list2));
        // list1에서 list2와 겹치는 객체를 제외하고 삭제한다.
        print(list1, list2);
        
        for(int i = list2.size()-1; i >= 0; i--){
            if(list1.contains(list2.get(i))){ // list1에 list2.get(i)에 값이 존재하는지 확인
            // get은 읽어오는거다.
                list2.remove(i); // 존재한다면 list2에서 삭제한다.
            }
        }
        print(list1,list2);
    }
    public static void print(ArrayList a, ArrayList b){
        System.out.println("list1 = " + a);
        System.out.println("list2 = " + b);
        System.out.println();
    }
}