"์•ˆ๋…•, ์•„๋ฏธ๊ณ !"

"์•ˆ๋…•, ์—˜๋ฆฌ!"

"์˜ค๋Š˜ ์šฐ๋ฆฌ๋Š” ์ปฌ๋ ‰์…˜์˜ ๊ตฌ์กฐ์— ๋Œ€ํ•ด ๋‹จ๋ฒˆ์— ์™„์ „ํžˆ ์•Œ์•„๋ณผ ๊ฒƒ์ž…๋‹ˆ๋‹ค."

"๋‚˜๋Š” ์ด๊ฒƒ์„ ์˜ค๋žซ๋™์•ˆ ๊ธฐ๋‹ค๋ ธ๋‹ค."

"์ปฌ๋ ‰์…˜์ด ๋ฌด์—‡์ธ์ง€ ์ด๋ฏธ ์•Œ๊ณ  ์žˆ๊ณ  ์–ด๋–ป๊ฒŒ ์ž‘์—…ํ•˜๋Š”์ง€ ์•Œ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ง€์‹์„ ์—„๊ฒฉํ•œ ์‹œ์Šคํ…œ์œผ๋กœ ์ •๋ฆฌํ•  ๋•Œ์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋ฉด ๋งŽ์€ '์™œ'์™€ '์–ด๋–ป๊ฒŒ'์— ๋Œ€ํ•œ ์งˆ๋ฌธ์ด ์‚ฌ๋ผ์ง€๊ณ  ๋Œ€๋ถ€๋ถ„์˜ ๊ฒƒ์ด ๋ถ„๋ช…ํ•ด์งˆ ๊ฒƒ์ž…๋‹ˆ๋‹ค."

" ์ปฌ๋ ‰์…˜ ์ธํ„ฐํŽ˜์ด์Šค . ์ปฌ๋ ‰์…˜ ์ธํ„ฐํŽ˜์ด์Šค ์˜ ์ƒ์† ๊ตฌ์กฐ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค."

์ปฌ๋ ‰์…˜ ์ธํ„ฐํŽ˜์ด์Šค - 1

๋‘ ๊ฐ€์ง€๋ฅผ ์ฃผ๋ชฉํ•˜์‹ญ์‹œ์˜ค.

์ฒซ์งธ, ์—ฌ๊ธฐ์— ํ‘œ์‹œ๋˜๋Š” ๋ชจ๋“  ๊ฒƒ์€ ์ธํ„ฐํŽ˜์ด์Šค์ž…๋‹ˆ๋‹ค.

๋‘˜์งธ, ํ™”์‚ดํ‘œ๋Š” ยซ์ƒ์†ยป์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

"์ฆ‰, List, Set ๋ฐ Queue๋Š” Collection์„ ์ƒ์†ํ•˜์ง€๋งŒ Map์€ ๊ทธ๋ ‡์ง€ ์•Š์Šต๋‹ˆ๊นŒ?"

"๊ทธ๋ ‡์Šต๋‹ˆ๋‹ค. ์ถ”์ƒ ํด๋ž˜์Šค๋Š” ์ด๋Ÿฌํ•œ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์ƒ์†ํ•˜๊ณ , ์ฐจ๋ก€๋กœ  ArrayList, Hashtable, TreeSet,โ€ฆ "

"๋งž์•„์š”."

"์ด์ œ ์ด๋Ÿฌํ•œ ์ธํ„ฐํŽ˜์ด์Šค์˜ ๋ฉ”์„œ๋“œ๊ฐ€ ๋ฌด์—‡์ธ์ง€ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค."

Iterable<E>: ์ธํ„ฐํŽ˜์ด์Šค ์˜ ๋ฉ”์„œ๋“œ :

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
Iterator<T> iterator(); ๋ฐ˜๋ณต์ž ๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

"์ถฉ๋ถ„ํ•˜์ง€ ์•Š์€ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค."

"๊ธ€์Ž„, ๊ทธ๊ฒŒ ์–ผ๋งˆ๋‚˜ ๋งŽ์€์ง€. Iterator์— ๋Œ€ํ•œ ์ „๋ถ€์ž…๋‹ˆ๋‹ค. ์ง€๊ธˆ์€ ๋‹ค๋ฃจ์ง€ ์•Š๊ฒ ์ง€๋งŒ ๊ณง ์ž์„ธํžˆ ๋‹ค๋ฃฐ ๊ฒƒ์ž…๋‹ˆ๋‹ค."

Collection<E> ์˜ ๋ฉ”์†Œ๋“œ : ์ธํ„ฐํŽ˜์ด์Šค:

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
boolean add(E e); ์ปฌ๋ ‰์…˜์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
boolean addAll(Collection<? extends E> c); ์ปฌ๋ ‰์…˜์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
void clear(); ์ปฌ๋ ‰์…˜์—์„œ ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.
boolean contains(Object o); ์ปฌ๋ ‰์…˜์— ์š”์†Œ๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
boolean containsAll(Collection<?> c); ์ปฌ๋ ‰์…˜์— ์š”์†Œ๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
boolean equals(Object o); ์ปฌ๋ ‰์…˜์ด ๋™์ผํ•œ์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
int hashCode(); ํ•ด์‹œ ์ฝ”๋“œ๋ฅผ ๋ฐ˜ํ™˜
boolean isEmpty(); ์ปฌ๋ ‰์…˜์ด ๋น„์–ด ์žˆ๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
Iterator<E> iterator(); ๋ฐ˜๋ณต์ž ๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
boolean remove(Object o); ์ปฌ๋ ‰์…˜์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.
boolean removeAll(Collection<?> c); ์ปฌ๋ ‰์…˜์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.
boolean retainAll(Collection<?> c); c์— ์—†๋Š” ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.
int size(); ์ปฌ๋ ‰์…˜์˜ ํฌ๊ธฐ๋ฅผ ๋ฐ˜ํ™˜
Object[] toArray(); ์ปฌ๋ ‰์…˜์„ ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜
<T> T[] toArray(T[] a); ์ปฌ๋ ‰์…˜์„ ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜

"์ €๋Š” ์ด๋ฏธ ์—ฌ๊ธฐ ์žˆ๋Š” ๋ชจ๋“  ๊ฒƒ์ด ํ™•์‹คํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฐฉ๋ฒ•์˜ ์ ˆ๋ฐ˜์€ ์‚ฌ์šฉํ–ˆ๊ณ  ๋‚˜๋จธ์ง€ ์ ˆ๋ฐ˜์€ ์ ‘ํ–ˆ์Šต๋‹ˆ๋‹ค."

"์ข‹์•„, ๊ทธ๋Ÿผ ๊ณ„์†ํ•˜์ž."

 List<E>: ์ธํ„ฐํŽ˜์ด์Šค ์˜ ๋ฉ”์†Œ๋“œ :

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
void add(int index, E element); ์ปฌ๋ ‰์…˜ ์ค‘๊ฐ„์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
boolean addAll(int index, Collection<? extends E> c); ์ปฌ๋ ‰์…˜์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
E get(int index); ์ธ๋ฑ์Šค๋กœ ์š”์†Œ๋ฅผ ๋ฐ˜ํ™˜
int indexOf(Object o); ์š”์†Œ์˜ ์ธ๋ฑ์Šค(์ˆซ์ž)๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int lastIndexOf(Object o); ๋งˆ์ง€๋ง‰ ์š”์†Œ์˜ ์ธ๋ฑ์Šค๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
ListIterator<E> listIterator(); ๋ชฉ๋ก์— ๋Œ€ํ•œ ๋ฐ˜๋ณต์ž๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
ListIterator<E> listIterator(int index); ๋ชฉ๋ก์— ๋Œ€ํ•œ ๋ฐ˜๋ณต์ž๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
E remove(int index); ์ธ๋ฑ์Šค๋กœ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.
E set(int index, E element); ์ธ๋ฑ์Šค๋กœ ์ƒˆ๋กœ์šด ๊ฐ’์„ ์„ค์ •
List<E> subList(int fromIndex, int toIndex); ํ•˜์œ„ ์ปฌ๋ ‰์…˜์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

"์—ฌ๊ธฐ์—์„œ๋„ ๊ทผ๋ณธ์ ์œผ๋กœ ์ƒˆ๋กœ์šด ๊ฒƒ์€ ์—†์Šต๋‹ˆ๋‹ค. ์ปฌ๋ ‰์…˜์— ๋Œ€ํ•œ ๊ฑฐ์˜ ๋ชจ๋“  ๊ฒƒ์„ ์ด๋ฏธ ์•Œ๊ณ  ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ๊ธฐ๋ปํ•  ์ˆ˜๋ฐ–์— ์—†์Šต๋‹ˆ๋‹ค."

"์Œ, ๋‹น์‹ ์„ ๋†€๋ผ๊ฒŒ ํ•  ๋ฌด์–ธ๊ฐ€๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ณ„์† ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค."

Set<E>: ์ธํ„ฐํŽ˜์ด์Šค ์˜ ๋ฉ”์†Œ๋“œ :

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
๋ฐฉ๋ฒ• ์—†์Œ

"Set ์ธํ„ฐํŽ˜์ด์Šค์—๋Š” ์ƒˆ๋กœ์šด ๋ฉ”์„œ๋“œ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค. ์ƒ์†๋ฐ›์€ ๋ฉ”์„œ๋“œ๋งŒ ์žˆ์Šต๋‹ˆ๋‹ค."

"๋„ค, Interable ์ธํ„ฐํŽ˜์ด์Šค์—๋„ ์•„๋ฌด๊ฒƒ๋„ ์—†๋Š” ๊ฑธ ๋ดค์Šต๋‹ˆ๋‹ค.

"๋ฐ˜๋ฉด์— ๋ฐฉ๋ฒ•์ด ์ ๋‹ค๋Š” ๊ฒƒ์€ ๊ธฐ์–ตํ•  ๊ฒƒ์ด ์ ๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค!"

"๋‹น์‹ ์˜ ์‚ถ์„ ๊ธ์ •ํ•˜๋Š” ๋‚™๊ด€์ฃผ์˜๊ฐ€ ๋‚˜๋ฅผ ํ–‰๋ณตํ•˜๊ฒŒ ํ•ฉ๋‹ˆ๋‹ค."

"Set ์ธํ„ฐํŽ˜์ด์Šค๋Š” SortedSet ๋ฐ NavigableSet ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ๋Š” ๋‘ ์ธํ„ฐํŽ˜์ด์Šค์— ์˜ํ•ด ์ƒ์†๋ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ž์„ธํžˆ ์‚ดํŽด๋ณด๊ฑฐ๋‚˜ ๋๋‚ด์ง€ ์•Š๊ฒ ์Šต๋‹ˆ๋‹ค."

"๋Œ€์‹  Java์—์„œ ์ปฌ๋ ‰์…˜์„ ์„ค๋ช…ํ•˜๋Š” ํด๋ž˜์Šค ๋ฐ ์ธํ„ฐํŽ˜์ด์Šค์— ๋Œ€ํ•œ ์ผ๋ฐ˜์ ์ธ ๊ทธ๋ฆผ์„ ์ œ๊ณตํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค."

"๊ฐ€์ ธ์™€."

"๊ทธ๋Ÿผ ๊ฝ‰ ์žก์•„."

์ปฌ๋ ‰์…˜ ์ธํ„ฐํŽ˜์ด์Šค - 2

"์™€, ์—„์ฒญ๋‚˜๋‹ค!"

"์Œ, ๊ทธ๋ ‡๊ฒŒ ํฌ์ง€๋Š” ์•Š์Šต๋‹ˆ๋‹ค. ๋˜ํ•œ ์ถ”์ƒ ํด๋ž˜์Šค๋Š” ์ „์ ์œผ๋กœ ์„ ํƒ ์‚ฌํ•ญ์ด๋ผ๋Š” ์ ์„ ๊ธฐ์–ตํ•˜์„ธ์š”. ํ•˜์ง€๋งŒ ์–ด๋–ค ํด๋ž˜์Šค๊ฐ€ ์–ด๋–ค ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•˜๋Š”์ง€ ๊ธฐ์–ตํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค. ๊ฝค ์ž์ฃผ ์œ ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค."

"์•„, ์ผ๋ถ€ ์ปฌ๋ ‰์…˜์€ ์“ธ๋ชจ ์—†๋Š” ๊ฒƒ์œผ๋กœ ๊ฐ„์ฃผ๋œ๋‹ค๋Š” ์ ์— ์œ ์˜ํ•˜๊ณ  ์‹ถ์Šต๋‹ˆ๋‹ค."

"๊ทธ๊ฒŒ ๋ญ์•ผ?"

"์ €๋Š” Vector, Stack, Dictionary ๋ฐ Hashtable ํด๋ž˜์Šค์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋“ค์€ ์ผ๋ฐ˜ ์ปฌ๋ ‰์…˜์˜ ๋™๊ธฐํ™”๋œ(์Šค๋ ˆ๋“œ ์•ˆ์ „) ๋ฒ„์ „์ž…๋‹ˆ๋‹ค."

"๊ทธ๋Ÿฌ๋‚˜ Java ๋Š” ๋‹ค๋ฅธ ์Šค๋ ˆ๋“œ์—์„œ ์•ก์„ธ์Šคํ•  ์ˆ˜ ์žˆ์„ ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ํ›จ์”ฌ ๋” ํšจ์œจ์ ์ธ ๊ตฌํ˜„์„ ๊ฐ€์ง„ ๋งŽ์€ ์ปฌ๋ ‰์…˜์ด ์žˆ๋Š”  ํŠน์ˆ˜ ๋™์‹œ์„ฑ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์ถ”๊ฐ€ํ–ˆ์Šต๋‹ˆ๋‹ค . ConcurrentHashMap ์€ Hashtable ๋ณด๋‹ค ํ›จ์”ฌ ๋” ํšจ์œจ์ ์ž…๋‹ˆ๋‹ค ."

"Vector, Stack, Dictionary ๋ฐ Hashtable ์ปฌ๋ ‰์…˜์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์ง€๋งŒ ๊ถŒ์žฅํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค."

"์•Œ์•˜์–ด, ๋ช…์‹ฌํ• ๊ฒŒ."

"๊ณ ๋งˆ์›Œ, ์—˜๋ฆฌ!"