์ปฌ๋ ์ ํ๋ ์์ํฌ
์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์ ๊ฐ์ฒด๋ค์ ํจ์จ์ ์ผ๋ก ์ถ๊ฐ, ์ญ์ , ๊ฒ์ํ ์ ์๋๋ก
์ธํฐํ์ด์ค์ ๊ตฌํ ํด๋์ค๋ฅผ java.util ํจํค์ง์์ ์ ๊ณตํ๋๋ฐ,
์ด๋ค์ ์ด์นญํด์ ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ผ ๋ถ๋ฅธ๋ค.
์ปฌ๋ ์ ์ ๊ฐ์ฒด์ ์ ์ฅ์ ๋ปํ๊ณ ํ๋ ์์ํฌ๋ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ์ ํด๋์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋งํ๋๋ฐ ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ์ ์ํ ์ธํฐํ์ด์ค์ ์ค์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๋ค์ํ ์ปฌ๋ ์ (๊ตฌํ) ํด๋์ค๋ฅผ ์ ๊ณตํ๋ค.
1. List ์ปฌ๋ ์
- ๊ฐ์ฒด๋ฅผ ์ ์ฅํ ๋ ์๋ ์ธ๋ฑ์ค๊ฐ ๋ถ์ฌ๋๋ฉฐ ์ด ์ธ๋ฑ์ค๋ก ๊ด๋ฆฌ๋๋ค.
- ๊ฐ์ฒด ์์ฒด๋ฅผ ์ ์ฅํ๋ ๊ฒ์ด ์๋ ๊ฐ์ฒด์ ๋ฒ์ง๋ฅผ ์ฐธ์กฐํ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ null๊ณผ ์ค๋ณต ์ ์ฅ๋ ์ ์๋ค.
- ๋ฐฐ์ด๊ณผ ๋ค๋ฅด๊ฒ ์ ์ฅ ์ฉ๋์ด ์๋์ผ๋ก ์ฆ๊ฐํ๋ค.
๋ฉ์๋ | ์ค๋ช |
boolean add(E e) | ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ ๋งจ ๋์ ์ถ๊ฐํฉ๋๋ค. |
void add(int index, E element) | ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐํฉ๋๋ค. |
E set(int index, E element) | ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ์ฃผ์ด์ง ๊ฐ์ฒด๋ก ๋ฐ๊ฟ๋๋ค. |
boolean contains(Object o) | ์ฃผ์ด์ง ๊ฐ์ฒด๊ฐ ์๋์ง์ ๋ํ ์ฌ๋ถ๋ฅผ ๊ฒ์ํฉ๋๋ค. |
E get(int index) | ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
boolean isEmpty() | ์ปฌ๋ ์ ์ด ๋น์ด์๋์ง ์กฐ์ฌํฉ๋๋ค. |
int size() | ์ ์ฅ๋์ด ์๋ ์ ์ฒด ๊ฐ์ฒด ์๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
void clear() | ์ ์ฅ๋ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ์ญ์ ํฉ๋๋ค. |
E remove(int index) | ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ์ญ์ ํฉ๋๋ค. |
boolean remove(Object o) | ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ ์ญ์ ํฉ๋๋ค. |
1) ArrayList
- ๊ธฐ๋ณธ์ ์ผ๋ก 10๊ฐ์ ์ด๊ธฐ ์ฉ๋์ ๊ฐ๊ณ ์๋ค.
- ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ๋๋ง๋ค ์ธ๋ฑ์ค ์ด๋์ ํ๊ธฐ ๋๋ฌธ์ ์ถ๊ฐ์ ์ญ์ ๊ฐ ๋น๋ฒํ ๋ ์ข์ง ์๋ค.
- ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด ๊ฐ์ฒด๋ฅผ ์ฐพ๊ฑฐ๋ ๋ง์ง๋ง์ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐ, ์ญ์ ํ ๊ฒฝ์ฐ์ ์ข๋ค.
List<E> list = new ArrayList<E>();
List<E> list = new ArrayList<>(); // ์๋ต
2) Vector
- ArrayList์ ๋์ผํ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ๊ฐ๋๋ค.
- ์ค๋ ๋ ์์ (Thread Safe): ๋๊ธฐํ๋ ๋ฉ์๋๋ก ๊ตฌ์ฑ๋์ด ์๊ธฐ ๋๋ฌธ์ ๋ฉํฐ ์ค๋ ๋๊ฐ ๋์์ Vector์ ๋ฉ์๋๋ค์ ์คํํ ์ ์๊ณ , ํ๋์ ์ค๋ ๋๊ฐ ๋ฉ์๋ ์คํ์ ์๋ฃํด์ผ๋ง ๋ค๋ฅธ ์ค๋ ๋๊ฐ ๋ฉ์๋๋ฅผ ์คํํ ์ ์๋ค.
List<E> list = new Vector<E>();
List<E> list = new Vector<>(); // ์๋ต
3) LinkedList
- ์ธ์ ์ฐธ์กฐ๋ฅผ ๋งํฌํด์ ์ฒด์ธ์ฒ๋ผ ๊ด๋ฆฌํ๋ค.
- ์ฒ์ ์์ฑ๋๋ฉด ์ด๋ ํ ๋งํฌ๋ ๋ง๋ค์ด์ง์ง ์๊ธฐ ๋๋ฌธ์ ๋ด๋ถ๋ ๋น์ด์๋ค.
- ํน์ ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํ๋ฉด ์๋ค ๋งํฌ๋ง ๋ณ๊ฒฝ๋๊ณ ๋๋จธ์ง ๋งํฌ๋ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
- ์ถ๊ฐ์ ์ญ์ ๊ฐ ๋น๋ฒํ๊ฒ ์ผ์ด๋๋ ๊ณณ์์ ์ฌ์ฉํ๊ธฐ ์ข๋ค.
List<E> list = new LinkedList<E>();
List<E> list = new LinkedList<>(); // ์๋ต
2. Set ์ปฌ๋ ์
๊ฐ์ฒด์ ์ ์ฅ ์์๋ฅผ ์ ์งํ์ง ์๊ณ ์ค๋ณต ์ ์ฅ์ ํ์ฉํ์ง ์๋๋ค.
๋ฉ์๋ | ์ค๋ช |
boolean add(E e) | ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ ์ ์ฅ ํ ์ฑ๊ณต์ด๋ฉด true๋ฅผ ์ค๋ณต ๊ฐ์ฒด๋ฉด false๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
boolean contains(Object o) | ์ฃผ์ด์ง ๊ฐ์ฒด๊ฐ ์ ์ฅ๋์ด์๋์ง ์กฐ์ฌํฉ๋๋ค. |
Iterator<E> iterator() | ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ํ ๋ฒ์ฉ ๊ฐ์ ธ์ค๋ ๋ฐ๋ณต์๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
boolean isEmpty() | ์ปฌ๋ ์ ์ด ๋น์ด์๋์ง ์กฐ์ฌํฉ๋๋ค. |
int Size() | ์ ์ฅ๋์ด ์๋ ์ ์ฒด ๊ฐ์ฒด ์๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
void clear() | ์ ์ฅ๋ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ์ญ์ ํฉ๋๋ค. |
boolean remove(Object o) | ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ ์ญ์ ํฉ๋๋ค. |
1) Iterator
Set ์ปฌ๋ ์ ์ ์ธ๋ฑ์ค๋ก ๊ฐ์ฒด๋ฅผ ๊ฒ์ํด์ ๊ฐ์ ธ์ฌ ์ ์๊ธฐ ๋๋ฌธ์ iterator๋ฅผ ํตํด ๋ฐ๋ณตํ์ฌ ์ฌ์ฉํ๋ค.
Iterator<String> iter = set.iterator();
while (iter.hasNext()) {
string str = iter.next();
if (str.equals("์ด๋ฆ"))
iter.remove();
}
2) HashSet
- HashSet์ด ํ๋จํ๋ ๋์ผํ ๊ฐ์ฒด๋ ๊ผญ ๊ฐ์ ์ธ์คํด์ค๋ฅผ ๋ปํ์ง๋ ์๋๋ค.
- hashCode()์ equals() ๋ฉ์๋ ์ฌ์ ์๋ฅผ ํตํด ๋๋ฑํ ๊ฐ์ฒด๋ก ๊ฐ์ฃผํ ์ง ๊ฒฐ์ ํ๋ค.
Set<E> set = new HashSet<E>();
Set<E> set = new HashSet<>(); // ์๋ต
- ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๊ธฐ ์ ์ hashCode() ๋ฉ์๋๋ฅผ ํธ์ถํด์ ์ด ์ฝ๋๋ก ์ ์ฅ๋์ด ์๋ ๊ฐ์ฒด๋ค๊ณผ ๋น๊ตํ๋ค.
- ๋ง์ฝ ๋์ผํ ํด์ ์ฝ๋๊ฐ ์๋ค๋ฉด equals() ๋ฉ์๋๋ก ๋ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค.
- true๊ฐ ๋์ค๋ฉด ๋์ผํ ๊ฐ์ฒด๋ก ํ๋จํ๊ณ ์ค๋ณต ์ ์ฅ์ ํ์ง ์๋๋ค.
3. Map ์ปฌ๋ ์
- ํค๊ณผ ๊ฐ์ผ๋ก ๊ตฌ์ฑ๋ Map.Entry ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๊ตฌ์กฐ๋ก Entry๋ Map ๋ด๋ถ์ ์ ์ธ๋ ์ค์ฒฉ ์ธํฐํ์ด์ค์ด๋ค.
- ํค๋ ์ค๋ณต ์ ์ฅ๋ ์ ์์ง๋ง ๊ฐ์ ์ค๋ณต ์ ์ฅ๋ ์ ์๋ค.
- ์ ์ฅ๋ ์ ์ฒด ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ํ๋์ฉ ์ป๊ณ ์ถ์ ๊ฒฝ์ฐ์๋
- keySet() ๋ฉ์๋๋ก ๋ชจ๋ ํค๋ฅผ Set ์ปฌ๋ ์ ์ผ๋ก ์ป์ ๋ค์, ๋ฐ๋ณต์๋ฅผ ํตํด ํค๋ฅผ ํ๋์ฉ ์ป๊ณ get() ๋ฉ์๋๋ฅผ ํตํด ๊ฐ์ ์ป๋๋ค.
- entrySet() ๋ฉ์๋๋ก ๋ชจ๋ Map.Entry๋ฅผ Set ์ปฌ๋ ์ ์ผ๋ก ์ป์ ๋ค์, ๋ฐ๋ณต์๋ฅผ ํตํด Map.Entry๋ฅผ ํ๋์ฉ ์ป๊ณ getKey()์ getValue() ๋ฉ์๋๋ฅผ ํตํด ํค์ ๊ฐ์ ์ป๋๋ค.
๋ฉ์๋ | ์ค๋ช |
V put(K Key, V value) | ์๋ก์ด ํค์ผ ๊ฒฝ์ฐ null์ ๋ฆฌํดํ๊ณ ๋์ผํ ํค๊ฐ ์์ ๊ฒฝ์ฐ ๊ฐ์ ๋์ฒดํ๊ณ ์ด์ ๊ฐ์ ๋ฆฌํดํฉ๋๋ค. |
boolean containsKey(Object Key) | ์ฃผ์ด์ง ํค๊ฐ ์๋์ง ์ฌ๋ถ๋ฅผ ํ์ธํฉ๋๋ค. |
boolean containsValue(Object value) | ์ฃผ์ด์ง ๊ฐ์ด ์๋์ง ์ฌ๋ถ๋ฅผ ํ์ธํฉ๋๋ค. |
Set<Map.Entry<K,V>> entrySet() | ๋ชจ๋ Map.Entry ๊ฐ์ฒด๋ฅผ Set์ ๋ด์์ ๋ฆฌํดํฉ๋๋ค. |
Set<K> keySet() | ๋ชจ๋ ํค๋ฅผ Set ๊ฐ์ฒด์ ๋ด์์ ๋ฆฌํดํฉ๋๋ค. |
V get(Object key) | ์ฃผ์ด์ง ํค์ ์๋ ๊ฐ์ ๋ฆฌํดํฉ๋๋ค. |
boolean isEmpty() | ์ปฌ๋ ์ ์ด ๋น์ด ์๋์ง ์ฌ๋ถ๋ฅผ ํ์ธํฉ๋๋ค. |
int size() | ์ ์ฅ๋ ํค์ ์ด ์๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
Collection<V> values() | ์ ์ฅ๋ ๋ชจ๋ ๊ฐ์ Collection์ ๋ด์์ ๋ฆฌํดํฉ๋๋ค. |
void clear() | ์ ์ฅ๋ ๋ชจ๋ Map.Entry๋ฅผ ์ญ์ ํฉ๋๋ค. |
V remove(Object Key) | ์ฃผ์ด์ง ํค์ ์ผ์นํ๋ Map.Entry๋ฅผ ์ญ์ ํ๊ณ ๊ฐ์ ๋ฆฌํดํฉ๋๋ค. |
1) HashMap
- ํค๋ก ์ฌ์ฉํ ๊ฐ์ฒด๋ hashCode()์ equals() ๋ฉ์๋๋ฅผ ์ฌ์ ์ํด์ ๋๋ฑ ๊ฐ์ฒด๊ฐ ๋ ์กฐ๊ฑด์ ์ ํด์ผ ํ๋ค.
Map<K, V> map = new HashMap<K, V>();
Map<K, V> map = new HashMap<>(); // ์๋ต
2) Hashtable
- HashMap๊ณผ ๋์ผํ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ๊ฐ๊ณ ๋์ผํ๊ฒ hashCode()์ equals() ๋ฉ์๋ ์ฌ์ ์๊ฐ ํ์ํ๋ค.
- ์ค๋ ๋ ์์ (Thread Safe): ๋๊ธฐํ๋ ๋ฉ์๋๋ก ๊ตฌ์ฑ๋์ด ์๊ธฐ ๋๋ฌธ์ ๋ฉํฐ ์ค๋ ๋๊ฐ ๋์์ Hashtable์ ๋ฉ์๋๋ค์ ์คํํ ์ ์๊ณ , ํ๋์ ์ค๋ ๋๊ฐ ๋ฉ์๋ ์คํ์ ์๋ฃํด์ผ๋ง ๋ค๋ฅธ ์ค๋ ๋๊ฐ ๋ฉ์๋๋ฅผ ์คํํ ์ ์๋ค.
Map<K, V> map = new Hashtable<K, V>();
Map<K, V> map = new Hashtable<>(); // ์๋ต
4. LIFO์ FIFO ์ปฌ๋ ์
1) LIFO(Last In First Out) Stack
๋์ค์ ๋ฃ์ ๊ฐ์ฒด๊ฐ ๋จผ์ ๋น ์ ธ๋๊ฐ๋ ๊ตฌ์กฐ์ด๋ค.
๋ฉ์๋ | ์ค๋ช |
E push(E item) | ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ ์คํ์ ๋ฃ์ต๋๋ค. |
E peek() | ์คํ์ ๋งจ ์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ต๋๋ค. ๊ฐ์ฒด๋ฅผ ์คํ์์ ์ ๊ฑฐํ์ง ์์ต๋๋ค. |
E pop() | ์คํ์ ๋งจ ์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ต๋๋ค. ๊ฐ์ฒด๋ฅผ ์คํ์์ ์ ๊ฑฐํฉ๋๋ค. |
Stack<E> stack = new Stack<E>();
Stack<E> stack = new Stack<>(); // ์๋ต
2) FIFO(First In First Out) Queue
๋จผ์ ๋ฃ์ ๊ฐ์ฒด๊ฐ ๋จผ์ ๋น ์ ธ๋๊ฐ๋ ๊ตฌ์กฐ์ด๋ค.
๋ฉ์๋ | ์ค๋ช |
boolean offer(E e) | ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ ํ์ ๋ฃ์ต๋๋ค. |
E peek() | ๊ฐ์ฒด ํ๋๋ฅผ ๊ฐ์ ธ์ต๋๋ค. ๊ฐ์ฒด๋ฅผ ํ์์ ์ ๊ฑฐํ์ง ์์ต๋๋ค. |
E poll() | ๊ฐ์ฒด ํ๋๋ฅผ ๊ฐ์ ธ์ต๋๋ค. ๊ฐ์ฒด๋ฅผ ํ์์ ์ ๊ฑฐํฉ๋๋ค. |
Queue<E> queue = new Queue<E>();
Queue<E> queue = new Queue<>(); // ์๋ต
// LinkedList๋ List ์ปฌ๋ ์
์ ๊ตฌํ ํด๋์ค์ด๊ธฐ๋ ํ์ง๋ง Queue ์ปฌ๋ ์
์ ๊ตฌํ ํด๋์ค๋ ๋ ์ ์๋ค.
Queue<E> queue = new LinkedList<>();