-
[Collection] ArrayList ๊ด๋ จ ๊ผฌ๋ฆฌ ์ง๋ฌธ ๋ต๋ณ ๊ณต๋ถ ๊ธฐ๋ก๊ฐ๋ฐ/Java 2022. 4. 18. 23:55
๐ก์ฌ๋ฌ๊ฐ์ง ๋ฐ์ดํฐ๋ฅผ ๋ด์ ๋, ๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉด ์ข์์ ์ ๋ฌด์์ผ๊น?
- ๋ฐฐ์ด์ ๊ทธ ํฌ๊ธฐ๊ฐ ์ ํด์ ธ ์์ ๋ ์ ์ฉํ๋ค
- ์ฑ๋ฅ์์ด๋ ๋ฉ๋ชจ๋ฆฌ ํจ์จ๋ฉด์์ ๊ฐ์ฅ ์ข๋ค.
๐ก๊ทธ๋ผ ํฌ๊ธฐ๊ฐ ์ผ๋ง๋ ๋๋์ง ๋ชจ๋ฅด๋ ๊ฒฝ์ฐ์๋?
- int์ ์ต๋๊ฐ์ ํด๋นํ๋ ํฌ๊ธฐ๋ฅผ ๊ฐ๋ ๋ฐฐ์ด์ ๋ง๋ ๋ค.
-> ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ์ฌํ๋ค.
- ํ์ํ ๊ฐ์๋งํผ ๋ ํฐ ๋ฐฐ์ด์ ํ๋ ๋ ๋ง๋ค์ด์ ๊ฑฐ๊ธฐ๋ค ๋ณต์ฌํด๋ฒ๋ฆฐ๋ค.
->๊ตณ์ด ์ด๋ ๊ฒ ํ ํ์๊ฐ ์๋ค. ์ด๋ฏธ ๋ง๋ค์ด์ ธ ์๋ ํด๋์ค๋ค์ ์ฌ์ฉํ ์ ์๋ค.
๐ก๋ค์ ๊ทธ๋ฆผ์ ๊ผญ ์ธ์ฐ์.
๋ฆฌ์คํธ, ์ , ํ๋ Collection์ด๋ผ๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์๋ค. Collection ์ธํฐํ์ด์ค๋ java.util ํจํค์ง์ ์ ์ธ๋์ด ์๋ค. ๋ชจ๋ ์ฌ๋ฌ ๊ฐ์ฒด๋ฅผ ํ๋์ ๊ฐ์ฒด์ ๋ด์ ์ฒ๋ฆฌํ ๋ ๊ณตํต์ ์ผ๋ก ์ฌ์ฉ๋๋ ์ฌ๋ฌ ๋ฉ์๋๋ค์ ์ ์ธํด ๋์๋ค.
์ฌ๊ธฐ์ ๋งต ๋ง์ด Collection๊ณผ ๊ด๋ จ ์๋ ๋ณ๋์ ์ธํฐํ์ด์ค๋ก ์ ์ธ๋์ด ์๋ค.
Collection ์ธํฐํ์ด์ค๋ Iterable<E>๋ฅผ ํ์ฅํ๋๋ฐ, ์ด Iterable<E> ํด๋์ค์ ์ ์ธ๋์ด ์๋ ๋ฉ์๋๋ iterator() ๋ฑ ํ๋๋ค. ์ด ๋ฉ์๋๋ Iterator๋ผ๋ ์ธํฐํ์ด์ค๋ฅผ ๋ฆฌํดํ๋ค. Iterator ์ธํฐํ์ด์ค๋ hasNext(), next(), remove()๋ฉ์๋๊ฐ ์๋ค.
๊ฒฐ๋ก ์ ์ผ๋ก, Collection ์ธํฐํ์ด์ค๊ฐ Iterable ์ธํฐํ์ด์ค๋ฅผ ํ์ฅํ๋ค๋ ์๋ฏธ๋ Iterator ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ๊ฐ์ ธ์ฌ ์ ์๋ค๋ ์๋ฏธ๋ค.
List์ ๊ฐ์ฅ ํฐ ํน์ง์ ๋ฐฐ์ด์ฒ๋ผ "์์"๊ฐ ์๋ค๋ ๊ฒ์ด๋ค. List ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ค ์ค, java.util ํจํค์ง์์๋ ArrayList, Vector, Stack, LinkedList๋ฅผ ๋ง์ด ์ฌ์ฉํ๋ค.
๐กArrayList์ Vector์ ์ฐจ์ด์ ์ ๋ฌด์์ธ๊ฐ?
์ผ๋จ Vector๋ JDK 1.0๋ถํฐ ์์๊ณ , ArrayList๋ JDK 1.2์์ ์ถ๊ฐ๋์๋ค. ๋ ํด๋์ค๋ ์ฌ์ฉ๋ฒ์ด ๊ฑฐ์ ๋์ผํ๊ณ , ๊ธฐ๋ฅ๋ ๊ฑฐ์ ๋น์ทํ๋ค. ํ์ง๋ง ArrayList๋ Thread safeํ์ง ์๊ณ , Vector๋ Thread safeํ๋ค. ์ฆ, ArrayList์ ๊ฐ์ฒด๋ ์ฌ๋ฌ ๋ช ์ด ๋ฌ๋ ค๋ค์ด ๊ฐ์ ๋ณ๊ฒฝํ๋ ค๊ณ ํ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๊ณ , Vector๋ ๊ทธ๋ ์ง ์๋ค.
cf) ArrayList๋ฅผ Thread safeํ๊ฒ ํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ฉด ๋๋ค.
List list = Collections.synchronizedList(new ArrayList(...));
๐กArrayList์ ์ด๊ธฐ ํฌ๊ธฐ๋ ์ผ๋ง์ธ๊ฐ?
์๋ฐ 7๊น์ง๋ ๊ฐ์ฒด๋ฅผ ์์ฑ์์ ์์ฑ์๋ฅผ ํธ์ถํ๋ฉด์ ๋ฐ๋ก 10๊ฐ์ ๊ณต๊ฐ์ด ์๊ธด๋ค. ํ์ง๋ง ์๋ฐ 8๋ถํฐ๋ ์์ฑ ์์๋ ๊ณต๊ฐ์ ํ ๋นํ์ง ์๊ณ , addํ๋ ์์ ์ 10๊ฐ๊ฐ ์์ฑ๋๋ค.
๐กArrayList์ LinkedList์ ์ฐจ์ด?
LinkedListํด๋์ค๋ List๋ ๋๊ณ , Queue๋ ๋๋ค. ๋ํ List์ ๋ฌ๋ฆฌ AbstractList๋ฅผ ํ์ฅํ AbstractSequentialList๊ฐ ๋ถ๋ชจ์ด๋ค. ์๋ฐ 6์์๋ถํฐ๋ Deque์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค. ์์ฑ์๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ ์ฒ์๋ถํฐ ํฌ๊ธฐ๋ฅผ ์ง์ ํ์ง ์๋๋ค. ๊ฐ ๋ฐ์ดํฐ๋ค์ด ์ ๋ค๋ก ์ฐ๊ฒฐ๋๋ ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์, ๋ฏธ๋ฆฌ ๊ณต๊ฐ์ ๋ง๋ค์ด ๋์ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค.
ArrayList
java.lang.Object ใด java.util.AbstractCollection<E> ใด java.util.AbstractList<E> ใด java.util.ArrayList<E>
LinkedList
java.lang.Object ใด java.util.AbstractCollection<E> ใด java.util.AbstractList<E> ใด java.util.AbstractSequentialList<E> ใด java.java.util.LinkedList<E>
๐กArrayList<String> list2 = new ArrayList<String>(list); ์ ArrayList<String>list2 = list; ์ ์ฐจ์ด๋?
1๋ฒ์ ArrayList์๋ Collection ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ด๋ ํ ํด๋์ค๋ ํฌํจ์ํฌ ์ ์๋ ์์ฑ์๊ฐ ์๊ธฐ ๋๋ฌธ์, list์ ์๋ ๋ด์ฉ์ list2์ ๋ณต์ฌํด์ผ ํ ์ผ์ด ์๊ธฐ๋ ๊ฒฝ์ฐ ์ฌ์ฉํ ์ ์๋ค. ๊ทธ๋ฐ๋ฐ, 2๋ฒ์ ๊ฒฝ์ฐ์๋ list2๊ฐ list์ ๊ฐ๋ง ์ฌ์ฉํ๊ฒ ๋ค๋ ๊ฒ์ด ์๋๋ผ, list๋ผ๋ ๊ฐ์ฒด๊ฐ ์์ฑ๋์ด ์ฐธ์กฐ๋๊ณ ์๋ ์ฃผ์๊น์ง๋ ์ฌ์ฉํ๊ฒ ๋ค๋ ๋ง์ด๋ค. ์ฆ, ArrayListlist2 = list; ์ด๋ ๊ฒ ์ ์ธํ๊ณ list์ A๋ผ๋ ๊ฐ์ add์ํค๋ฉด list2๋ฅผ ํ์ธํด๋ดค์ ๋, ๋์ผํ๊ฒ A๊ฐ ์ถ๊ฐ๋์ด ์๋ ๊ฒ์ ๋ณผ ์ ์๋ฐ.
๐กString[] strList = list.toArray(new String[0]); "new String[0]" ์ด๋ ๊ฒ ์ด ์ด์ ๋?
ArrayList ๊ฐ์ฒด์ ๋ฐ์ดํฐ ํฌ๊ธฐ๊ฐ ๋งค๊ฐ ๋ณ์๋ก ๋์ด๊ฐ ๋ฐฐ์ด ๊ฐ์ฒด์ ํฌ๊ธฐ๋ณด๋ค ํด ๊ฒฝ์ฐ์๋ ๋งค๊ฐ ๋ณ์๋ก ๋ฐฐ์ด์ ๋ชจ๋ ๊ฐ์ด null๋ก ์ฑ์์ง๋ค. ์์ ๊ฒฝ์ฐ์๋ ๋ชจ๋ null๋ก ์ฑ์์ง๋ค. ๊ทธ๋ฌ๋ฏ๋ก, toArray() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋์๋ ๊ฐ์ฅ ์ฒ์์ ์ฌ์ฉํ ๊ฒ๊ณผ ๊ฐ์ด ํฌ๊ธฐ๊ฐ 0์ธ ๋ฐฐ์ด์ ๋๊ฒจ์ฃผ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข๋ค.
๐กStack์ ์ ์์ข์ ๊ตฌํ์ผ๊น?
์ผ๋ฐ์ ์ผ๋ก ์น์ ๊ฐ๋ฐํ ๋๋ ๋ณ๋ก ๋ง์ด ์ฌ์ฉํ์ง๋ ์์ง๋ง, ๋ง์ง๋ง์ ๋ค์ด์จ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ์ฒ์์ ๊บผ๋ด๋ LIFO ๊ธฐ๋ฅ์ ๊ตฌํํ๋ ค๊ณ ํ ๋ ํ์ํ ํด๋์ค๋ค. ํ์ง๋ง LIFO ๊ธฐ๋ฅ์ ์ํด์ ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ถ์ฅํ์ง ์๋๋ค. ์๋ํ๋ฉด ์ด ํด๋์ค๋ณด๋ค ๋ ๋น ๋ฅธ ArrayDeque๋ผ๋ ํด๋์ค๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ด๋ค. ํ์ง๋ง, ArrayDeque๋ ์ฐ๋ ๋์ ์์ ํ์ง ๋ชปํ๋ค. ์ฝ๊ฐ ์ฑ๋ฅ์ ๋จ์ด์ง์ง๋ง, ์ฐ๋ ๋์ ์์ ํ LIFO ๊ธฐ๋ฅ์ ์ํ๋ค๋ฉด ์ด Stack ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
Stack ํด๋์ค์ ์์๊ด๊ณ
java.lang.Object ใด java.util.AbstractCollection<E> ใด java.util.AbstractList<E> ใด java.util.Vector<E> ใด java.util.Stack<E>
Stack ํด๋์ค์ ๋ถ๋ชจ ํด๋์ค๋ Vector์ธ ๊ฒ์ ๋ณผ ์ ์๋ค. ์ฆ, Vector ํด๋์ค์์ ์ ๊ณตํ๋ ๋ชจ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ , Stack ํด๋์ค์์ ๊ตฌํํ ์ธํฐํ์ด์ค๋ Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess๋ก ArrayList ํด๋์ค์์ ๊ตฌํํ ์ธํฐํ์ด์ค์ ๋ชจ๋ ๋์ผํ๋ค.
Stack ํด๋์ค๋ ์๋ฐ์์ ์์์ ์๋ชป ๋ฐ์ ์์ด๋ค. ์ด ํด๋์ค๊ฐ JDK 1.0๋ถํฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ์๋์ ์ทจ์ง์ธ LIFO๋ฅผ ์๊ฐํ๋ค๋ฉด Vector์ ์ํด์๋ ์ ๋๋ค. ํ์ง๋ง, ์๋ฐ์ ํ์ ํธํ์ฑ์ ์ํด ์ด ์์๊ด๊ณ๋ฅผ ๊ณ์ ์ ์งํ๊ณ ์๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.
๐กArrayList์ ๋์์๋ฆฌ?
ArrayList๋ elementData๋ผ๋ ๋ด๋ถ์ Object ๋ฐฐ์ด ๊ฐ์ฒด์ ๊ฐ์ ์ ์ฅํ๋ฉฐ, ํด๋น ๋ฐฐ์ด ๊ฐ์ฒด๋ ํญ์ ์ฌ์ ๋ถ์ ์ธ๋ฑ์ค๋ฅผ ๋๊ณ ์๋ค. (๋ถ์กฑํ๋ฉด grow๋ฉ์๋๊ฐ ์คํ๋๋ค.) ๊ฒฐ๊ตญ์ ๋ด๋ถ์ ๋ฐฐ์ด๋ก ๋์ํ๋๊ฑด๋ฐ, ์ฌ์ด์ ๊ฐ์ ๋ผ์ ๋ฃ์ ์ ์๋ ๊ฒ์ System.arraycopy๋ฉ์๋ ๋๋ถ์ด๋ค. ํด๋น ๋ฉ์๋๋ ๋ฐฐ์ด์ ๋ฐ์์ ํน์ ์์น์์ ์๋ฅด๊ณ , ๋ค๋ฅธ ๋ฐฐ์ด์ ํน์ ์์น์ ๋ณต์ฌํ๋ ๋ฉ์๋์ด๋ค. ์ด ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์๊ธฐ ์์ ์๊ฒ ๋ณต์ฌํ๋ฉด์ ํด๋น ์ธ๋ฑ์ค์ ํ ์๋ฆฌ๋ฅผ ๋์ฐ๊ณ ํด๋น ์๋ฆฌ์ ๊ฐ์ ์ ์ฅํ๋ค.
System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++;
remove๋ ๋ํ ๋์ผํ ๋ฉ์๋๋ฅผ ์ด์ฉํ๋๋ฐ, ๋ค์ ๋ด์ฉ์ ํ์นธ์ฉ ์์ผ๋ก ๋น๊ฒจ์ index ์๋ฆฌ๋ฅผ ๋ฎ์ด๋ฒ๋ฆฌ๊ณ , ๋ง์ง๋ง์ ์ฐ๋ ๊ธฐ ๊ฐ์ null๋ก ์ฒ๋ฆฌํ๋ค.
if(numMoved > 0 ) System.arraycopy(elementData, index + 1, elementData, index, numMoved); elementData[--size] = null;
์ถ์ฒ https://matdulgi.tistory.com/69
'๊ฐ๋ฐ > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ