์๋ฐ ์ฝ๋ฉ ํ
์คํธ์์ Array, List, ArrayList๋ ๊ฑฐ์ ๋ชจ๋ ๋ฌธ์ ์ ๊ธฐ๋ณธ ๋ผ๋๊ฐ ๋ฉ๋๋ค. ์ด ์ธ ๊ฐ์ง๋ฅผ ๋ค๋ฃฐ ๋ ํ์๋ก ์์์ผ ํ๋ ํต์ฌ ๋ฉ์๋์ ํ์ ์ํฉ๋ณ๋ก ๋๋์ด ๋ณด๊ธฐ ์ฝ๊ฒ ์ ๋ฆฌํด ๋๋ฆฝ๋๋ค.
์๋ฐ ๊ธฐ๋ณธ ๋ฐฐ์ด(int[], String[] ๋ฑ)์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์์ผ๋ฉฐ, ์ฃผ๋ก java.util.Arrays ํด๋์ค์ ์ ํธ๋ฆฌํฐ ๋ฉ์๋์ ํจ๊ป ์ฌ์ฉ๋ฉ๋๋ค.
| ๋ฉ์๋ | ์ค๋ช | ์์ |
|---|---|---|
arr.length |
๋ฐฐ์ด์ ๊ธธ์ด(๋ณ์) | int len = arr.length; |
Arrays.sort(arr) |
๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ (์๋ณธ ๋ณ๊ฒฝ) | Arrays.sort(arr); |
Arrays.copyOfRange(arr, from, to) |
๋ฐฐ์ด์ ํน์ ๋ฒ์๋ฅผ ์๋ฅธ ์ ๋ฐฐ์ด ์์ฑ (to๋ ์ ์ธ) | int[] sub = Arrays.copyOfRange(arr, 0, 3); |
Arrays.fill(arr, val) |
๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ํน์ ๊ฐ์ผ๋ก ์ด๊ธฐํ (DP ๋ฑ์์ ์ ์ฉ) | Arrays.fill(arr, -1); |
Arrays.asList(arr) |
๋ฐฐ์ด์ ๊ณ ์ ํฌ๊ธฐ์ List๋ก ๋ณํ | List<String> list = Arrays.asList(strArr); |
โ ๏ธ ์ฃผ์:Arrays.sort()์ ๋ณ๋์ ์ ๋ ฌ ๊ธฐ์ค(Comparator)์ ๋ฃ๊ณ ์ถ๋ค๋ฉด,int[]๊ฐ์ ๊ธฐ๋ณธํ ๋ฐฐ์ด์ด ์๋Integer[]๊ฐ์ ์ฐธ์กฐํ ๊ฐ์ฒด ๋ฐฐ์ด์ด์ด์ผ ํฉ๋๋ค.
ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ ์ธ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ๊ฐ์ฅ ๋ง์ด ์๋๋ค. ์ฝํ
์์๋ ๋๋ค์ List<T> list = new ArrayList<>(); ํํ๋ก ์ ์ธํด ์ฌ์ฉํฉ๋๋ค.
| ๋ฉ์๋ | ์ค๋ช | ์์ |
|---|---|---|
list.size() |
๋ฆฌ์คํธ์ ์์ ๊ฐ์ ๋ฐํ | int size = list.size(); |
list.add(value) |
๋ฆฌ์คํธ ๋์ ์์ ์ถ๊ฐ | list.add(10); |
list.add(index, value) |
ํน์ ์ธ๋ฑ์ค์ ์์ ์ฝ์ (๋ค ์์๋ค์ ๋ฐ๋ฆผ) | list.add(0, 5); |
list.get(index) |
ํน์ ์ธ๋ฑ์ค์ ๊ฐ ๊ฐ์ ธ์ค๊ธฐ | int val = list.get(2); |
list.set(index, value) |
ํน์ ์ธ๋ฑ์ค์ ๊ฐ ๋ณ๊ฒฝ | list.set(1, 20); |
list.remove(index) |
ํน์ ์ธ๋ฑ์ค์ ์์ ์ญ์ (์ญ์ ๋ ๊ฐ ๋ฐํ) | list.remove(0); |
list.indexOf(value) |
ํน์ ๊ฐ์ด ์์นํ ์ธ๋ฑ์ค ์ฐพ๊ธฐ (์์ผ๋ฉด -1) |
int idx = list.indexOf("target"); |
list.contains(value) |
ํน์ ๊ฐ์ด ๋ฆฌ์คํธ์ ํฌํจ๋์ด ์๋์ง ํ์ธ (boolean) | if (list.contains(5)) { ... } |
list.clear() |
๋ฆฌ์คํธ์ ๋ชจ๋ ์์ ์ญ์ | list.clear(); |
List ๊ณ์ด์ ์ปฌ๋ ์
์ ๋ค๋ฃฐ ๋๋ java.util.Collections ํด๋์ค๋ฅผ ํ์์ ์ผ๋ก ์ฌ์ฉํด์ผ ํฉ๋๋ค.
- ์ค๋ฆ์ฐจ์ ์ ๋ ฌ:
Collections.sort(list); - ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ:
Collections.sort(list, Collections.reverseOrder()); - ์์ ๋ค์ง๊ธฐ (๋ค์ฃฝ๋ฐ์ฃฝ์ผ๋ก ๋ง๋ค๊ธฐ ์๋):
Collections.reverse(list); - ์ต๋๊ฐ / ์ต์๊ฐ ์ฐพ๊ธฐ:
int max = Collections.max(list);
int min = Collections.min(list);์๋ฐ ์ฝํ ๋ฌธ์ ๋ฅผ ํ๋ค ๋ณด๋ฉด ๋ฐฐ์ด์ ๋ฆฌ์คํธ๋ก, ๋ฆฌ์คํธ๋ฅผ ๋ฐฐ์ด๋ก ๋ฐ๊ฟ์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์ ๋ง ๋ง์ต๋๋ค. ์๋ ํจํด์ ์ธ์๋์๋ ๊ฒ์ด ์ข์ต๋๋ค.
ArrayList<int[]> al = new ArrayList<>();
// ... al์ ๋ฐ์ดํฐ ์ถ๊ฐ ...
int[][] answer = al.toArray(new int[al.size()][]);int[] arr = {1, 2, 3};
List<Integer> list = Arrays.stream(arr)
.boxed()
.collect(Collectors.toList());List<Integer> list = new ArrayList<>();
// ... list์ ๋ฐ์ดํฐ ์ถ๊ฐ ...
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();- ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์๊ณ ์ธ๋ฑ์ค๋ก ๋น ๋ฅธ ์ ๊ทผ์ด ํ์ํ๋ค โก๏ธ
Array - ๋ฐ์ดํฐ ๊ฐ์๊ฐ ๊ณ์ ๋ณํ๊ณ , ์ค๊ฐ ์ฝ์
/์ญ์ ๋ ํ์ ๋ฉ์๋๊ฐ ํ์ํ๋ค โก๏ธ
ArrayList - ๋๋ค์์ ์ธ ๋ ๋ฆฌ์คํธ ์์ ๋ณ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ์ธ๋ถ ๋ณ์๊ฐ ๊ณ ์ ๊ฐ(
finalํน์ ๋ณํ์ง ์๋ ์ํ)์ด์ด์ผ ํ๋ค๋ ์ ์ ํญ์ ์ธ์งํ๊ธฐ!