๋ธ๋ก๊ทธ ์ฎ๊ฒผ์ต๋๋ค! ๐ก integer.blog
์๋ฐ์ ์ ์(๋จ๊ถ์ฑ ์ ) ํ์ต๋ด์ฉ ์ ๋ฆฌ
1. ์ปฌ๋ ์ ํ๋ ์์ (Collections Framework)
‘๋ฐ์ดํฐ ๊ทธ๋ฃน์ ๋ค๋ฃจ๊ณ ํํํ๊ธฐ ์ํ ๋จ์ผํ๋ ๊ตฌ์กฐ’ - Java API๋ฌธ์
JDK1.2 ์ด์ ๊น์ง๋ Vector, Hashtable, Properties์ ๊ฐ์ ์ปฌ๋ ์ ํด๋์ค๋ค์ ๊ฐ์์ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌ
1.1. ํต์ฌ ์ธํฐํ์ด์ค
- List
- ์์ ์๋ ๋ฐ์ดํฐ ์งํฉ
- ๋ฐ์ดํฐ ์ค๋ณต ํ์ฉ
- ์์) ๋๊ธฐ์ ๋ช ๋จ
- Set
- ์์ ์๋ ๋ฐ์ดํฐ ์งํฉ
- ๋ฐ์ดํฐ ์ค๋ณต ๋ถํ
- ์์) ์์ ์ ์์งํฉ, ์์์ ์งํฉ
- Map
- ํค์ ๊ฐ์ ์์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ ์งํฉ
- ์์ ์๊ณ , ํค ์ค๋ณต ๋ถํ, ๊ฐ ์ค๋ณต ํ์ฉ
- ์ด๋ค ๋ ๊ฐ์ ์ฐ๊ฒฐํ๋ค๋ ์๋ฏธ์์ Map์ด๋ผ ์ง์ด์ง
- ์์) ์ฐํธ๋ฒํธ, ์ง์ญ๋ฒํธ
Vector๋ Hashtable๊ณผ ๊ฐ์ ๊ธฐ์กด์ ์ปฌ๋ ์ ํด๋์ค๋ค์ ํธํ์ ์ํด,
์ค๊ณ๋ฅผ ๋ณ๊ฒฝํด์ ๋จ๊ฒจ๋์์ง๋ง ์ฌ์ฉ์ํ๋ ๊ฒ์ด ์ข๋ค.
๋์ ์๋ก ์ถ๊ฐ๋ ArrayList์ HashMap ์ฌ์ฉ ๊ถ์ฅ.
1.2. ์ธํฐํ์ด์ค ์์๊ณ์ธต๋
List ์์๊ณ์ธต๋ -
List
-Vector
-Stack
-ArrayList
-LinkedList
Set ์์๊ณ์ธต๋ -
List
-HashSet
-SortedSet
-TreeSet
Map ์์๊ณ์ธต๋ -
Map
-Hashtable
-HashMap
-LinkedHashMap
-SortedMap
-TreeMap
1.3. Map.Entry ์ธํฐํ์ด์ค
Map.Entry ์ธํฐํ์ด์ค๋ Map ์ธํฐํ์ด์ค์ ๋ด๋ถ ์ธํฐํ์ด์ค์ด๋ค.
Map์ ์ ์ฅ๋๋ key-value ์์ ๋ค๋ฃจ๊ธฐ ์ํด ๋ด๋ถ์ Entry ์ธํฐํ์ด์ค ์ ์.
๋ด๋ถ ํด๋์ค์ ๊ฐ์ด ์ธํฐํ์ด์ค ์์ ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ๋ ๋ด๋ถ ์ธํฐํ์ด์ค๊ฐ ๊ฐ๋ฅํ๋ค.
public interface Map {
...
interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
boolean equals(Object o);
int hashCode();
...
}
}
2. ArrayList
ArrayList๋ ๊ธฐ์กด์ Vector๋ฅผ ๊ฐ์ ํ ๊ฒ.
ArrayList๋ Object ๋ฐฐ์ด์ ์ด์ฉํด์ ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ์ฅํ๋ค.
๋ฐฐ์ด์ ๋ ์ด์ ์ ์ฅํ ๊ณต๊ฐ์ด ์์ผ๋ฉด,
๋ณด๋ค ํฐ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํด์ ๊ธฐ์กด ๋ฐฐ์ด์ ์ ์ฅ๋ ๋ด์ฉ์ ์๋ก์ด ๋ฐฐ์ด๋ก ๋ณต์ฌํ๊ณ ์ ์ฅํ๋ค.
์ ์ธ๋ ๋ฐฐ์ด์ ํ์ ์ด Object์ด๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ์ข ๋ฅ์ ๊ฐ์ฒด๋ฅผ ๋ด์ ์ ์๋ค.
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable {
...
transient Object[] elementData; // Object๋ฐฐ์ด
...
}
2.1. list์ ๊ณตํต ์์ ์ญ์ ํ๊ธฐ
for(int i = list2.size()-1; i >= 0; i--) {
if(list1.contains(list2.get(i)))
list2.remove(i);
}
์์ ์ฝ๋์์ ๋ณ์ i๋ฅผ ์ฆ๊ฐ์ํค๋ฉด์ ์ญ์ ํ๋ฉด, ํ ์์๊ฐ ์ญ์ ๋ ๋๋ง๋ค
๋น ๊ณต๊ฐ์ ์ฑ์ฐ๊ธฐ ์ํด ๋๋จธ์ง ์์๋ค์ด ์๋ฆฌ์ด๋์ ํด์ผํด์ ์ฌ๋ฐ๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
๊ทธ๋์ i๋ฅผ ๊ฐ์์ํค๋ฉด์ ์ญ์ ๋ฅผ ํด์ผ ์๋ฆฌ์ด๋์ด ๋ฐ์ํด๋ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
2.2. ๋ฌธ์์ด ๋ฐ์ดํฐ๋ฅผ ์ํ๋ ๊ธธ์ด๋ก ์๋ผ์ ArrayList์ ๋ด๊ธฐ
import java.util.*;
class ArrayListEx {
public static void main(String[] args) {
final int LIMIT = 10; //์๋ฅด๊ณ ์ ํ๋ ๊ธ์์ ๊ฐ์ ์ง์
String source = "0123456789abcdefghijklmnopqrstuvwxyz"
int length = source.length();
List list = new ArrayList(length/LIMIT + 10); //ํฌ๊ธฐ๋ฅผ ์ฌ์ ์๊ฒ ์ก์
for(int 1=0; i< length; i+=LIMIT) {
if(i+LIMIT < length)
list.add(source.substring(i, i+LIMIT));
else
list.add(source.substring(i));
}
for(int i=0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
๋จ์ํ ๋ฌธ์์ด์ ํน์ ํฌ๊ธฐ๋ก ์๋ผ์ ์ถ๋ ฅํ ๊ฒ์ด๋ผ๋ฉด
charAt(int i)
์ for๋ฌธ์ ์ด์ฉํ๋ฉด ๋์ง๋ง,
ArrayList์ ๋ด์์ผ๋ก์ ๋ ๋ค์ํ ์์
์ ๊ฐ๋จํ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค.
ArrayList๋ Vector ๊ฐ์ด ๋ฐฐ์ด์ ์ด์ฉํ ์๋ฃ๊ตฌ์กฐ๋
๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ค๊ณ ์ ์ฅํ๋ ๋ฐ๋ ํจ์จ์ด ์ข์ง๋ง,
์ฉ๋์ ๋ณ๊ฒฝํด์ผํ ๋๋ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ ํ
๊ธฐ์กด ๋ฐฐ์ด๋ก๋ถํฐ ์ ๋ฐฐ์ด๋ก ๋ฐ์ดํฐ๋ฅผ ๋ณต์ฌํ๊ธฐ ๋๋ฌธ์ ํจ์จ์ด ๋จ์ด์ง๋ค.
๊ทธ๋ฌ๋ฏ๋ก ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋๋ถํฐ ์ถฉ๋ถํ ํฌ๊ธฐ๋ก ์์ฑํด์ผ ํ๋ค.
2.3. remove() ๋ฉ์๋
Object[] data = null; // ๊ฐ์ฒด๋ฅผ ๋ด๊ธฐ์ํ ๊ฐ์ฒด๋ฐฐ์ด ์ ์ธ
int capacity = 0; // ์ฉ๋
int size = 0; // ํฌ๊ธฐ
public Object remove(int index) {
Object oldObj = null;
if(index < 0 || index >=size)
throw new IndexOutOfBoundsException("๋ฒ์๋ฅผ ๋ฒ์ด๋ฌ์ต๋๋ค.");
oldObj = data[index];
if(index != size-1) {
System.arraycopy(data, index+1, data, index, size-index-1);
}
data[size-1] = null;
size--;
return oldObj;
}
๋ฐฐ์ด์ ์ค๊ฐ์ ์์นํ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ๋ ๊ฒฝ์ฐ
System.arraycopy()๋ฅผ ํธ์ถํด์ ๋ค๋ฅธ ๋ฐ์ดํฐ์ ์์น๋ฅผ ์ด๋์์ผ์ผ ํ๊ธฐ ๋๋ฌธ์ ์์ ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฐ๋ค.
3. LinkedList
๋ฐฐ์ด์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ค๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๋น ๋ฅด๋ค๋ ์ฅ์ ์ด ์์ง๋ง,
ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์์ผ๋ฏ๋ก, ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํด์ ๋ฐ์ดํฐ๋ฅผ ๋ณต์ฌํด์ผ ํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด์ ์คํ ์๋๋ฅผ ํฅ์์ํค๊ธฐ ์ํด์๋ ์ถฉ๋ถํ ํฐ ํฌ๊ธฐ๋ก ๋ฐฐ์ด์ ์์ฑํด์ผํ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ญ๋น๋๋ค.
๋ํ, ๋ฐฐ์ด์ ์ฐจ๋ก๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ณ ๋ง์ง๋ง์์๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ ๊ฒ์ ๋น ๋ฅด๋ค. ํ์ง๋ง ๋ฐฐ์ด ์ค๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ ค๋ฉด, ๋น์๋ฆฌ๋ฅผ ๋ง๋ค๊ธฐ ์ํด ๋ค๋ฅธ ๋ฐ์ดํฐ๋ค์ ๋ณต์ฌํด์ ์ด๋ํด์ผ ํ๋ค.
3.1. ์ญ์
๊ฐ๋จํ๋ค. ์ญ์ ํ๊ณ ์ ํ๋ ์์์ ์ด์ ์์๊ฐ ์ญ์ ํ๊ณ ์ ํ๋ ์์์ ๋ค์์์๋ฅผ ์ฐธ์กฐํ๋๋ก ๋ณ๊ฒฝํ๋ฉด ๋. ๋ฐฐ์ด์ฒ๋ผ ๋ฐ์ดํฐ๋ฅผ ์ด๋ํ๊ธฐ ์ํด ๋ณต์ฌํ๋ ๊ณผ์ ์ด ์๊ธฐ ๋๋ฌธ์ ์ฒ๋ฆฌ์๋๊ฐ ๋งค์ฐ ๋น ๋ฅด๋ค.
3.2. ์ด์ค ์ฐ๊ฒฐ๋ฆฌ์คํธ (Doubly Linked List)
๋งํฌ๋ ๋ฆฌ์คํธ๋ ์ด๋๋ฐฉํฅ์ด ๋จ๋ฐฉํฅ์ด๊ธฐ ๋๋ฌธ์ ์ด์ ์์์ ๋ํ ์ ๊ทผ์ ์ด๋ ต๋ค.
์ด์ค ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ์ฐธ์กฐ๋ณ์๋ฅผ ํ๋ ๋ ์ถ๊ฐํ์ฌ, ์ด์ ์์์ ๋ํ ์ฐธ์กฐ๊ฐ ๊ฐ๋ฅ
3.3. ArrayList์ LinkedList ๋น๊ต
- ์์ฐจ์ ์ธ ์ถ๊ฐ/์ญ์ ์ ArrayList๊ฐ ๋ ๋น ๋ฅด๋ค.
- ์์ฐจ์ ์ผ๋ก ์ญ์ ํ๋ค๋ ๊ฒ์ ๋ง์ง๋ง ๋ฐ์ดํฐ๋ถํฐ ์ญ์์ผ๋ก ์ญ์ ํ๋ ๊ฒ์ด๊ณ , ArrayList๋ ๋จ์ง ๋ง์ง๋ง ์์์ ๊ฐ์ null๋ก ๋ฐ๊พธ๋ฉด ๋๋ค.
- ์ค๊ฐ ๋ฐ์ดํฐ์ ์ถ๊ฐ/์ญ์ ์ LinkList๊ฐ ๋ ๋น ๋ฅด๋ค.
- LinkedList๋ ๊ฐ ์์๊ฐ์ ์ฐ๊ฒฐ๋ง ๋ณ๊ฒฝํด์ฃผ๋ฉด ๋๊ธฐ ๋๋ฌธ
- ๋ฐ๋ฉด ArrayList๋ ๊ฐ ์์๋ค์ ์ฌ๋ฐฐ์นํ์ฌ ์ถ๊ฐํ ๊ณต๊ฐ์ ํ๋ณดํ๊ฑฐ๋ ๋น๊ณต๊ฐ์ ์ฑ์์ผ ํ๋ค.
4. Stack๊ณผ Queue
Stack์ ๋ง์ง๋ง์ ์ ์ฅํ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ๊บผ๋ด๊ฒ ๋๋ LIFO(Last In First Out)๊ตฌ์กฐ.
Queue๋ ์ฒ์์ ์ ์ฅํ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ๊บผ๋ด๊ฒ ๋๋ FIFO(First In First Out)๊ตฌ์กฐ.
4.1. Stack๊ณผ Queue ๊ตฌํ
- Stack
- ์์ฐจ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ณ ์ญ์ ํ๋ ์คํ์๋ ArrayList์ ๊ฐ์ ๋ฐฐ์ด ๊ธฐ๋ฐ์ ์ปฌ๋ ์ ํด๋์ค๊ฐ ์ ํฉ
- Queue
- ํ๋ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ผ ๋ ํญ์ ์ฒซ๋ฒ์งธ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ค.
- ๊ทธ๋ฌ๋ฏ๋ก ArrayList์ ๊ฐ์ ๋ฐฐ์ด ๊ธฐ๋ฐ์ ์ปฌ๋ ์ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค๋ฉด, ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ผ ๋๋ง๋ค ๋น๊ณต๊ฐ์ ์ฑ์ฐ๊ธฐ ์ํด ๋ฐ์ดํฐ ๋ณต์ฌ๊ฐ ๋ฐ์ํด์ ๋นํจ์จ์ .
- ํ๋ ArrayList๋ณด๋ค ๋ฐ์ดํฐ์ ์ถ๊ฐ/์ญ์ ๊ฐ ์ฌ์ด LinkedList๊ฐ ๋ ์ ํฉํ๋ค.
4.2. Stack ๋ฉ์๋
boolean empty()
: Stack์ด ๋น์ด์๋์ง ์๋ ค์ค๋ค.Object peek()
: Stack์ ๋งจ ์์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ๋ฐํ.pop()
๊ณผ ๋ฌ๋ฆฌ Stack์์ ๊ฐ์ฒด๋ฅผ ๊บผ๋ด์ง๋ ์์Object pop()
: Stack์ ๋งจ ์์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ๊บผ๋ธ๋ค.Object push(Object item)
: Stack์ ๊ฐ์ฒด(item)๋ฅผ ์ ์ฅํ๋ค.int search(Object o)
: Stack์์ ์ฃผ์ด์ง ๊ฐ์ฒด(o)๋ฅผ ์ฐพ์์ ๊ทธ ์์น๋ฅผ ๋ฐํ. ๋ชป์ฐพ์ผ๋ฉด -1 ๋ฐํ. (๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ์์น๋ 0์ด ์๋ 1๋ถํฐ ์์)
4.3. Queue ๋ฉ์๋
boolean add(Object o)
: ์ง์ ๋ ๊ฐ์ฒด๋ฅผ Queue์ ์ถ๊ฐํ๋ค. ์ฑ๊ณตํ๋ฉดtrue
๋ฐํ. ์ ์ฅ๊ณต๊ฐ ๋ถ์กฑํ๋ฉดIlligalStateException
๋ฐ์boolean offer(Object o) : Queue์ ๊ฐ์ฒด๋ฅผ ์ ์ฅ. ์ฑ๊ณตํ๋ฉด
true์คํจํ๋ฉด
false` ๋ฐํObject remove()
: Queue์์ ๊ฐ์ฒด๋ฅผ ๊บผ๋ด ๋ฐํ. ๋น์ด์์ผ๋ฉดNoSuchElementException
๋ฐ์Object poll()
: Queue์์ ๊ฐ์ฒด๋ฅผ ๊บผ๋ด์ ๋ฐํ. ๋น์ด์์ผ๋ฉดnull
๋ฐํObject element()
: ์ญ์ ์์ด ์์๋ฅผ ์ฝ์ด์จ๋ค.peek()
๊ณผ ๋ฌ๋ฆฌ Queue๊ฐ ๋น์์ ๋NoSuchElementException ๋ฐ์
Object peek()
: ์ญ์ ์์ด ์์๋ฅผ ์ฝ์ด ์จ๋ค. Queue๊ฐ ๋น์ด์์ผ๋ฉดnull
๋ฐํ
Java์์๋ ์คํ์ Stack ํด๋์ค๋ก ๊ตฌํํ์ฌ ์ ๊ณตํ๊ณ ์์ง๋ง
ํ๋ Queue ์ธํฐํ์ด์ค๋ก ์ ์ํด๋๊ณ ํด๋์ค๋ ์ ๊ณตํ์ง ์๋๋ค.
๋์ Queue ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ค ์ค ํ๋๋ฅผ ์ ํํด์ ์ฌ์ฉํ๋ฉด ๋๋ค.
4.4. Stack ์ง์ ๊ตฌํํ๊ธฐ
import java.util.*;
class MyStack extends Vector {
public Object push(Object item) {
addElement(item);
return item;
}
public Object pop() {
Object obj = peek(); // Stack์ ์ ์ฅ๋ ๋ง์ง๋ง ์์๋ฅผ ์ฝ์ด์จ๋ค.
removeElementAt(size()-1); // ๋ง์ง๋ง ์์๋ฅผ ์ญ์ ํ๋ค. ๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ 0๋ถํฐ ์์ํ๋ฏ๋ก 1์ ๋นผ์ค๋ค.
return obj;
}
public Object peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len -1);
}
public boolean empty() {
return size() == 0;
}
public int search(Object 0) {
int i = lastIndexOf(o); // ๋์์๋ถํฐ ๊ฐ์ฒด๋ฅผ ์ฐพ๋๋ค.
if (i >= 0) {
return size() - i;
}
return -1; // ํด๋น ๊ฐ์ฒด๋ฅผ ์ฐพ์ง ๋ชปํ๋ฉด -1 ๋ฐํ
}
}
4.5. Deque(Double-Ended Queue)
Deque๋ ์์ชฝ ๋์ ์ถ๊ฐ/์ญ์ ๊ฐ๋ฅ
Deque๋ ์คํ๊ณผ ํ๋ฅผ ํ๋๋ก ํฉ์ณ๋์ ๊ฒ๊ณผ ๊ฐ์ผ๋ฉฐ ์คํ์ผ๋ก ์ฌ์ฉํ ์๋, ํ๋ก ์ฌ์ฉํ ์๋ ์๋ค.
Deque | Queue | Stack |
---|---|---|
offerLast() | offer() | push() |
pollLast() | pop() | |
pollFirst() | poll() | |
peekFirst() | peek() | |
peekLast() | peek() |
5. Iterator
์ปฌ๋ ์ ํ๋ ์์์์๋ ์ปฌ๋ ์ ์ ์ ์ฅ๋ ์์๋ค์ ์ฝ์ด์ค๋ ๋ฐฉ๋ฒ์ ํ์คํํ์๋ค.
์ปฌ๋ ์ ์ ์ ์ฅ๋ ๊ฐ ์์์ ์ ๊ทผํ๋ Iterator์ธํฐํ์ด์ค๋ฅผ ์ ์ํ๊ณ ,
Collection ์ธํฐํ์ด์ค์๋ Iterator(Iterator๋ฅผ ๊ตฌํํ ํด๋์ค์ ์ธ์คํด์ค)๋ฅผ ๋ฐํํ๋ iterator()๋ฅผ ์ ์ํ๊ณ ์๋ค.
public interface Iterator {
boolean hasnext();
Object next();
void remove();
}
public interface Collection {
...
public Iterator iterator();
...
}
์ปฌ๋ ์ ํด๋์ค์ ๋ํด iterator()๋ฅผ ํธ์ถํ์ฌ Iterator๋ฅผ ์ป์ ๋ค์ ๋ฐ๋ณต๋ฌธ(์ฃผ๋ก while๋ฌธ)์ ์ฌ์ฉํด์ ์ปฌ๋ ์ ํด๋์ค์ ์์๋ค์ ์ฝ์ด ์จ๋ค.
boolean hasNext()
- ์ฝ์ด์ฌ ์์๊ฐ ๋จ์์๋์ง ํ์ธ. ์์ผ๋ฉด true ์์ผ๋ฉด falseObject next()
- ๋ค์ ์์๋ฅผ ์ฝ์ด ์จ๋ค. next()๋ฅผ ํธ์ถํ๊ธฐ ์ ์ hasNext()๋ฅผ ํธ์ถํด์ ์ฝ์ด ์ฌ ์์๊ฐ ์๋์ง ํ์ธํ๋ ๊ฒ์ด ์์ .void remove()
- next()๋ก ์ฝ์ด ์จ ์์๋ฅผ ์ญ์ ํ๋ค. next()๋ฅผ ํธ์ถํ ๋ค์์ remove()๋ฅผ ํธ์ถํด์ผ ํ๋ค.
Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ปฌ๋ ์ ํด๋์ค๋ Key์ Value๋ฅผ ์์ผ๋ก ์ ์ฅํ๊ธฐ ๋๋ฌธ์ iterator()๋ฅผ ์ง์ ํธ์ถํ ์ ์๋ค. ๋์ keySet()์ด๋ entrySet()์ ํตํด Key์ Value๋ฅผ ๊ฐ๊ฐ ๋ฐ๋ก Set์ ํํ๋ก ์ป์ด ์จ ํ์ ๋ค์ iterator()๋ฅผ ํธ์ถํด์ผ Iterator๋ฅผ ์ป์ ์ ์๋ค.
Map map = new HashMap(); ... Iterator it = map.keySet().iterator();
Listํด๋์ค๋ค์ ์ ์ฅ์์๋ฅผ ์ ์งํ๊ธฐ ๋๋ฌธ์ Iterator๋ฅผ ์ด์ฉํด์ ์ฝ์ด ์จ ๊ฒฐ๊ณผ ์ญ์ ์ ์ฅ ์์์ ๋์ผํ์ง๋ง Setํด๋์ค๋ค์ ๊ฐ ์์๊ฐ์ ์์๊ฐ ์ ์ง๋์ง ์๊ธฐ ๋๋ฌธ์ Iterator๋ฅผ ์ด์ฉํด์ ์ ์ฅ๋ ์์๋ค์ ์ฝ์ด ์๋ ์ฒ์์ ์ ์ฅ๋ ์์์ ๊ฐ์ง ์๋ค.
5.1. ListIterator
ListIterator๋ Iterator๋ฅผ ์์๋ฐ์์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ๊ฒ์ผ๋ก, ์ปฌ๋ ์ ์ ์์์ ์ ๊ทผํ ๋ Iterator๋ ๋จ๋ฐฉํฅ์ผ๋ก๋ง ์ด๋ํ ์ ์์ง๋ง, ListIterator๋ ์๋ฐฉํฅ์ผ๋ก์ ์ด๋์ด ๊ฐ๋ฅ. ๋จ, List์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ปฌ๋ ์ ์์๋ง ์ฌ์ฉ ๊ฐ๋ฅ
void add(Object o)
- ์ปฌ๋ ์ ์ ์๋ก์ด ๊ฐ์ฒด(o)๋ฅผ ์ถ๊ฐhasPrevious()
- ์ฝ์ด ์ฌ ์ด์ ์์๊ฐ ๋จ์์๋์ง ํ์ธ. ์์ผ๋ฉด true, ์์ผ๋ฉด falseObject previous()
- ์ด์ ์์๋ฅผ ์ฝ์ด ์จ๋ค. previous()๋ฅผ ํธ์ถํ๊ธฐ ์ ์ hasPrevious()๋ฅผ ํธ์ถํด์ ์ฝ์ด ์ฌ ์์๊ฐ ์๋์ง ํ์ธํ๋ ๊ฒ์ด ์์ .int nextIndex()
- ๋ค์ ์์์ index๋ฅผ ๋ฐํint previousIndex()
- ์ด์ ์์์ index๋ฅผ ๋ฐํvoid set(Object o)
- next() ๋๋ previous()๋ก ์ฝ์ด ์จ ์์๋ฅผ ์ง์ ๋ ๊ฐ์ฒด(o)๋ก ๋ณ๊ฒฝ. ๋ฐ๋์ next()๋ previous()๋ฅผ ๋จผ์ ํธ์ถํ ๋ค์์ ์ด ๋ฉ์๋๋ฅผ ํธ์ถํด์ผํ๋ค.
6. Arrays
Arrays ํด๋์ค์๋ ๋ฐฐ์ด์ ๋ค๋ฃจ๋๋ฐ ์ ์ฉํ ๋ฉ์๋๊ฐ ์ ์๋์ด ์๋ค.
Arrays์ ์ ์๋ ๋ฉ์๋๋ ๋ชจ๋ static ๋ฉ์๋๋ค.
6.1. ๋ฐฐ์ด ๋ณต์ฌ - copyOf(), copyOfRange()
copyOf()๋ ๋ฐฐ์ด ์ ์ฒด ๋ณต์ฌ, copyOfRange()๋ ๋ฐฐ์ด์ ์ผ๋ถ๋ฅผ ๋ณต์ฌํด์ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ค์ด ๋ฐํ.
copyOfRange()์ ์ง์ ๋ ๋ฒ์์ ๋์ ํฌํจ๋์ง ์๋๋ค.
int[] arr = {0,1,2,3,4,};
int[] arr2 = Arrays.copyOf(arr, 3); // arr2 = [0,1,2]
int[] arr3 = Arrays.copyOfRange(arr, 2, 4); // arr3 = [2,3]
6.2. ๋ฐฐ์ด ์ฑ์ฐ๊ธฐ - fill(), setAll()
fill()์ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ง์ ๋ ๊ฐ์ผ๋ก ์ฑ์ด๋ค.
setAll()์ ๋ฐฐ์ด์ ์ฑ์ฐ๋๋ฐ ์ฌ์ฉํ ํจ์ํ ์ธํฐํ์ด์ค๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ๋๋ค.
int[] arr = new int[5];
Arrays.fill(arr, 9); // arr = [9,9,9,9,9]
Arrays.setAll(arr, () -> (int)(Math.random()*5)+1); // arr = [1,5,2,1,1]
6.3. ๋ฐฐ์ด ์ ๋ ฌ, ๊ฒ์ - sort(), binarySearch()
sort()๋ ๋ฐฐ์ด ์ ๋ ฌ, binarySearch()๋ ๋ฐฐ์ด์ ์ ์ฅ๋ ์์๋ฅผ ๊ฒ์
binarySearch()๋ ๋ฐฐ์ด์์ ์ง์ ๋ ๊ฐ์ด ์ ์ฅ๋ ์์น(index)๋ฅผ ์ฐพ์์ ๋ฐํ. ๋ฐ๋์ ๋ฐฐ์ด์ด ์ ๋ ฌ๋ ์ํ์ฌ์ผ ์ฌ๋ฐ๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ์ป๋๋ค.
int[] arr = { 3, 2, 0, 1, 4,};
Arrays.sort(arr); // arr = [0,1,2,3,4]
int idx = Arrays.binarySearch(arr, 2); // idx = 2
6.4. ๋ฌธ์์ด์ ๋น๊ต, ์ถ๋ ฅ - equals(), toString()
equals(), toString()์ ์ผ์ฐจ์ ๋ฐฐ์ด์๋ง ์ฌ์ฉ ๊ฐ๋ฅ.
๋ค์ฐจ์ ๋ฐฐ์ด์๋ deepEquals(), deepToString() ์ฌ์ฉ.
deepToString()์ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ฌ๊ท์ ์ผ๋ก ์ ๊ทผํด์ ๋ฌธ์์ด์ ๊ตฌ์ฑํ๋ฏ๋ก 3์ฐจ์ ์ด์์ ๋ฐฐ์ด์๋ ๋์
- ๋ค์ฐจ์ ๋ฐฐ์ด์ ‘๋ฐฐ์ด์ ๋ฐฐ์ด’์ ํํ๋ก ๊ตฌ์ฑํ๊ธฐ ๋๋ฌธ์ equals()๋ก ๋น๊ตํ๋ฉด, ๋ฌธ์์ด์ ๋น๊ตํ๋ ๊ฒ์ด ์๋๋ผ ‘๋ฐฐ์ด์ ์ ์ฅ๋ ๋ฐฐ์ด์ ์ฃผ์’๋ฅผ ๋น๊ตํ๊ฒ ๋๋ค.
6.5. ๋ฐฐ์ด์ List๋ก ๋ฐํ - asList(Object…a)
asList()๋ ๋ฐฐ์ด์ List์ ๋ด์์ ๋ฐํ.
- ๋งค๊ฐ๋ณ์์ ํ์
์ด ๊ฐ๋ณ์ธ์๋ผ์ ๋ฐฐ์ด ์์ฑ ์์ด ์ ์ฅํ ์์๋ค๋ง ๋์ดํ๋ ๊ฒ๋ ๊ฐ๋ฅ
- asList()๊ฐ ๋ฐํํ List์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
- ํฌ๊ธฐ ๋ณ๊ฒฝ๊ฐ๋ฅํ List๋
List list = new ArrayList(Arrays.asList(1,2,3,4,5));
7. Comparator์ Comparable
Arrays.sort()๋ฅผ ํธ์ถํ๋ฉด ์์์ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ ๊ฒ์ฒ๋ผ ๋ณด์ด์ง๋ง,
์ฌ์ค์ Chractorํด๋์ค์ Comparable์ ๊ตฌํ์ ์ํด ์ ๋ ฌ๋์๋ ๊ฒ.
Comparble์ ๊ตฌํํ ํด๋์ค๋ ์ ๋ ฌ์ด ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ ์๋ฏธ.
public interface Comparator {
int compare(Object o1, Object o2);
boolean equals(Object obj);
}
public interface Comparable {
public int compareTo(Object o);
}
Comparable์ java.lang ํจํค์ง์ ์๊ณ , Comparator๋ java.util ํจํค์ง์ ์๋ค.
- Comparable : ๊ธฐ๋ณธ ์ ๋ ฌ๊ธฐ์ค์ ๊ตฌํํ๋๋ฐ ์ฌ์ฉ.
- Comparator : ๊ธฐ๋ณธ ์ ๋ ฌ๊ธฐ์ค ์ธ์ ๋ค๋ฅธ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ณ ์ํ ๋ ์ฌ์ฉ
8. HashSet
HashSet์ Set์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ฐ์ฅ ๋ํ์ ์ธ ์ปฌ๋ ์ .
HashSet์ ์ ์ฅ์์๋ฅผ ์ ์งํ์ง ์์ผ๋ฏ๋ก ์ ์ฅ์์๋ฅผ ์ ์งํ๊ณ ์ ํ๋ค๋ฉด LinkedHashSet ์ฌ์ฉ.
- ๋ก๋๋ฒํธ ์์
import java.util.*;
class HashSetLotto {
public static void main(String[] args) {
Set set = new HashSet();
for (int i = 0; set.size() < 6; i++) {
int num = (int)(Math.random()*45) + 1;
set.add(new Integer(num));
}
List list = new LinkedList(set);
Collections.sort(list);
System.out.println(list);
}
}
๋ฒํธ๋ฅผ ํฌ๊ธฐ ์์ผ๋ก ์ ๋ ฌํ๊ธฐ ์ํด Collectionsํด๋์ค์ sort(List list)๋ฅผ ์ฌ์ฉํ๋ค.
์ด ๋ฉ์๋๋ ์ธ์๋ก List์ธํฐํ์ด์ค ํ์ ์ ํ์๋ก ํ๊ธฐ ๋๋ฌธ์
LinkedListํด๋์ค์ ์์ฑ์ LinkedList(Collection c)๋ฅผ ์ด์ฉํด์ HashSet์ ์ ์ฅ๋ ๊ฐ์ฒด๋ค์ LinkedList์ ๋ด์์ ์ฒ๋ฆฌํ๋ค.
9. TreeSet
TreeSet์ ์ด์ง๊ฒ์ํธ๋ฆฌ(binary search tree) ํํ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์ปฌ๋ ์ ํด๋์ค๋ค.
TreeSet์ ์ด์ง๊ฒ์ํธ๋ฆฌ์ ์ฑ๋ฅ์ ํฅ์์ํจ Red-Black tree๋ก ๊ตฌํ๋์ด ์๋ค.
์ค๋ณต๋ ๋ฐ์ดํฐ์ ์ ์ฅ์ ํ์ฉํ์ง ์์ผ๋ฉฐ, ์ ๋ ฌ๋ ์์น์ ์ ์ฅํ๋ฏ๋ก ์ ์ฅ์์๋ฅผ ์ ์งํ์ง๋ ์๋๋ค.
TreeSet์ ์ ๋ ฌ๋ ์ํ๋ฅผ ์ ์งํ๊ธฐ ๋๋ฌธ์ ๋จ์ผ ๊ฐ ๊ฒ์๊ณผ ๋ฒ์๊ฒ์, ์๋ฅผ ๋ค๋ฉด 3๊ณผ 7์ฌ์ด์ ๋ฒ์์ ์๋ ๊ฐ์ ๊ฒ์ํ๋ ๊ฒ์ด ๋งค์ฐ ๋น ๋ฅด๋ค.
Binary Search Tree
- ๋ชจ๋ ๋ ธ๋๋ ์ต๋ ๋ ๊ฐ์ ์์๋ ธ๋๋ฅผ ๊ฐ์ง ์ ์๋ค.
- ์ผ์ชฝ ์์๋ ธ๋์ ๊ฐ์ ๋ถ๋ชจ๋ ธ๋์ ๊ฐ๋ณด๋ค ์๊ณ , ์ค๋ฅธ์ชฝ ์์๋ ธ๋์ ๊ฐ์ ๋ถ๋ชจ๋ ธ๋์ ๊ฐ๋ณด๋ค ์ปค์ผํ๋ค.
- ๋ ธ๋์ ์ถ๊ฐ ์ญ์ ์ ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค.(์์ฐจ์ ์ผ๋ก ์ ์ฅํ์ง ์์ผ๋ฏ๋ก)
- ๊ฒ์(๋ฒ์๊ฒ์)๊ณผ ์ ๋ ฌ์ ์ ๋ฆฌํ๋ค.
- ์ค๋ณต๋ ๊ฐ์ ์ ์ฅํ์ง ๋ชปํ๋ค.
TreeSet์ผ๋ก ๋ง๋ ๋ก๋๋ฒํธ ์์ฑ ํ๋ก๊ทธ๋จ (HashSet์ผ๋ก ๋ง๋ ๊ฒ๊ณผ ๋ฌ๋ฆฌ ์ ๋ ฌํ๋ ์ฝ๋๊ฐ ํ์์๋ค. TreeSet์ ์ ์ฅํ ๋ ์ด๋ฏธ ์ ๋ ฌํ๊ธฐ ๋๋ฌธ์.)
import java.util.*;
class TreeSetLotto {
public static void main(String[]args) {
Set set = new TreeSet();
for (int i =0; set.size() < 6; i++) {
int num = (int)(Math.random()*45) + 1;
set.add(num); // set.add(new Integer(num));
}
System.out.println(set);
}
}
- headSet()๊ณผ tailSet()์ ์ฌ์ฉํ๋ฉด, TreeSet์ ์ ์ฅ๋ ๊ฐ์ฒด ์ค ์ง์ ๋ ๊ธฐ์ค ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ ๊ฐ์ฒด๋ค๊ณผ ์์ ๊ฐ์ ๊ฐ์ฒด๋ค์ ์ป์ ์ ์๋ค.
import java.util.*;
class TreeSetEx2 {
public static void main(String[] args) {
TreeSet set = new TreeSet();
int[] score = {80, 95, 50, 35, 45, 65, 10, 100};
for (int i=0; i < score.length; i++)
set.add(new Integer(score[i]));
System.out.println("50๋ณด๋ค ์์ ๊ฐ :" + set.headSet(new Integer(50)));
System.out.println("50๋ณด๋ค ํฐ ๊ฐ :" + set.tailSet(new Integer(50)));
}
}
10. HashMap
Hashtable๊ณผ HashMap์ ๊ด๊ณ๋ Vector์ ArrayList์ ๊ด๊ณ์ ๊ฐ์์ Hashtable๋ณด๋ค๋ ์๋ก์ด ๋ฒ์ ์ธ HashMap์ ์ฌ์ฉํ ๊ฒ์ ๊ถํ๋ค.
HashMap์ Map์ ๊ตฌํํ์ผ๋ฏ๋ก ํค์ ๊ฐ์ ๋ฌถ์ด์ ํ๋์ ๋ฐ์ดํฐ๋ก ์ ์ฅํ๋ค.
๊ทธ๋ฆฌ๊ณ hashing์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๋๋ฐ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ณด์ธ๋ค.
public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable {
transient Entry[] table;
...
static class Entry implements Map.Entry {
final Object key;
Object value;
...
}
}
HashMap์ Entry๋ผ๋ ๋ด๋ถ ํด๋์ค๋ฅผ ์ ์ํ๊ณ , ๋ค์ Entryํ์ ์ ๋ฐฐ์ด์ ์ ์ธํ๋ค.
ํค์ ๊ฐ์ ๋ณ๊ฐ์ ๊ฐ์ด ์๋๋ผ ์๋ก ๊ด๋ จ๋ ๊ฐ์ด๊ธฐ ๋๋ฌธ์
๊ฐ๊ฐ์ ๋ฐฐ์ด๋ก ์ ์ธํ๊ธฐ ๋ณด๋ค๋ ํ๋์ ํด๋์ค๋ก ์ ์ํด์ ํ๋์ ๋ฐฐ์ด๋ก ๋ค๋ฃจ๋ ๊ฒ์ด ๋ฐ์ดํฐ์ ๋ฌด๊ฒฐ์ฑ(integrity)์ ์ธ ์ธก๋ฉด์์ ๋ ๋ฐ๋์งํ๊ธฐ ๋๋ฌธ.
- HashMap์ ํค์ ๊ฐ์ ๊ฐ๊ฐ Object ํ์ ์ผ๋ก ์ ์ฅํ๋ค.
- (Object, Object)์ ํํ๋ก ์ ์ฅํ๊ธฐ ๋๋ฌธ์ ์ด๋ ํ ๊ฐ์ฒด๋ ์ ์ฅํ ์ ์์ง๋ง key๋ ์ฃผ๋ก String์ ๋๋ฌธ์ ๋๋ ์๋ฌธ์๋ก ํต์ผํด์ ์ฌ์ฉํ๋ค.
11. ํด์ฑ๊ณผ ํด์ํจ์
ํด์ฑ์ด๋ ํด์ํจ์(hash function)๋ฅผ ์ด์ฉํด์ ๋ฐ์ดํฐ๋ฅผ ํด์ํ ์ด๋ธ(hash table)์ ์ ์ฅํ๊ณ ๊ฒ์ํ๋ ๊ธฐ๋ฒ
ํด์ํจ์๋ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋ ๊ณณ์ ์๋ ค์ฃผ๊ธฐ ๋๋ฌธ์ ๋ค๋์ ๋ฐ์ดํฐ ์ค์์๋ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ์ฐพ์ ์ ์๋ค.
- ํด์ฑ์ ๊ตฌํํ ํจ์ - HashSet, HashMap, Hashtable
- Hashtable์ Collection Framework๊ฐ ๋์ ๋๋ฉด์ HashMap์ผ๋ก ๋์ฒด๋์์ผ๋ ์ด์ ์์ค์์ ํธํ์ฑ ๋ฌธ์ ๋ก ๋จ๊ฒจ๋๊ณ ์๋ค.
11.1. hashCode()
- HashMap๊ณผ ๊ฐ์ด ํด์ฑ์ ๊ตฌํํ ์ปฌ๋ ์ ํด๋์ค์์๋ Objectํด๋์ค์ ์ ์๋ hashCode()๋ฅผ ํด์ํจ์๋ก ์ฌ์ฉํ๋ค.
- Objectํด๋์ค์ ์ ์๋ hashCode()๋ ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ์ด์ฉํ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํด์์ฝ๋๋ฅผ ๋ง๋ค๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ๊ฐ์ฒด์ ๋ํด hashCode()๋ฅผ ํธ์ถํ ๊ฒฐ๊ณผ๊ฐ ์๋ก ์ ์ผํ ํ๋ฅญํ ๋ฐฉ๋ฒ์ด๋ค.
- Stringํด๋์ค์ ๊ฒฝ์ฐ Object๋ก ๋ถํฐ ์์๋ฐ์ hashCode()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํด์ ๋ฌธ์์ด์ ๋ด์ฉ์ผ๋ก ํด์์ฝ๋๋ฅผ ๋ง๋ค์ด๋ธ๋ค. ๊ทธ๋์ ์๋ก ๋ค๋ฅธ String์ธ์คํด์ค์ผ์ง๋ผ๋ ๊ฐ์ ๋ด์ฉ์ ๋ฌธ์์ด์ ๊ฐ์ก๋ค๋ฉด hashCode()๋ฅผ ํธ์ถํ๋ฉด ๊ฐ์ ํด์์ฝ๋๋ฅผ ์ป๋๋ค.
12. TreeMap
TreeMap์ ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด ์ด์ง๊ฒ์ํธ๋ฆฌ์ ํํ๋ก ํค์ ๊ฐ์ ์์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค.
๊ทธ๋์ ๊ฒ์๊ณผ ์ ๋ ฌ์ ์ ํฉํ ํด๋์ค์ด๋ค.
๊ฒ์์ ๊ฒฝ์ฐ ๋๋ถ๋ถ์ ๊ฒฝ์ฐ์์ HashMap์ด TreeMap๋ณด๋ค ๋ ๋ฐ์ด๋๋ค.
๋ค๋ง ๋ฒ์๊ฒ์์ด๋ ์ ๋ ฌ์ด ํ์ํ ๊ฒฝ์ฐ TreeMap์ด ๋ซ๋ค.
13. Properties
Properties๋ HashMap์ ๊ตฌ๋ฒ์ ์ธ Hashtable์ ์์๋ฐ์ ๊ตฌํํ ๊ฒ์ด๋ค.
Hashtable์ ํค์ ๊ฐ์ (Object, Object)์ ํํ๋ก ์ ์ฅํ๋๋ฐ ๋นํด
Properties๋ (String, String)์ ํํ๋ก ์ ์ฅํ๋ ๋ณด๋ค ๋จ์ํ๋ ์ปฌ๋ ์ ํด๋์ค์ด๋ค.
- ์ฃผ๋ก ์ ํ๋ฆฌ์ผ์ด์
์ ํ๊ฒฝ์ค์ ๊ณผ ๊ด๋ จ๋ ์์ฑ(property)์ ์ ์ฅํ๋๋ฐ ์ฌ์ฉ๋๋ค.
- ๋ฐ์ดํฐ๋ฅผ ํ์ผ๋ก๋ถํฐ ์ฝ๊ณ ์ฐ๋ ํธ๋ฆฌํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
- Properties๋ ์ปฌ๋ ์
ํ๋ ์์ ์ด์ ์ ๊ตฌ๋ฒ์ ์ด๋ฏ๋ก Iterator๊ฐ ์๋ Enumeration์ ์ฌ์ฉํ๋ค.
- list๋ฉ์๋๋ก Properties์ ์ ์ฅ๋ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ๋ฉด ๋๋ ํ์ผ์ ํธํ๊ฒ ์ถ๋ ฅํ ์ ์๋ค.
void list(PrintStream out)
void list(PrintWriter out)
14. Collections
Arrays๊ฐ ๋ฐฐ์ด๊ณผ ๊ด๋ จ๋ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ ๊ฒ์ฒ๋ผ, Collections๋ ์ปฌ๋ ์ ๊ณผ ๊ด๋ จ๋ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค.
fill(), copy(), sort(), binarySearch() ๋ฑ์ ๋ฉ์๋๋ ๋ ํด๋์ค ๋ชจ๋์ ํฌํจ๋์ด ์์ผ๋ฉฐ ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ค.
14.1. ์ปฌ๋ ์ ์ ๋๊ธฐํ
- ๋ฉํฐ ์ฐ๋ ๋(multi-thread) ํ๋ก๊ทธ๋๋ฐ์์๋ ํ๋์ ๊ฐ์ฒด๋ฅผ ์ฌ๋ฌ ์ฐ๋ ๋๊ฐ ๋์์ ์ ๊ทผํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ์ ์ผ๊ด์ฑ(consistency)์ ์ ์งํ๊ธฐ ์ํด์๋ ๊ณต์ ๋๋ ๊ฐ์ฒด์ ๋๊ธฐํ(synchronization)๊ฐ ํ์ํ๋ค.
- ์๋ก ์ถ๊ฐ๋ ArrayList์ HashMap๊ณผ ๊ฐ์ ์ปฌ๋ ์
์ ๋๊ธฐํ๋ฅผ ์์ฒด์ ์ผ๋ก ์ฒ๋ฆฌํ์ง ์๋๋ค.
- ํ์ํ ๊ฒฝ์ฐ์๋ง java.util.Collections ํด๋์ค์ ๋๊ธฐํ ๋ฉ์๋๋ฅผ ์ด์ฉํด์ ๋๊ธฐํ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋๋ก ๋ณ๊ฒฝํ์๋ค.
15. ์ปฌ๋ ์ ํด๋์ค ์์ฝ
ArrayList
: ๋ฐฐ์ด๊ธฐ๋ฐ. ๋ฐ์ดํฐ์ ์ถ๊ฐ์ ์ญ์ ์ ๋ถ๋ฆฌ. ์์ฐจ์ ์ธ ์ถ๊ฐ์ญ์ ๋ ์ ์ผ ๋น ๋ฆ. ์์์ ์์์ ๋ํ ์ ๊ทผ์ฑ์ด ๋ฐ์ด๋จ.LinkedList
: ์ฐ๊ฒฐ๊ธฐ๋ฐ. ๋ฐ์ดํฐ์ ์ถ๊ฐ์ ์ญ์ ์ ์ ๋ฆฌ. ์์์ ์์์ ๋ํ ์ ๊ทผ์ฑ์ด ์ข์ง ์๋ค.HashMap
: ๋ฐฐ์ด๊ณผ ์ฐ๊ฒฐ์ด ๊ฒฐํฉ๋ ์ํ. ์ถ๊ฐ,์ญ์ ,๊ฒ์,์ ๊ทผ์ฑ์ด ๋ชจ๋ ๋ฐ์ด๋จ. ๊ฒ์์๋ ์ต๊ณ ์ ์ฑ๋ฅ.TreeMap
: ์ฐ๊ฒฐ๊ธฐ๋ฐ. ์ ๋ ฌ๊ณผ ๊ฒ์(ํนํ ๋ฒ์๊ฒ์)์ ์ ํฉ. ๊ฒ์์ฑ๋ฅ์ HashMap๋ณด๋ค ๋จ์ด์ง.Stack
: Vector๋ฅผ ์์๋ฐ์ ๊ตฌํQueue
: LinkedList๊ฐ Queue์ธํฐํ์ด์ค๋ฅผ ๊ตฌํProperties
: Hashtable์ ์์๋ฐ์ ๊ตฌํHashSet
: HashMap์ ์ด์ฉํด์ ๊ตฌํTreeSet
: TreeMap์ ์ด์ฉํด์ ๊ตฌํLinkedHashMap
: HashMap๊ณผ HashSet์ ์ ์ฅ์์์ ์ง๊ธฐ๋ฅ ์ถ๊ฐLinkedHashSet
: HashMap๊ณผ HashSet์ ์ ์ฅ์์์ ์ง๊ธฐ๋ฅ ์ถ๊ฐ