JAVA Collection

• Collection : 데이터를 수집하기 위한 집합
• Framework : 틀, 구조
• Collection Framework : 데이터를 수집하여 저장하기 위해 사용할 수 있도록 정의해 놓은 클래스의 집합

1. Collection 인터페이스

• List와 Set의 상위 인터페이스

※ Collection 인터페이스에 선언된 주요 메서드

메서드 설명

boolean add(E e)	Collection에 객체를 추가
void clear()	Collection의 모든 객체 제거
Iterator<E> iterator	Collection을 순환할 반복자(Iterator)를 반환
boolean remove(Object o)	Collection에 매개변수에 해당하는 인스턴스가 존재할 경우 삭제
int size()	Collection에 있는 요소의 개수 반환

※ Collection 인터페이스 특징인터페이스 설명 구현 클래스

List<E>	순서가 있는 데이터의 집합으로, 데이터의 중복을 허용함.	Vector, ArrayList, LinkedList, Stack, Queue
Set<E>	순서가 없는 데이터의 집합으로, 데이터의 중복을 허용하지 않음	HashSet, TreeSet
Map<K,V>	- 키와 값의 한 쌍으로 이루어지는 데이터의 집합으로, 순서가 없음. - 키는 중복을 허용하지 않지만, 값은 중복될 수 있음	HashMap, TreeMap, Hashtable, Properties

 

Set : 비순차적 저장, 중복 데이터 불허 Map : 비순차적 저장, 중복 데이터 허용

List : 순차적 저장, 중복 데이터 허용

Map : 비순차적 저장, 중복 데이터 허용

 

2. Iterator

서로 다른 자료구조(Vector, ArrayList, LinkedList)의 데이터를 동일한 방법으로 다음 데이터에 접근하는 방법을 제공하는 인터페이스

 

3. Set

순서가 없고 중복된 데이터를 허용하지 않는 방식으로, 저장된 순서와 출력 순서는 다를 수 있다.

• HashSet
• 가장 빠른 임의 접근 속도
• 순서를 예측할 수 없음
• HashSet, HashMap, HashTable 과 같은 Hash 알고리즘을 사용하는 Collection들은 객체의 동등성 비교를 위해 HashCode와 equals 메서드를 호출한다.

import java.util.HashSet;
import java.util.Iterator;

public class set2 {
  public static void main(String[] args) {
    HashSet<Integer> hs = new HashSet<>();
// Generic 선언 : 일반화
    // hs.add("hello");
    hs.add(10); // 숫자인 경우 컬렉션에서 알아서 숫자 객체로 변환 new Integer(10) auto-boxing
    hs.add(20);
    hs.add(30);
    hs.add(30);

    Iterator<Integer> it = hs.iterator(); // 반복자
    while(it.hasNext()) { // 순회
      System.out.println(it.next());
    }

    System.out.println(hs.size());
    System.out.println(hs.isEmpty());
    System.out.println(hs.remove(30));
    System.out.println(hs.contains(30)); //들어있는 값
    System.out.println(hs.size());
    
// 이미 앞에서 한번 순회를 했기 때문에
    it = hs.iterator(); // 다시 생성
    while(it.hasNext()) { // 순회
      System.out.println(it.next());
    }
  }
}

• TreeSet
• 자동으로 오름차순으로 데이터 정렬
• 객체의 정렬에 사용되는 클래스
• 내부적으로 이진 검색 트리로 구현되어 있으며, 정렬방법을 지정할 수 있다.

package Collection;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;

public class treeSet {
    public static void main(String[] args) {
        /*  TreeSet<타입> 변수명 = new TreeSet<>(); 
        선언하면 자동으로 오름차순 정렬이 되는 TreeSet을 선언
        */
        // Integer 타입으로 오름차순 정렬
        TreeSet<Integer> ts = new TreeSet<>();
		
		// Integer 타입으로 내림차순 정렬
		TreeSet<Integer> ts2 = new TreeSet<>(Collections.reverseOrder());
		// String 타입으로 오름차순 정렬
		TreeSet<String> ts3 = new TreeSet<>();
		// String 타입으로 내림차순 정렬
		TreeSet<String> ts4 = new TreeSet<>(Collections.reverseOrder());

        // 값 추가
        ts.add(5);
        ts.add(4);
        ts.add(3);
        ts.add(2);
        ts.add(1);

        // TreeSet은 기본적으로 정렬을 해주기때문에 결과를 출력하면 정렬된 값으로 출력이 된다.
        System.out.println(ts);
        // 크기 출력
        System.out.println("TreeSet의 크기는" + ts.size());

        // ts.remove(4); // 4삭제
        // System.out.println(ts);
        // ts.pollFirst(); // 맨 처음 데이터 삭제
        // System.out.println(ts);
        // ts.pollLast(); // 맨 마지막 데이터 삭제
        // System.out.println(ts);
        // ts.clear(); // 전체삭제
        // System.out.println(ts);

        // 향상된 for문을 사용하여 출력
        for(Integer str : ts)
        System.out.println(str + " ");
        System.out.println();

        //Iterator를 사용하여 출력
        Iterator it = ts.iterator();
        while(it.hasNext())
        System.out.println(it.next() + " ");
    }
}

• LinkedHashSet HashSet과 동일한 구조이며 HashSet과는 달리 삽입된 순서대로 반복하며, 중복된 값을 허용하지 않는다.

package Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class Linked {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("1");
        set.add("1");
        set.add("one");
        set.add("2");
        set.add("3");
        set.add("4");
        set.add("five");

        Iterator iterator = set.iterator();

        while(iterator.hasNext()){
            if(iterator.next().equals("1")){ // 1이 있으면
                iterator.remove(); // 지워라
            }
        }
        System.out.println(set); //출력 결과 : [one, 2, 3, 4, five]
    }
}

4. List

 

배열과 같이 데이터의 저장 순서(Index)가 존재하며, 데이터의 중복을 허용한다.

• ArrayList
• 단방향 포인터 구조로 각 데이터에 대한 인덱스를 가지고 있어 조회 기능에 성능이 뛰어남. → 데이터의 삽입 삭제가 없이 단순 검색만을 사용하는 로직에서 사용함.
• LinkedList
• 양방향 포인터 구조로 데이터의 삽입, 삭제가 빈번할 경우 데이터의 위치정보만 수정하면 되기에 유용
• 스택, 큐, 양방향 큐 등을 만들기 위한 용도로 쓰임
• Vector
• 과거에 대용량 처리를 위해 사용했으며, 내부에서 자동으로 동기화처리가 일어나 비교적 성능이 좋지 않고 무거워 잘 쓰이지 않음

import java.util.ArrayList;

public class list {
  public static void main(String[] args) {
    ArrayList<Integer> al = new ArrayList<>();

    //배열
    al.add(111);
    al.add(12);
    al.add(23);
    al.add(54);
    al.add(568);
    al.add(453);
    al.add(23);

    al.add(1, 9865); // 1번 자리에 9865로 변경

    al.remove(3); //3번 지우기

    for(int i = 0; i < al.size(); i++) {
      System.out.println(al.get(i));
    }
  }
}

5. Queue

Queue는 FIFO(First In First Out : 선입선출)구조로 설계되어있다. → 먼저 등록된 데이터가 먼저 출력이 된다.

 

Queue에서만 사용되는 메서드

메서드 설명

add	큐에 요소 등록, 등록 실패 시 Expection throw
element	큐에 등록된 첫 번째 요소를 리턴
offer	큐에 요소 등록, 등록 실패 시 false리턴
peek	큐의 요소를 출력, 없는 경우 null 리턴
poll	큐에 요소를 출력, 출력된 요소는 큐에서 삭제, 큐가 비어있으면 null리턴
remove	큐의 요소를 삭제

package Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class queue {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        
        queue.add("1. Java");
        queue.offer("2. Javascript");
        queue.offer("3. C");
        queue.add("4. C++");
            
        System.out.println("element : "+queue.element());
            
        for(Iterator<String> itr = queue.iterator(); itr.hasNext();){
            System.out.println(itr.next());
        }
        System.out.println("before Poll : "+queue.size());
            
        while(queue.peek()!=null){
            System.out.println("peek : "+queue.peek());
            System.out.println("after Peek : "+queue.size());
            System.out.println("poll : "+queue.poll());
            System.out.println("after Poll : "+queue.size());
        }
    }
}

6. Map

리스트나 배열처럼 순차적으로 해당 요소 값을 구하지 않고 Key를 통해 Value를 얻는다. 맵의 가장 큰 특징으로는 key로 value를 얻어낸다.

특징 :

• 요소의 저장 순서를 유지하지 않는다.
• key는 중복을 허용하지 않으며, value의 중복은 허용한다.

public class map {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("people", "사람");
        map.put("baseball", "야구");

        System.out.println(map);

        // get 메서드를 이용하면 value 값을 얻을 수 있다.
        System.out.println(map.get("people"));

        /* remove 메서드는 맵의 항목을 삭제하는 메서드로 
        key값에 해당되는 아이템(key:value)을 삭제한 후 그 value 값을 리턴한다.  */
        System.out.println(map.remove("people")); // 해당 아이템(people:사람)이 삭제 된 후 사람 출력

        // size 메서드는 map의 갯수 리턴
        System.out.println(map.size());
    }

• LinkedHashMap : 입력된 순서대로 데이터가 출력되는 특징을 가지고 있다.
• HashMap
• 중복과 순서가 허용되지 않으며 null값이 올 수 있다.
• Hashtable
• HashMap보다는 느리지만 동기화 지원
• key와 value로 null이 허용되지 않는다.

package Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class hashtable {
    public static void main(String[] args) {
        Hashtable<String, String> ht = new Hashtable<String, String>(); // Hashtable 선언
		
		// 값 추가
		ht.put("1", "Hello1");
		ht.put("2", "World2");
		ht.put("3", "Hello3");
		ht.put("4", "World4");
		ht.put("2", "WorldWorld2");
		
    //put 메서드를 사용하여 key가 같고 value가 다른 값을 중복해서 넣으면 나중에 넣은 value값으로 변경
		System.out.println(ht); // 결과출력

        /* 향상된 for문을 사용하여 HashTable의 값 출력 */
        for(Map.Entry<String, String> e : ht.entrySet())
        System.out.println("Key : " + e.getKey() + ", Value : " + e.getValue());
        
        /*Iterator를 이용한 방식 */
        Iterator<Entry<String, String>> it = ht.entrySet().iterator();
        while(it.hasNext())
        {
            Map.Entry<String, String> entry = it.next();
            System.out.println("Key : "+ entry.getKey()+", Value : "+ entry.getValue());
        }
        System.out.println("-----------------------");

        Iterator<String> iter2 = ht.keySet().iterator();
		    while(iter2.hasNext())
		    {
		    	String key = iter2.next();
		    	System.out.println("Key : " + key + ", Value : " + ht.get(key));
		    }
    }
}

• TreeMap
• 정렬된 순서대로 키(Key)와 값(Value)을 저장하여 검색이 빠르다.
• 입력된 key의 오름차순으로 데이터가 출력되는 특징을 가지고 있다.
• key에 사용되는 클래스에 Comparable, Comparator 인터페이스를 구현

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class map {
  public static void main(String[] args) {
    // 키값과 value값을 매칭해서 저장
    // 키 : 중복x , value : 중복 o 
    HashMap hm = new HashMap();

    hm.put("Hello", 100);
    hm.put(10, "tester");

    System.out.println(hm.get(10));
    System.out.println(hm.get(1));
    System.out.println(hm.get("Hello"));

    Set keys = hm.keySet();
    Iterator it = keys.iterator();
    while(it.hasNext()) {
      System.out.println(it.next());
    }
    // key 값만 가져옴
    for(Object o : keys) {
      System.out.println(o);
    }
    // value 값만 가져옴
    Collection values = hm.values();
    for(Object o : values) {
      System.out.println(o);
    }

    it = keys.iterator();
    while(it.hasNext()) {
      Object key = it.next();
      Object value = hm.get(key);
      System.out.println(key + ":" + value);
    }
  }
}

• List와 Set의 차이
• List는 기본적으로 순서대로 데이터가 들어가며 중복을 허용한다.
• Set은 순서가 보장되지 않고 중복을 허용하지 않는다.
• Map은 순서가 보장되지 않고, Key중복은 허용하지 않지만 Value의 중복은 허용된다.