"๋‚˜ ์—ฌ๊ธฐ์žˆ์–ด."

"์—ฌ๊ธฐ์„œ ์˜ค๋žซ๋™์•ˆ ๋‹น์‹ ์„ ๊ธฐ๋‹ค๋ฆฌ๊ณ  ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค."

"๊ทธ๋žฌ์œผ๋ฉด ์ข‹๊ฒ ์–ด. ๊ทธ๋Ÿผ ๊ณ„์†ํ•˜์ž."

"์ปฌ๋ ‰์…˜์„ ์œ„ํ•œ ์ดˆํŠน๊ธ‰ ํ’€ ๊ธฐ๋Šฅ ์œ ํ‹ธ๋ฆฌํ‹ฐ ํด๋ž˜์Šค๋ฅผ ์†Œ๊ฐœํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค."

"๋‚˜๋Š” ์ด๋ฏธ ํฅ๋ถ„์œผ๋กœ ์˜จํ†ต ๋–จ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค."

"์ข‹์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿผ ์‹œ์ž‘ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. Collections ํด๋ž˜์Šค์˜ ๋ฉ”์„œ๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค."

์•”ํ˜ธ ์„ค๋ช…
boolean addAll(Collection<? super T> c, T... elements)
์ „๋‹ฌ๋œ ์ปฌ๋ ‰์…˜์— ์ „๋‹ฌ๋œ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
์ด ๋ฉ”์„œ๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํŽธ๋ฆฌํ•˜๊ฒŒ ํ˜ธ์ถœํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. Collections.addList(๋ชฉ๋ก, 10,11,12,13,14,15)
Queue<T> asLifoQueue(Deque<T> deque)
deque์—์„œ ๋งŒ๋“  ยซ์ผ๋ฐ˜ ๋Œ€๊ธฐ์—ดยป์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
๋ชฉ๋ก์˜ ํ‚ค ์š”์†Œ์— ๋Œ€ํ•œ ์ด์ง„ ๊ฒ€์ƒ‰์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.
๋ชฉ๋ก์„ ์ •๋ ฌํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
๋น„๊ต๊ธฐ๋ฅผ ์ง€์ •ํ•˜์—ฌ ์š”์†Œ๋ฅผ ๋น„๊ตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
Collection<E> checkedCollection(Collection<E> c, Class<E> type)
์ปฌ๋ ‰์…˜ c์˜ ๋ชจ๋“  ์š”์†Œ๊ฐ€ ํŠน์ • ์œ ํ˜•์ธ์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
List, Map, Set ๋ฐ SortedSet์— ๋Œ€ํ•ด์„œ๋„ ๋น„์Šทํ•œ ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.
void copy(List<? super T> dest, List<? extends T> src)
src ๋ชฉ๋ก์„ dest ๋ชฉ๋ก์— ๋ณต์‚ฌํ•ฉ๋‹ˆ๋‹ค.
boolean disjoint(Collection<?> c1, Collection<?> c2)
์ปฌ๋ ‰์…˜์— ๊ณตํ†ต ์š”์†Œ๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ์ง€ ์•Š์€์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
void fill(List<? super T> list, T obj)
์š”์†Œ obj๋กœ ๋ชฉ๋ก์„ ์ฑ„์›๋‹ˆ๋‹ค.
int frequency(Collection<?> c, Object o)
๊ฐœ์ฒด o๊ฐ€ ์ปฌ๋ ‰์…˜ c์— ๋ช‡ ๋ฒˆ ์กด์žฌํ•˜๋Š”์ง€ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค.
int indexOfSubList(List<?> source, List<?> target)
์†Œ์Šค ๋ชฉ๋ก ๋‚ด์—์„œ ๋Œ€์ƒ ๋ชฉ๋ก์ด ์ฒ˜์Œ ๋‚˜ํƒ€๋‚˜๋Š” ์ธ๋ฑ์Šค๋ฅผ ๊ฒฐ์ •ํ•ฉ๋‹ˆ๋‹ค.
์›๋ฆฌ๋Š” String.indexOf("some string") ๊ณผ ๋น„์Šทํ•ฉ๋‹ˆ๋‹ค.
int lastIndexOfSubList(List<?> source, List<?> target)
์†Œ์Šค ๋ชฉ๋ก ๋‚ด์—์„œ ๋งˆ์ง€๋ง‰์œผ๋กœ ๋‚˜ํƒ€๋‚˜๋Š” ๋Œ€์ƒ ๋ชฉ๋ก์˜ ์ธ๋ฑ์Šค๋ฅผ ๊ฒฐ์ •ํ•ฉ๋‹ˆ๋‹ค.
String.lastIndexOf("์ผ๋ถ€ ๋ฌธ์ž์—ด")๊ณผ ์œ ์‚ฌ
max(Collection<? extends T> coll)
๋ชจ์Œ์—์„œ ์ตœ๋Œ€ ์ˆ˜/๊ฐ’์„ ๊ฒ€์ƒ‰ํ•ฉ๋‹ˆ๋‹ค.
์ตœ๋Œ€ 6๊ฐœ์˜ ์ˆซ์ž๋ฅผ ์ฐพ๋Š” ๋ฐฉ๋ฒ•์€ ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?
Collections.max(Arrays.asList(51, 42, 33, 24, 15, 6));
min(Collection<? extends T> coll)
์ปฌ๋ ‰์…˜์—์„œ ์ตœ์†Œ๊ฐ’์„ ๊ฒ€์ƒ‰ํ•ฉ๋‹ˆ๋‹ค.
List<T>nCopies(int n, To)
o ์š”์†Œ๊ฐ€ n๋ฒˆ ๋‚˜ํƒ€๋‚˜๋Š” ๋”๋ฏธ ์ปฌ๋ ‰์…˜์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค.
boolean replaceAll(List<T> list, T oldVal, T newVal)
๋ชฉ๋ก์˜ ๋ชจ๋“  oldVal ์š”์†Œ๋ฅผ newVal ์š”์†Œ๋กœ ๋ฐ”๊ฟ‰๋‹ˆ๋‹ค.
void reverse(List<?> list)
๋ชฉ๋ก์„ ๋’ค์ง‘์Šต๋‹ˆ๋‹ค.
void shuffle(List<?> list)
๋ชฉ๋ก์˜ ์š”์†Œ๋ฅผ ๋ฌด์ž‘์œ„๋กœ ์„ž์Šต๋‹ˆ๋‹ค.
List<T>singletonList(To)
ํ•˜๋‚˜์˜ ์ „๋‹ฌ๋œ ์š”์†Œ๋กœ ๊ตฌ์„ฑ๋œ ๋ถˆ๋ณ€ ๋ชฉ๋ก์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
Map, Set ๋ฐ SortedSet์— ๋Œ€ํ•ด ์œ ์‚ฌํ•œ ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.
void sort(List<T> list)
๋ชฉ๋ก์„ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌํ•ฉ๋‹ˆ๋‹ค.
void swap(List<?> list, int i, int j)
๋ชฉ๋ก์˜ ์š”์†Œ๋ฅผ ๋ฐ”๊ฟ‰๋‹ˆ๋‹ค.
Collection<T>synchronizedCollection(Collection<T> c)
์ด ์ปฌ๋ ‰์…˜์„ ๋™๊ธฐํ™”๋œ ๋Œ€์‘ ํ•ญ๋ชฉ์œผ๋กœ ๋ž˜ํ•‘ํ•ฉ๋‹ˆ๋‹ค.
List, Map, Set ๋ฐ SortedSet์— ๋Œ€ํ•ด์„œ๋„ ๋น„์Šทํ•œ ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

"์™€์šฐ! ๊ทธ๋ž˜, ์ด๊ฑด ์™„์ „ ๋ฌด๊ธฐ๊ณ ์•ผ. ๊ทธ๋ฆฌ๊ณ  ๋‚œ ๊ทธ๊ฑธ ๊ฑฐ์˜ ์‚ฌ์šฉํ•˜์ง€ ์•Š์•˜์–ด."

"์‚ฌ์‹ค ์˜ค๋Š˜ ๋‚ด ์ˆ˜์—…์€ ์—ฌ๊ธฐ์„œ ๋์ด์•ผ."

"์ด๋Ÿฌํ•œ ๋ฐฉ๋ฒ•์„ ์‚ดํŽด๋ณด๊ณ  ๊ฐ€์žฅ ์‚ฌ์šฉํ•  ๊ฐ€๋Šฅ์„ฑ์ด ๋†’์€ ๋ฐฉ๋ฒ•์„ ์ฐพ์œผ์‹ญ์‹œ์˜ค."

"์•„๋‹ˆ๋ฉด ๋” ์ข‹์€ ๋ฐฉ๋ฒ•์€ ๊ทธ๊ฒƒ๋“ค์„ ์—ฐ๊ตฌํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๊ฒƒ๋“ค์€ ๋‹น์‹ ์—๊ฒŒ ์œ ์šฉํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค."

"๊ณ ๋งˆ์›Œ, ๋ฆฌ์‹œ. ๊ณต๋ถ€ํ•˜๋Ÿฌ ๊ฐˆ๊ฒŒ."