[JAVA] Arrays ํด๋์ค
in Tech-Stack on JAVA
Contents
Arrays ํด๋์ค
- java.util ํจํค์ง์ ์กด์ฌํ๋ ํด๋์ค์ด๋ค.
- ๋ฐฐ์ด์ ๋ค๋ฃจ๊ธฐ ์ํ ๋ค์ํ ๋ฉ์๋๊ฐ ์กด์ฌํ๋ค.
- ์๋จ์
import java.util.Arrays;๋ฅผ ํตํด ๋ถ๋ฌ์์ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
1. Arrays.sort(๋ฐฐ์ด, ๊ตฌ๊ฐ) ๋ฉ์๋
- ๋งค๊ฐ๋ณ์
- ๋ฐฐ์ด - ์๋ณธ ๋ฐฐ์ด
- ๊ตฌ๊ฐ(์์ index, ๋ง์ง๋ง+1 index) - ์ ๋ ฌ ๋ฒ์๋ฅผ ์ค์ ํ ์ ์์ผ๋ฉฐ ์
๋ ฅํ์ง ์์ผ๋ฉด ๋ชจ๋ ์์๋ฅผ ์ ๋ ฌํ๋ค.
- ์์ index - ์ ๋ ฌ์ ์์ํ index
- ๋ง์ง๋ง+1 index - ์ ๋ ฌํ ์์์ ๋ง์ง๋ง index
์ ๋ฌ๋ฐ์ ๋ฐฐ์ด์์ ์์๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
๋ฐฐ์ด์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ค๋ฉด ์ธ์์ ์ถ๊ฐ๋ก Collections ํด๋์ค์ Collections.reverseOrder()์ ์ ๋ฌํ๋ฉด ๋๋ค.
import java.util.Arrays;
import java.util.Collections;
...
int[] arr1 = {4, 5, 2, 3};
String[] arr2 = {"A", "B", "Z", "T", "D"};
int[] arr3 = {9, 5, 7, 8, 9, 5, 3, 1};
int[] arr4 = {1, 2, 3, 4, 5};
Arrays.sort(arr1); // arr ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
Arrays.sort(arr2);
Arrays.sort(arr3, 3, 7); // 3 ~ 6 index์ ์์๋ง ์ ๋ ฌ
// error ๋ฐ์!!!!
Arrays.sort(arr4, Collections.reverseOrder());
// ์คํ ๊ฒฐ๊ณผ ===========
// arr1 = {2, 3, 4, 5};
// arr2 = {"A", "B", "D", "T", "Z"};
// arr3 = {9, 5, 7, 3, 5, 8, 9, 1};
๋ง์ฝ ์์ ๊ฐ์ด ์คํํ ๊ฒฝ์ฐ Arrays.sort(arr4, Collections.reverseOrder());์์ ์๋์ ๊ฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒ์ด๋ค.
The method sort(int[]) in the type Arrays is not applicable for the arguments (int[], Collections.reverseOrder())
Collections.reverseOrder()์ ๊ฐ์ฒด์๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ ๋ฉ์๋์ด๋ค.
ํ์ง๋ง arr4๋ ๊ธฐ๋ณธ ์๋ฃํ(primitive type)์ธ int ํ์ ์ด๊ธฐ ๋๋ฌธ์ ์ ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค.
- ํด๊ฒฐ ๋ฐฉ๋ฒ
int[]๊ฐ ์๋Integer[]์ ํตํด ๊ฐ์ฒด๋ก ์ ์ธํ๋ฉด ๋๋ค.
import java.util.Arrays; import java.util.Collections; ... Integer[] arr4 = {1, 2, 3, 4, 5}; Arrays.sort(arr4, Collections.reverseOrder()); // ์คํ ๊ฒฐ๊ณผ =========== // arr4 = {5, 4, 3, 2, 1};
2. Arrays.copyOf(๋ฐฐ์ด, ๊ธธ์ด) ๋ฉ์๋
- ๋งค๊ฐ๋ณ์
- ๋ฐฐ์ด - ์๋ณธ ๋ฐฐ์ด
- ๊ธธ์ด - ์๋ก ์์ฑํ ๋ฐฐ์ด์ ํฌ๊ธฐ
์ ๋ฌ๋ฐ์ ๋ฐฐ์ด์ ์ ๋ฌ๋ฐ์ ๊ธธ์ด์ ์๋ก์ด ๋ฐฐ์ด๋ก ์์ฑํด์ ๋ฐํํ๋ค.
- ์๋กญ๊ฒ ์์ฑ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์๋ณธ ๋ฐฐ์ด๋ณด๋ค ๊ธธ๋ฉด, ๋๋จธ์ง ์์๋ ๋ฐฐ์ด์ ์๋ฃํ์ ๋ง๊ฒ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ฑ์์ง๋ค.
- ์๋กญ๊ฒ ์์ฑ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์๋ณธ ๋ฐฐ์ด๋ณด๋ค ์์ผ๋ฉด, ํด๋น ๊ธธ์ด๊น์ง์ ์์๋ง ๋ฐํํ๋ค.
int[] arr1 = {1, 2, 3}; // ํฌ๊ธฐ๊ฐ 3์ธ intํ ๋ฐฐ์ด arr1 ์์ฑ
// arr1์ ๋์ผํ ์์๋ฅผ ๊ฐ์ง๋ฉฐ ํฌ๊ธฐ๊ฐ 5์ธ ๋ฐฐ์ด ์์ฑ
int[] arr2 = Arrays.copyOf(arr1, 5);
// arr1์ ๋์ผํ ์์๋ฅผ ๊ฐ์ง๋ฉฐ ํฌ๊ธฐ๊ฐ 2์ธ ๋ฐฐ์ด ์์ฑ
int[] arr3 = Arrays.copyOf(arr1, 2);
// ์คํ ๊ฒฐ๊ณผ ===========
// arr1 = {1, 2, 3};
// arr2 = {1, 2, 3, 0, 0};
// arr3 = {1, 2};
copyOf()๋ฅผ ์ฌ์ฉํ์ง ์์ ๊ฒฝ์ฐ๋ ๋ค์๊ณผ ๊ฐ๋ค.
int[] arr = { 1, 2, 3 };
int[] tmp = arr;
arr = new int[arr.length + 3];
for (int i = 0; i < tmp.length; i++) {
arr[i] = tmp[i];
}
3. Arrays.toString(๋ฐฐ์ด) ๋ฉ์๋
- ๋งค๊ฐ๋ณ์
- ๋ฐฐ์ด - ๊ฐ์ ์ถ๋ ฅํ ๋ฐฐ์ด
- ๋ฐฐ์ด - ๊ฐ์ ์ถ๋ ฅํ ๋ฐฐ์ด
๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ฐ์ ๋ฐฐ์ด์ ์ ์๋ ๊ฐ๋ค์ ๋ฌธ์์ด ํํ๋ก ๋ง๋ค์ด์ ๋ฐํํด์ค๋ค.
import java.util.Arrays;
...
int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr));
// ์คํ ๊ฒฐ๊ณผ ===========
// [1, 2, 3]
4. Arrays.copyOfRange(๋ฐฐ์ด, ์์์ธ๋ฑ์ค, ๋ง์ง๋ง์ธ๋ฑ์ค) ๋ฉ์๋
- ๋งค๊ฐ๋ณ์
- ๋ฐฐ์ด - ์๋ณธ ๋ฐฐ์ด
- ์์ ์ธ๋ฑ์ค - ๋ฐฐ์ด์ ์๋ฅผ ์ธ๋ฑ์ค์ ์์น
- ๋ง์ง๋ง ์ธ๋ฑ์ค - ์
๋ ฅ๋ ์ซ์ -1 ๊น์ง ๋ฐฐ์ด์ ๋ถ๋ฆฌํจ
์ ๋ ฅ๋ฐ์ ๋ฐฐ์ด์ ์์ ์ธ๋ฑ์ค ๋ถํฐ ๋ง์ง๋ง ์ธ๋ฐ์ค -1 ๊น์ง์ ๊ฐ์ ๋ฐฐ์ด์ ๋ฐํํ๋ค.
์๋ณธ ๋ฐฐ์ด์ ์์ ํ๋ ๊ฒ์ด ์๋๊ณ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํด์ ๋ฐํํ๋ค.
import java.util.Arrays;
int[] arr1 = {1, 2, 3, 4, 5, 6, 7};
int[] arr2 = Arrays.copyOfRange(arr, 3, arr.length);
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
// ์คํ ๊ฒฐ๊ณผ ===========
// [ 1, 2, 3, 4, 5, 6, 7]
// [ 4, 5, 6, 7]
