์ด ๊ธฐ์ฌ๋ " Java ์ปฌ๋ ์
์ ๊ดํ ์์ 10๊ฐ์ง ์ง๋ฌธ " ๊ธฐ์ฌ๋ฅผ ๋ฒ์ญํ ๊ฒ์
๋๋ค . ๋ค์์ Stackowerflow์์ ์ง๋ฌธํ๊ณ ํ ๋ก ํ Java ์ปฌ๋ ์
์ ๊ดํ ๊ฐ์ฅ ์ธ๊ธฐ ์๋ ์ง๋ฌธ์
๋๋ค. ์ด๋ฌํ ์ง๋ฌธ์ ๋ณด๊ธฐ ์ ์ ํด๋์ค ๊ณ์ธต ๋ค์ด์ด๊ทธ๋จ์ ์ดํด๋ณด๋ ๊ฒ์ด ์ข์ต๋๋ค.
1. ArrayList ๋์ LinkedList๋ฅผ ์ธ์ ์ฌ์ฉํด์ผ ํฉ๋๊น?
ArrayList ๋ ์ค์ ๋ก ๋ฐฐ์ด์ด๋ฏ๋ก ํด๋น ์์๋ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ง์ ์ก์ธ์คํ ์ ์์ต๋๋ค. ๋ฐฐ์ด์ด ์ค๋ฒํ๋ก๋๋ฉด ๋ ๋ง์ ๊ณต๊ฐ์ด ์๋ ์ ๋ฐฐ์ด์ด ํ์ํฉ๋๋ค. ๋ชจ๋ ์์๋ฅผ โโ๋ฐฐ์นํ๊ณ ์ด๋ํ๋ ๋ฐ๋ O(n) ์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค. ๋ํ ๋ฐฐ์ด์ ๊ธฐ์กด ์์๋ฅผ ์ด๋ํ๋ ค๋ฉด ์์๋ฅผ ์ถ๊ฐํ๊ณ ์ ๊ฑฐํด์ผ ํฉ๋๋ค. ์ด๊ฒ์ด ์๋ง๋ ArrayList๋ฅผ ์ฌ์ฉํ ๋ ๊ฐ์ฅ ํฐ ๋ถํธํจ์ผ ๊ฒ์
๋๋ค. LinkedList๋ ์์ ๋งํฌ์ ์ด์ค ๋ชฉ๋ก์
๋๋ค. ๋ฐ๋ผ์ ์ค์์ ์๋ ์์์ ์ ๊ทผํ๋ ค๋ฉด ์ํธ์ ๋งจ ์ฒ์๋ถํฐ ๋๊น์ง ๊ฒ์ํด์ผ ํฉ๋๋ค. ๋ฐ๋ฉด์ LinkedList์์ ์์๋ฅผ ์ถ๊ฐํ๊ณ ์ ๊ฑฐํ๋ ์์
์ ๋ชฉ๋ก ์์ฒด๋ง ๋ณ๊ฒฝํ๋ฏ๋ก ๋ ๋น ๋ฆ
๋๋ค. ์ต์
์ ์๊ฐ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ฐฉ๋ฒ |
๋ฐฐ์ด ๋ชฉ๋ก |
๋งํฌ๋๋ฆฌ์คํธ |
get(์ธ๋ฑ์ค) |
์ค(1) |
์) |
์ถ๊ฐ(E) |
์) |
์ค(1) |
์ถ๊ฐ(E, ์ธ๋ฑ์ค) |
์) |
์) |
์ ๊ฑฐ(์์ธ) |
์) |
์) |
๋ฐ๋ณต์.์ ๊ฑฐ() |
์) |
์ค(1) |
๋ฐ๋ณต์.์ถ๊ฐ(E) |
์) |
์ค(1) |
์คํ ์๊ฐ์๋ ๋ถ๊ตฌํ๊ณ ํฐ ๋ชฉ๋ก์ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๊ฐ๋ณ์ ์ผ๋ก ๊ณ ๋ คํด์ผ ํฉ๋๋ค. LinkedList์์๋ ๊ฐ ๋
ธ๋์ ์ด์ ๋
ธ๋์ ๋ค์ ๋
ธ๋๋ฅผ ์ฐ๊ฒฐํ๊ธฐ ์ํ ์ถ๊ฐ ํฌ์ธํฐ๊ฐ ๋ ๊ฐ ์ด์ ์์ด์ผ ํ์ง๋ง ArrayList์์๋ ์์ ๋ฐฐ์ด๋ง ํ์ํฉ๋๋ค.
ArrayList, LinkedList ๋ฐ Vector ๋ชฉ๋ก ์ ๋ํ ์ถ๊ฐ ๋น๊ต .
2. ์ปฌ๋ ์
๋ฐ๋ณต ์ค์ ์์๋ฅผ ์ ๊ฑฐํ๋ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ ๋ฐ๋ณต ์ค์ ์ปฌ๋ ์
์ ์์ (์์ ์ ๊ฑฐ)ํ๋ ์ ์ผํ ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ์
Iterator.remove() ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค . ์: ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์ค๋ฅ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ์ ์ฝ๋๋ฅผ ์คํํ๋ ๋์
ConcurrentModificationException์ด ๋ฐ์ํฉ๋๋ค . ์ด๋ ์ ์ฒด ๋ชฉ๋ก์ ์ด๋ํ๋๋ก ๋ฐ๋ณต์๊ฐ ์์ฑ๋์์ง๋ง ๋์์ Iterator.remove()๋ฅผ ํธ์ถํ์ฌ ์ํธ๊ฐ ๋ณ๊ฒฝ๋๊ธฐ ๋๋ฌธ์ ๋ฐ์ํฉ๋๋ค. ์ด ์์ธ์ ๋ํ ๋ฌธ์์ ๊ธฐ๋ก๋ ๋๋ก,
Iterator
itr = list.iterator(); while(itr.hasNext()) { // do something itr.remove(); }
for(Integer i: list) { list.remove(i); }
"์ผ๋ฐ์ ์ผ๋ก ํ ์ค๋ ๋๊ฐ ์ปฌ๋ ์
์ ์์ ํ๋ ๋์ ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์ปฌ๋ ์
์ ๋ฐ๋ณตํ๋ ๊ฒ์ ํ์ฉ๋์ง ์์ต๋๋ค."
์ผ๋ฐ์ ์ผ๋ก ํ ์ค๋ ๋๊ฐ ์ปฌ๋ ์
์ ํ์ํ๋ ๋์ ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์ปฌ๋ ์
์ ์์ ํ๋ ๊ฒ์ ํ์ฉ๋์ง ์์ต๋๋ค.
3. List๋ฅผ int[] ๋ฐฐ์ด๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น? ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ์
Apache Commons Lang ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ์๋
ArrayUtils๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค . JDK์๋ ์ด ํํ์์ ๋ํ ์ง๋ฆ๊ธธ์ด ์์ต๋๋ค. ์ด ํํ์์ List๋ฅผ Integer[]( ๊ธฐ๋ณธ ์ ํ์ด
์๋ ) ๋ก ๋ณํํ๊ธฐ ๋๋ฌธ์ List.toArray()๋ฅผ ์ฌ์ฉํ ์ ์๋ค๋ ์ ์ ๊ธฐ์ตํ์ญ์์ค . ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ์ ๋ค์ ์ต์
์
๋๋ค.
4. int[] ๋ฐฐ์ด์ ๋ชฉ๋ก์ผ๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น? ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ์ ์์ ๊ฐ์ด
Apache Commons Lang ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์
ArrayUtils๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. ๋ํ JDK์๋ ์ด ํํ์์ ๋ํ ์ง๋ฆ๊ธธ์ด ์์ต๋๋ค.
5. ์ปฌ๋ ์
์ ํํฐ๋งํ๋ ๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น?
Guava ๋๋
Apache Commons Lang ๊ณผ ๊ฐ์ ํ์ฌ ํจํค์ง๋ฅผ ์ฌ์ฉํ์ฌ ๊ธฐ๋ฅ์ ํฅ์ํ ์ ์์ต๋๋ค. ์ด ๋ ํจํค์ง์๋ ๋ชจ๋ filter() ๋ฉ์๋( Guava์
Collections2 ํด๋์ค ์ Apache์
CollectionUtils )๊ฐ ์์ต๋๋ค. filter() ๋ฉ์๋๋ ์ฃผ์ด์ง Predicate์ ์ผ์นํ๋ ์์๋ฅผ ๋ฐํํฉ๋๋ค. JDK์์๋ ๋ชจ๋ ๊ฒ์ด ๋ ๋ณต์กํฉ๋๋ค. ์ข์ ์์์ Java 8์ ์กฐ๊ฑด์๊ฐ ์ถ๊ฐ๋๋ค๋ ๊ฒ์
๋๋ค
. ํ์ง๋ง ์ง๊ธ์ ์ ์ฒด ์ปฌ๋ ์
์ ๋ฐ๋ณตํ๋ ค๋ฉด Iterator๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ๋ฌผ๋ก ์๋ก์ด Predicate ์ธํฐํ์ด์ค์ ์ต์ํด์ง๋ฉด Guava ๋ฐ Apache๊ฐ ๋ฐ๋ฅด๋ ๊ฒฝ๋ก๋ฅผ ๋ชจ๋ฐฉํ ์ ์์ต๋๋ค. ์ด์ ๋ค์ ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ์ปฌ๋ ์
์ ํํฐ๋งํ ์ ์์ต๋๋ค.
6. List๋ฅผ Set์ผ๋ก ์ฝ๊ฒ ๋ณํํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น? ํ๋ฑ์ ์ ์ํ๋ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ์ด๋ฅผ ์ํํ๋ ๋ฐฉ๋ฒ์๋ ๋ ๊ฐ์ง๊ฐ ์์ต๋๋ค. ์ฒซ ๋ฒ์งธ ์ฝ๋ ์กฐ๊ฐ์ ๋ชฉ๋ก์ HashSet์ ๋ฃ์ต๋๋ค. ์ด ๊ฒฝ์ฐ ์ค๋ณต์ ์ฃผ๋ก hashCode()์ ์ํด ๊ฒฐ์ ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด๊ฒ์ ์๋ํฉ๋๋ค. ๊ทธ๋ฌ๋ ๋น๊ต ๊ฒฝ๋ก๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ ๊ฒฝ์ฐ์๋ ์ฝ๋์ ๋ ๋ฒ์งธ ๋ถ๋ถ์ ์ฌ์ฉํ์ฌ ์์ ๋ง์ ๋น๊ต๊ธฐ๋ฅผ ์ ์ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
7. ArrayList์์ ์ค๋ณต ์์๋ฅผ ์ ๊ฑฐํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํฉ๋๊น? ์ด ์ง๋ฌธ์ ์์ ์ง๋ฌธ๊ณผ ์ด๋ ์ ๋ ๊ด๋ จ์ด ์์ต๋๋ค. ArrayList์ ์์ ์์๊ฐ ์ค์ํ์ง ์์ ๊ฒฝ์ฐ ์ํธ๋ฅผ Set์ ๋ฐฐ์นํ์ฌ ์ค๋ณต ํญ๋ชฉ์ ์ ๊ฑฐํ ๋ค์ ๋ค์ List๋ก ๋๋๋ฆฌ๋ ๊ฒ์ด ํ๋ช
ํ ๋ฐฉ๋ฒ์
๋๋ค. ์๋๋ ์์์
๋๋ค. ์์์ ์์๊ฐ ์ค์ํ๋ค๋ฉด ํ์ค JDK์ ์๋
LinkedHashSet ์ ๋ชฉ๋ก์ ๋ฐฐ์นํ์ฌ ์์๋ฅผ ๋ณด์ฅํ ์ ์์ต๋๋ค.
8. ์ ๋ ฌ๋ ์ปฌ๋ ์
int[] array = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));
int[] array = new int[list.size()]; for(int i=0; i < list.size(); i++) { array[i] = list.get(i); }
List list = Arrays.asList(ArrayUtils.toObject(array));
int[] array = {1,2,3,4,5}; List
list = new ArrayList
(); for(int i: array) { list.add(i); }
Iterator
itr = list.iterator(); while(itr.hasNext()) { int i = itr.next(); if (i > 5) { // filter all ints bigger than 5 itr.remove(); } }
public interface Predicate
{ boolean test(T o); } public static
void filter(Collection
collection, Predicate
predicate) { if ((collection != null) && (predicate != null)) { Iterator
itr = collection.iterator(); while(itr.hasNext()) { T obj = itr.next(); if (!predicate.test(obj)) { itr.remove(); } } } }
filter(list, new Predicate
() { public boolean test(Integer i) { return i <= 5; } });
Set
set = new HashSet
(list);
Set
set = new TreeSet
(aComparator); set.addAll(list);
ArrayList** list = ... // initial a list with duplicate elements Set
set = new HashSet
(list); list.clear(); list.addAll(set);
Java์์ ์ ๋ ฌ๋ ์ปฌ๋ ์
์ ์ง์ํ๋ ๋ฐฉ๋ฒ์๋ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ต๋๋ค. ์ด๋ค ๋ชจ๋๋ ์์ฐ ์์๋ก ๋๋ ์ง์ ๋ ๋น๊ต๊ธฐ์ ์ํด ์ปฌ๋ ์
์ ์ ๊ณตํฉ๋๋ค. ์์ฐ ์์์ ๊ฒฝ์ฐ ์์์
Comparable ์ธํฐํ์ด์ค๋ ๊ตฌํํด์ผ ํฉ๋๋ค.
- Collections.sort()๋ ๋ชฉ๋ก์ ์ ๋ ฌํ ์ ์์ต๋๋ค. Java ๋ฌธ์์ ๋ช
์๋ ๋๋ก ์ด ์ ๋ ฌ์ ์์ ์ ์ด๋ฉฐ n log(n) ์ฑ๋ฅ์ ๋ณด์ฅํฉ๋๋ค.
- PriorityQueue๋ ์ง์์ ์ฐํ ๋๊ธฐ์ด์ ์ ๊ณตํฉ๋๋ค. PriorityQueue์ Collections.sort()์ ์ฐจ์ด์ ์ PriorityQueue๊ฐ ํญ์ ๋๊ธฐ์ด์ ์์๋ฅผ ์ ์งํ์ง๋ง ๋๊ธฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ง ๊ฐ์ ธ์ฌ ์ ์๋ค๋ ๊ฒ์
๋๋ค. PriorityQueue.get(4)๊ณผ ๊ฐ์ ์์์๋ ๋ฌด์์๋ก ์ก์ธ์คํ ์ ์์ต๋๋ค.
- ์ปฌ๋ ์
์ ์ค๋ณต ํญ๋ชฉ์ด ์์ผ๋ฉด TreeSet ์ ์ ํํ ์ ์์ต๋๋ค . PriorityQueue์ ๋ง์ฐฌ๊ฐ์ง๋ก TreeSet์ ํญ์ ์์๊ฐ ์ง์ ๋ ์ธํธ๋ฅผ ์ ์งํฉ๋๋ค. TreeSet์์ ๊ฐ์ฅ ์๊ฑฐ๋ ๊ฐ์ฅ ํฐ ์์๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์ง๋ง ์ฌ์ ํ ํด๋น ์์์ ๋ฌด์์๋ก ์ก์ธ์คํ ์๋ ์์ต๋๋ค.
๊ฐ๋จํ ๋งํด์ Collections.sort()๋ ์ผํ์ฑ ์ ๋ ฌ ๋ชฉ๋ก์ ์ ๊ณตํฉ๋๋ค. PriorityQueue ๋ฐ TreeSet์ ์์์ ๋ํ ์์ธํ๋ ์ก์ธ์ค๊ฐ ๋ถ์กฑํ์ฌ ํญ์ ์์๊ฐ ์ง์ ๋ ์ปฌ๋ ์
์ ์ ์งํฉ๋๋ค.
9. Collections.emptyList() ๋๋ ์ ์ธ์คํด์ค emptyMap() ๋ฐemptySet()์๋ ๋์ผํ ์ง๋ฌธ์ด ์ ์ฉ๋ฉ๋๋ค. ๋ ๋ฉ์๋ ๋ชจ๋ ๋น ๋ชฉ๋ก์ ๋ฐํํ์ง๋ง Collections.emptyList()๋ ๋ณ๊ฒฝํ ์ ์๋ ๋ชฉ๋ก์
๋๋ค. ์ด๋ "๋น" ๋ชฉ๋ก์ ์ ์์๋ฅผ ์ถ๊ฐ
ํ ์ ์์์ ์๋ฏธํฉ๋๋ค. ๋ฐฑ๊ทธ๋ผ์ด๋์์ Collections.emptyList() ๋ฉ์๋๋ฅผ ํธ์ถํ ๋๋ง๋ค ์ค์ ๋ก๋ ๋น ๋ชฉ๋ก์ ์ ์ธ์คํด์ค๊ฐ ์์ฑ๋์ง ์์ต๋๋ค. ๋์ , ์ด๋ฏธ ์กด์ฌํ๋ ๋น ์ธ์คํด์ค๋ฅผ ์ฌ์ฌ์ฉํฉ๋๋ค.
๋์์ธ ํจํด์ผ๋ก ์ฑ๊ธํด์ ์ต์ํ๋ค๋ฉด , ๊ทธ ์๋ฏธ๋ฅผ ์ดํดํด์ผ ํฉ๋๋ค. ์์ฃผ ํธ์ถํ๋ฉด ์ฑ๋ฅ์ด
ํฅ์ ๋ฉ๋๋ค .
10 ์ปฌ๋ ์
๋ณต์ฌ, Collections.copy() ์์ค ๋ชฉ๋ก์ ๋์ ๋ชฉ๋ก์ผ๋ก ๋ณต์ฌํ๋ ๋ฐฉ๋ฒ์๋ ๋ ๊ฐ์ง๊ฐ ์์ต๋๋ค. ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ArrayList ์์ฑ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค.
๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ Collections.copy() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค . ์ฒซ ๋ฒ์งธ ์ค์ ์ฃผ์ํ์ธ์. ์ปฌ๋ ์
์ ๋ํ Java ๋ฌธ์์ ๋ค์๊ณผ ๊ฐ์ด ๋์ ์์ผ๋ฏ๋ก ์๋ณธ ๋ชฉ๋ก์ ๊ธธ์ด์ ์ต์ํ ๋์ผํ ๊ธธ์ด์ ๋ชฉ๋ก์ ํ ๋นํฉ๋๋ค.
ArrayList
dstList = new ArrayList
(srcList);
๋์ ๋ชฉ๋ก์ ์ต์ํ ์์ค ๋ชฉ๋ก๋ณด๋ค ๊ธธ์ด์ผ ํฉ๋๋ค.
์ฆ, ์ต์ข
๋ชฉ๋ก์ ์๋ณธ ๋ชฉ๋ก๋ณด๋ค ์งง์์๋ ์ ๋ฉ๋๋ค. ๋ ๋ฐฉ๋ฒ ๋ชจ๋ ์์ ๋ณต์ฌ์
๋๋ค. ๊ทธ๋ ๋ค๋ฉด ์ด ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ฐจ์ด์ ์ ๋ฌด์์
๋๊น? ์ฒซ์งธ, dstList์ srcList์ ๋ชจ๋ ์์๋ฅผ โโํฌํจํ ๊ณต๊ฐ์ด ์ถฉ๋ถํ์ง ์์ ๊ฒฝ์ฐ์๋ Collections.copy()๋ dstList ์ปฌ๋ ์
์ ์ฉ๋์ ์ฌํ ๋นํ์ง ์์ต๋๋ค. ๋์
IndexOutOfBoundsException ์ด ๋ฐ์ํฉ๋๋ค . ์ด๊ฒ์ ์ด๋ค ์ด์ ์ด ์๋์ง ๋ฌผ์ด๋ณผ ์๋ ์์ต๋๋ค. ๊ทธ ์ด์ ๋ ๋ฉ์๋๊ฐ ์๊ฐ์ ๋ฐ๋ผ ์ ํ์ ์ผ๋ก ์คํ๋๋๋ก ๋ณด์ฅํ๊ธฐ ๋๋ฌธ์
๋๋ค. ์ด๋ ArrayList ์์ฑ์์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ค์ ํ ๋นํ๋ ๋์ ๋ฐฐ์ด์ ์ฌ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ์๋ ์ ํฉํฉ๋๋ค.
๊ฒฐ๋ก ๋์ ๊ธฐ์ฌ๋ฅผ ์ฝ์ ํ์๋ ์ฌ์ ํ ๊ถ๊ธํ ์ ์ด ์์ผ๋ฉด ๋๊ธ๋ก ์ง๋ฌธํด ์ฃผ์ธ์. ๋ํ, ๋ฒ์ญ์ด ๋ถ์ ํํ๊ฑฐ๋ ๊ธฐํ ์ค๋ฅ๊ฐ ์๋ ๊ฒฝ์ฐ PM์๊ฒ ํธ์ง๋ฅผ ๋ณด๋ด์ฃผ์๋ฉด ์์ ํด ๋๋ฆฌ๊ฒ ์ต๋๋ค. ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.
์๋์.
ArrayList
dstList = new ArrayList
(srcList.size()); Collections.copy(dstList, srcList);
GO TO FULL VERSION