"์๋ , ์๋ฏธ๊ณ !"
"์๋ , ์๋ฆฌ!"
"์ค๋ ์ฐ๋ฆฌ๋ ์ปฌ๋ ์ ์ ๊ตฌ์กฐ์ ๋ํด ๋จ๋ฒ์ ์์ ํ ์์๋ณผ ๊ฒ์ ๋๋ค."
"๋๋ ์ด๊ฒ์ ์ค๋ซ๋์ ๊ธฐ๋ค๋ ธ๋ค."
"์ปฌ๋ ์ ์ด ๋ฌด์์ธ์ง ์ด๋ฏธ ์๊ณ ์๊ณ ์ด๋ป๊ฒ ์์ ํ๋์ง ์๊ณ ์์ต๋๋ค. ์ง์์ ์๊ฒฉํ ์์คํ ์ผ๋ก ์ ๋ฆฌํ ๋์ ๋๋ค. ๊ทธ๋ฌ๋ฉด ๋ง์ '์'์ '์ด๋ป๊ฒ'์ ๋ํ ์ง๋ฌธ์ด ์ฌ๋ผ์ง๊ณ ๋๋ถ๋ถ์ ๊ฒ์ด ๋ถ๋ช ํด์ง ๊ฒ์ ๋๋ค."
" ์ปฌ๋ ์ ์ธํฐํ์ด์ค . ์ปฌ๋ ์ ์ธํฐํ์ด์ค ์ ์์ ๊ตฌ์กฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค."
๋ ๊ฐ์ง๋ฅผ ์ฃผ๋ชฉํ์ญ์์ค.
์ฒซ์งธ, ์ฌ๊ธฐ์ ํ์๋๋ ๋ชจ๋ ๊ฒ์ ์ธํฐํ์ด์ค์ ๋๋ค.
๋์งธ, ํ์ดํ๋ ยซ์์ยป์ ์๋ฏธํฉ๋๋ค.
"์ฆ, 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์์ ์ปฌ๋ ์ ์ ์ค๋ช ํ๋ ํด๋์ค ๋ฐ ์ธํฐํ์ด์ค์ ๋ํ ์ผ๋ฐ์ ์ธ ๊ทธ๋ฆผ์ ์ ๊ณตํ๊ฒ ์ต๋๋ค."
"๊ฐ์ ธ์."
"๊ทธ๋ผ ๊ฝ ์ก์."
"์, ์์ฒญ๋๋ค!"
"์, ๊ทธ๋ ๊ฒ ํฌ์ง๋ ์์ต๋๋ค. ๋ํ ์ถ์ ํด๋์ค๋ ์ ์ ์ผ๋ก ์ ํ ์ฌํญ์ด๋ผ๋ ์ ์ ๊ธฐ์ตํ์ธ์. ํ์ง๋ง ์ด๋ค ํด๋์ค๊ฐ ์ด๋ค ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋์ง ๊ธฐ์ตํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ๊ฝค ์์ฃผ ์ ์ฉํ ์ ์์ต๋๋ค."
"์, ์ผ๋ถ ์ปฌ๋ ์ ์ ์ธ๋ชจ ์๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋๋ค๋ ์ ์ ์ ์ํ๊ณ ์ถ์ต๋๋ค."
"๊ทธ๊ฒ ๋ญ์ผ?"
"์ ๋ Vector, Stack, Dictionary ๋ฐ Hashtable ํด๋์ค์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์์ต๋๋ค. ์ด๋ค์ ์ผ๋ฐ ์ปฌ๋ ์ ์ ๋๊ธฐํ๋(์ค๋ ๋ ์์ ) ๋ฒ์ ์ ๋๋ค."
"๊ทธ๋ฌ๋ Java ๋ ๋ค๋ฅธ ์ค๋ ๋์์ ์ก์ธ์คํ ์ ์์ ๋ฟ๋ง ์๋๋ผ ํจ์ฌ ๋ ํจ์จ์ ์ธ ๊ตฌํ์ ๊ฐ์ง ๋ง์ ์ปฌ๋ ์ ์ด ์๋ ํน์ ๋์์ฑ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ถ๊ฐํ์ต๋๋ค . ConcurrentHashMap ์ Hashtable ๋ณด๋ค ํจ์ฌ ๋ ํจ์จ์ ์ ๋๋ค ."
"Vector, Stack, Dictionary ๋ฐ Hashtable ์ปฌ๋ ์ ์ ์ฌ์ฉํ ์ ์์ง๋ง ๊ถ์ฅํ์ง ์์ต๋๋ค."
"์์์ด, ๋ช ์ฌํ ๊ฒ."
"๊ณ ๋ง์, ์๋ฆฌ!"
GO TO FULL VERSION