๋ ๋ฎ์ ๋๋ฅผ, ๋ถ์กฑํ ๋๋ฅผ.
๋ ๋ฎ์ ๋๋ฅผ, ๋ถ์กฑํ ๋๋ฅผ. ๊ด๋ จ
Arrays.asList(์ด๋ ์ด)
๋ String[]
๋ฑ์ ๋ฐฐ์ด์ List<String>
๋ฆฌ์คํธ๋ก ๋ฐ๊ฟ ๋ ๋งค์ฐ ์์ฃผ ์ฐ๋ ๋ฉ์๋์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ ์ด๋๋ ์ด๋ ๊ฒ ์ง๊ณ ๋๋ ์ค๋ฅ๊ฐ ๋น ๋ฐฉ!!!
// ์ฌ์ง url ๋ฐฐ์ด์ ๋ฆฌ์คํธ๋ก ๋ง๋ค๊ณ
List<String> photoList = Arrays.asList(photoUrls);
// ํด๋น ๋ฆฌ์คํธ์ ๋ ๋ค๋ฅธ ์ฌ์ง๋ค์ ์ถ๊ฐ arrayList ํํ
List<String> photoList2 = getPhotoList();
photoList.addAll(photoList2); // java.lang.UnsupportedOperationException
java.lang.UnsupportedOperationException
์ ์์ฃผ ๋ชป๋ณด๋ ์ค๋ฅ๋ผ ์ด์ฌํ ์ฐพ์๋ดค๋๋, ๋ฌธ์ ๋ Arrays.asList()
method ์ ๊ฒฐ๊ณผ๋ฌผ์ ์ฐ๋ฆฌ๊ฐ ํํ ์ฐ๋ java.util.ArrayList
๊ฐ ์๋๋ผ Arrays
์์ ์๋ inner class ์์ต๋๋ค.
Arrays$arrayList
/**
* @serial include
*/
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
@Override
public int size() {
return a.length;
}
@Override
public Object[] toArray() {
return a.clone();
}
@Override
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
int size = size();
if (a.length < size)
return Arrays.copyOf(this.a, size,
(Class<? extends T[]>) a.getClass());
System.arraycopy(this.a, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
/***
์ค๋ต
***/
@Override
public void sort(Comparator<? super E> c) {
Arrays.sort(a, c);
}
}
์ ์ฝ๋๋ฅผ ๋ณด์๋ฉด ์ ์ ์๋ฏ์ด, abstractList ๋ฅผ ์์๋ฐ์์ ์์ฑ๋์๊ณ ๋ฑํ list ์ ์๋ add
๋ addAll
method ๋ฅผ override ํ์ง ์๊ณ ์์ต๋๋ค. ๊ทธ๋ ๊ธฐ์ ๊ฒฐ๊ตญ ํด๋น addAll(์ปฌ๋ ์
)
์ ์ฌ์ฉํ๋ฉด AbstractCollection
์ addAll
๋ฉ์๋๊ฐ ์ํ๋๊ฒ ๋ฉ๋๋ค. ( AbstractList
์ addAll(collection)
๋ฉ์๋๊ฐ ์๊ธฐ๋๋ฌธ์ ์์๋ฐ์ AbstractCollection
๊ฒ์ ์ํ)
/** AbstractCollection class ๋ฐ์ท **/
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e)) // abstractList ์ add ์ฌ์ฉ
modified = true;
return modified;
}
/** AbstractCollection class ๋ฐ์ท **/
// ์ผ๋ฐ์ ์ธ add ๋ฉ์๋๋ ๊ฐ๋ฅ
public boolean add(E e) {
**add(size(), e);** // ์๋ add(index,element) ํธ์ถ
return true;
}
// ์ค๋ฅ๋จ... ๊ฒฐ๊ตญ add(index,element) ๋ฅผ ์ฌ๊ตฌํ ํ์ง ์์ผ๋ฉด ์ฃ๋ค ๋ชป์ฐ๋ ๋ฉ์๋
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
์์ ๊ฐ์ addAll
๋ฉ์๋๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ๋ค๋ณด๋ ์ฒ์์ ์ ๊ฐ addAll
ํ๊ฒ ๋ ๋ถ๋ถ์์ UnsupportedOperationException
๊ฐ ๋์ค๊ฒ ๋ ๊ฒ์
๋๋ค. ํ๋ผ๋ฏธํฐ์ ์ธ๋ฑ์ค๊ฐ ์๋ add
๋ฅผ Override ํด์ผ์ง๋ง addAll
๋ ์ธ ์ ์๊ฒ ๋๋ ์ํ๋ก ๋ณด์ด๋๋ฐ, Arrays.asList
์ ๊ฒฐ๊ณผ์ธ Arrays$arrayList
ํด๋์ค๋ ๊ตณ์ด ๊ทธ๋ ๊ฒ ๋ง๋ค์ง ์์๊ธฐ์ ์ค๋ฅ๊ฐ ๋๋ค์.
๊ฒฐ๋ก
Arrays.asList(๋ฐฐ์ด)
์ ๊ฒฐ๊ณผ์ธ arrayList
๋ ๊ธฐ์กด์java.util.ArrayList
์๋ ๋ค๋ฅด๋ฉฐ, addAll
๋ฉ์๋๋ฅผ ์ธ ์ ์๋ ์ํ๋ค... ๋ผ๊ณ ์์ ๋๋ฉด ๋ ๊ฒ ๊ฐ์ต๋๋ค.
์๋ฌดํผ ์ด๋ ๊ฒ ๋ ํ๋ ๋ฐฐ์ฐ๊ฒ ๋๋ ํ๋ฃจ์์ต๋๋ค. ๋ฎ์์ง๋ง ๋ถ์กฑํ ๋ ์์ ์ฃผ์ํ์ธ์.