<자료 구조> JAVA의 Collection 자료 구조 정리

그 동안 여러 코딩 테스트, 알고리즘 문제를 풀면서 다양한 자료 구조를 사용하긴 했지만, 따로 정리한 내용이 부족한 것 같기도 하고, 오늘 강의에서 Java의 Collection 에 있는 자료 구조를 전부 설명해 주시길래 정리해보려고 한다. 

 

1. ArrayList: 워낙 기본적인 내용이기도 하고 많이 사용해서...자세한 내용은 Pass.

package com.choonham.list;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTestClass {

	public ArrayListTestClass() {
		// TODO Auto-generated constructor stub
	}
	
	public static void arrayListTest() {
		ArrayList<String> list = new ArrayList<>();
		
		list.add("grape");   // add() 맨 마지막 위치에 데이터를 추가 
		list.add("orange");
		list.add("orange");
		list.add("peach");
		
		System.out.println(list.size()); //4
		/** 0: "grape"   1:"orange"  2: "orange"  3: "peach"   **/
		
		
		list.add(1, "kiwi");  //특정 인덱스에 삽입
		/** 0: "grape"   1:  "kiwi"  2:"orange"  3: "orange"  4: "peach"   **/
		
		list .set(2, "apple"); //특정 인덱스 데이터 변경
		/** 0: "grape"   1:  "kiwi"  2:"apple"  3: "orange"  4: "peach"   **/
		
		list.remove(0);  //특정 인덱스의 데이터 제거
		/** 0:  "kiwi"  1:"apple"  2: "orange"  3: "peach"   **/
		
		list.remove("kiwi"); //특정 데이터 선택 제거
		/** 0:"apple"  1: "orange"  2: "peach"   **/
		
		int idx = list.indexOf("peach"); //특정 데이터의 위치 반환
		/** 2 **/
		
		
		/** 이터레이터를 사용하여 리스트의 있는 값 추출하는 방법 **/
		Iterator<String> itr  = list.iterator();   //순차적으로 인덱스를 가지는 이터레이터 객체 
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
		
		
	}
	

}

---

2. LinkedList: ArrayList와는 달리 삽입, 삭제시 데이터 그 자체가 움직이는 것이 아닌 연결된 인덱스가 수정되는 것이기 때문에 ArrayList보다 수정면에서 속도가 빠르다.

package com.choonham.list.linked;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class LinkedListTestClass {
	/** List 계열
	 *  ArrayList : 자료에 변동이 적을 때 유리
	 *  LinkedList : 삽입, 삭제가 많은 작업시 유리
	 */
	public LinkedListTestClass() {
		
	}
	
	public  static void linkedListTest() {
		LinkedList<Character> list = new LinkedList<>();
		list.add('a');
		list.add('b');
		list.add('c');
		
		for(Character c : list) {
			System.out.println(c);
		}
		
		Iterator<Character> itr = list.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
		
	} 
	
	public static void linkedListExample() {
		List<String> arrayList = new ArrayList<>();
		List<String> linkedList = new LinkedList<>();
		
		
		long startTime, endTime;
		
		//ArrayList 처리 시간
		startTime = System.nanoTime();
		for(int i = 0; i < 10000; i++) {
			arrayList.add(String.valueOf(i));
		}
		
		
		endTime = System.nanoTime();
		System.out.println("ArrayList  처리 시간: " + (endTime - startTime));
		
		
		//LinkedList 처리 시간
		
		startTime = System.nanoTime();
		for(int i = 0; i < 10000; i++) {
			linkedList.add(String.valueOf(i));
		}
		
		
		endTime = System.nanoTime();
		System.out.println("LinkedList  처리 시간: " + (endTime - startTime));
		
	}

}

다음과 같이 코드를 작성해서 속도를 비교하면 ArrayList 와 LinkedList에 각각 10000개의 데이터를 삽입했을 때의 속도 차이는

이 정도 차이가 난다. (데이터가 많아지면 많아질수록 차이는 커진다.)

 

---

3. Vector: 동기적 방식의 자료 구조로, 속도가 느려서 자주 사용되는 자료 구조는 아니지만 참고용으로 알아두자

package com.choonham.list.vector;

import java.util.Enumeration;
import java.util.Vector;

public class VectorTestClass {

	/*
	 *  List 계열: 자료가 순차적, 중복적일 경우 사용
	 *  ArrayList: 비동기적(효율적)
	 *  Vector: 동기적
	 *  
	 *  ------------------------비동기적 방식과 동기적 방식------------------------
	 *  은행: 통장(10,000) => A는 출금(7,000) / B는 입금 (5,000)
	 *  A 는 출금(7,000) => 3,000
	 *  B 는 입금(5,000) => 15,000
	 *  이렇게 가정했을 때, A가 계좌에서 출금 작업을 진행할 때, B의 입금은 대기 상태가 되었다가 A의 작업이 끝난 후 작업 시작 => 동기적 방식
	 *  출금과 입금이 동시에 이뤄진다면 => 비동기적 방식
	 *  --------------------------------------------------------------------------------
	 *  
	 *  But, Vector는 전체 코드의 처리 시간이 느려져서 잘 사용하지 않는다.
	 * 
	 */
	
	public VectorTestClass() {
		// TODO Auto-generated constructor stub
	}
	
	public static void vectorTest() {
		Vector<String> v1 = new Vector<>();
		v1.add("Samsung"); // List 인터페이스에 의해서 Override된 메서드
		v1.addElement("Samsung2"); //Vector Class 자체 정의 메서드(add메서드보단 이 메서드를 더 자주 사용)
		v1.addElement("LG");
		v1.addElement("Google");
		
		System.out.println(v1);  //Vector는 이렇게 직접 출력이 가능하다.
		
		System.out.println(v1.elementAt(2));  //특정 인덱스에 있는 데이터를 추출
		
		Enumeration<String> e = v1.elements(); //이렇게 Enumeration 을 사용하여 이터레이터와 같이 출력 가능
		
		while(e.hasMoreElements()) {
			System.out.println(e.nextElement());
		}
		
		
	}

}

 

---

4. Stack: 마찬가지로 기본적인 자료 구조, 특징은 Last in, first out  /  First in, last out 이라는 것. 바구니에 차곡 차곡 쌓는 걸 생각하면 데이터를 따라가기 쉽다.

package com.choonham.list.stack;

import java.util.Stack;

public class StackTestClass {
	/*
	 *  Stack: List 계열
	 *  동작: Last in, first out  /  First in, last out
	 *  
	 */
	public StackTestClass() {
		// TODO Auto-generated constructor stub
	}
	
	public static void stackTest() {
		Stack<String> s = new Stack<>();
		s.push("abc");   //데이터 삽입: 맨 아래부터 쌓아 올린다.
		s.push("def");
		s.push("ghi");
		
		
		System.out.println(s.peek());  //가장 최근에 Push된, 맨 위 데이터 확인
		
		System.out.println(s.pop());  // 데이터 추출: 맨 위부터 꺼낸다.
		System.out.println(s.pop());
		System.out.println(s.pop());
		
		
		
	}
	
}

 

---

5. Queue: First in first out 개념의 자료 구조, LinkedList 이용하여 구현한다.

package com.choonham.list.stack;

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListQueueTestClass {

	/* LinkedList 를 이용하여 구현하는 Queue
	 * 
	 *  Queue: First in First out
	 *  Queue는 클래스로 구현되어있지 않고, 인터페이스로 구현되어 있기 때문에 
	 *  Queue타입의 LinkedList 를 생성해야 사용이 가능하다.
	 *
	 */
	
	public LinkedListQueueTestClass() {
		// TODO Auto-generated constructor stub
	}
	
	public static void queueTest() {
		Queue<String> q = new LinkedList<String>();
		
		q.add("오늘은 ");
		q.add("3월 30일");
		q.add("화요일 입니다.");
		
		System.out.println(q.peek());  //가장 먼저 들어간 데이터(head) 확인
		
		System.out.println(q.poll());  //head 부터 데이터 추출
		System.out.println(q.poll());
		System.out.println(q.poll());
		
	}

}

 

---

6. HashMap: key와 value 쌍을 데이터로 가지고 있는 Map형태로, 순서나 인덱스를 따로 가지고 있지 않는다.

 

package com.choonham.map.hashmap;

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

public class HashmapTestClass {
 /*
  * 
  *  Map 계열 : 자료가 key, Value 쌍으로 되어 있는 상태일 때 사용
  *  하위 클래스 : HashMap(가장 많이 사용), TreeMap(군집 분석 시 많이 쓰임), HashTable, Properties
  *  HashTable : old ver.
  *  HashMap : new ver.
  *  Map - NavigableMap - HashTable/HashMap, Properties, TreeMap
  * 
  * */
	
	public HashmapTestClass() {
		// TODO Auto-generated constructor stub
	}
	
	public static void hashmapTest() {
		Map<String, Integer> m = new HashMap<String, Integer>();
		
		m.put("a",  10);
		m.put("a",  20);
		m.put("a",  30);
		m.put("a",  40);  // key "a" 에 계속 데이터를 덮어 쓴다. 즉, 동일한 Key명이 중복되어 Map에 들어갈 수 없다.
		
		
		m.put("b", 200);
		m.put("c",  120);
		m.put("d",  300);
		
		     // 데이터 추출1. keySet() 키 값을 반환하는 메서드로, Set 타입으로 반환한다.
		
		Set<String> s = m.keySet();
		
		s = m.keySet();
		Iterator<String> itr = s.iterator();
		
		while(itr.hasNext()) {
			String keyName = itr.next();
			Integer value = m.get(keyName);
			System.out.println(keyName + " : " + value);
		}
 		
		System.out.println(m.get("a"));  // 데이터 추출2. 특정 키 값만 반환
		
	}

}

 

---

7. Set: 자료가 주머니 속에 저장된다고 생각하면 된다. 순서는 없고, 중복 자료가 들어갈 수 없다. 

즉,  어떤 데이터 집합에서 깔끔하게 중복 값을 제거하고 싶을 때, 전부 Set에 넣어버리면 중복 값이 제거된다.

 

package com.choonham.map.hashset;

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

public class HashSetTestClass {
/*
 *  Set계열: 자료가 주머니 속에 저장. 순서 없음, 중복 불가 <== 값(데이터)만 저장!
 *  			: Iterable - Collection - Set - HashSet/TreeSet
 * 순서나 Key를 가지고 있지 않기 때문에 무조건 Iterator을 사용하여 데이터를 추출해야한다.
 * 
 * 어떤 데이터 집합에서 깔끔하게 중복 값을 제거하고 싶을 때, 
 * 전부 Set에 넣어버리면 중복 값이 제거된다.
 * 
 * */
	
	
	public HashSetTestClass() {
		// TODO Auto-generated constructor stub
	}
	
	public static void hashSetTest() {
		HashSet<String> h = new HashSet<>();
		h.add("test1");
		h.add("test2");
		h.add("test3");
		h.add("test4");
		
		Iterator<String> itr = h.iterator();
		
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
		
		
	}

	
}

 

위와 같이 코드를 구성하여 Iterator를 사용해 출력해보면,

이렇게 순서를 깡그리 무시하고, 출력되는 것을 볼 수 있다.

또한, ArrayList의 생성자 부분에 Set을 넣어 Set에게 순서를 주거나 정렬할 수도 있다.

 

대강 코드를 짤 때 자주 사용하는 Collection의 자료 구조를 정리해봤는데... 역시 많이 사용하는 걸 잘 기억할 수 밖에 없는 것 같다. 

 

결론: 굳이 굳이 활용하여 많이 사용해보자!