์ฝ๋ฉํ ์คํธ ๊ณต๋ถ๋ฅผ ํ๋ค ๋ณด๋ฉด ์์๋ค์ ์ค๋ณต์ ํ์ฉํ์ง ์๋ ๋ฌธ์ ๋ฅผ ์์ฃผ ์ ํ๊ฒ ๋ฉ๋๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํํ ์ฌ์ฉํ๋ ๋ ๊ฐ์ง ์ค๋ณต ์ ๊ฑฐ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด ๋ณด์์ต๋๋ค.
์ถ๊ฐ๋ก, ์ค๋ณต ์ ๊ฑฐ ํ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด์๋ ์ด์ง ์ ์ด๋ณด์์ต๋๋ค ๐ค
1๏ธโฃ distinct() ์ฌ์ฉ
int[]arr = new int[n];
arr[0] =3; arr[1]=2;
// ์ค๋ณต ์ ๊ฑฐ
int[] arr2 = Arrays.stream(arr).distinct().toArray();
Arrays.sort(arr2);
sort ํจ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์์ ๋๋ค.
๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๊ณ ์ถ์ผ๋ฉด `Collections.reverseOrder()` ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค.
๊ทผ๋ฐ `Collections.reverseOrder()`์ผ๋ก ์ ๋ ฌํ ๋ฐฐ์ด์ ํ๋ฆฌ๋ฏธํฐ๋ธ ํ์ ์ด ์๋ ๋ํผํด๋์ค ์ด์ด์ผ ํ๋ค๋ ์ !
์ ์์ ๊ฒฝ์ฐ, `int` ๊ฐ ์๋ `Integer` ์ฌ์ผ ํ๋ค๋ ๊ฒ์ด์ฃ .
๋ฐ๋ผ์ `int []` ํ์ ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ์ถ์ผ๋ฉด ์๋์ฒ๋ผ `Integer []`๋ก ๋ณ๊ฒฝํ์ฌ ์ ๋ ฌํ ํ, ๋ค์ `int []`ํ์ ์ผ๋ก ๋ณ๊ฒฝํ๋ฉด ๋ฉ๋๋ค.
int[] arr1 = {3, 1, 2, 4};
// 1. int[] -> Integer[]
Integer[] arr2 = Arrays.stream(arr).boxed().distinct().toArray(Integer[]::new);
// 2. ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
Arrays.sort(arr2, Collections.reverseOrder());
// 3. Integer[] -> int[]
int[] arr3 = Arrays.stream(arr2).mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(arr3));
- `boxed()` ๋ฉ์๋๋ ์์ ํ์
์ ๋ํ ์คํธ๋ฆผ ์ง์์ ํด๋์ค ํ์
์ผ๋ก ์ ํํด ์ค๋๋ค.
- ex. IntStream -> Stream <Integer>
- `mapToInt()` ๋ฉ์๋๋ Stream์ IntStream์ผ๋ก ์ ํํด ์ค๋๋ค.
- `int []` ๋ฅผ ์คํธ๋ฆผํํ๋ฉด `IntStream` / `Integer []`๋ฅผ ์คํธ๋ฆผํํ๋ฉด `Stream <Integer>`
- ๋ค๋ฅธ Stream์ int[]๋ก ๋ณ๊ฒฝํ๊ณ ์ถ์ผ๋ฉด mapToInt() ์ฌ์ฉํ๊ธฐ
์ ์ฝ๋์์๋ 3๊ฐ์ง ๊ณผ์ ์ผ๋ก ๋ถ๋ฆฌํ์ฌ ์์ฑํ์ง๋ง, ํ ์ค๋ก ์๋์ ๊ฐ์ด ์์ฑํ ์๋ ์์ต๋๋ค.
int[] arr1 = {3, 1, 2, 4};
// ํ ์ค๋ก ์์ฑ
int[] arr2 = Arrays.stream(arr)
.distinct()
.boxed()
.sorted(Comparator.reverseOrder())
.mapToInt(Integer::intValue)
.toArray();
2๏ธโฃ HashSet ์ฌ์ฉ
์งํฉ์ ์ค๋ณต์ ํ์ฉํ์ง ์์ต๋๋ค.
๋ฐ๋ผ์ ์ ์ด์ ์ ๋ต์ ๋ด๋ ์๋ฃํ์ผ๋ก HashSet์ ์ฌ์ฉํ๋ฉด, ์ดํ์ ๋ฐ๋ก ์ค๋ณต ์ ๊ฑฐ๋ฅผ ํ์ง ์์๋ ๋ฉ๋๋ค.
HashSet<Integer> set = new HashSet<>();
int[] answer = set.stream().sorted().mapToInt(Integer::intValue).toArray()
โ ๊ธฐ๋ณธํ ๋ฐฐ์ด <-> ๋ํผ ํด๋์ค ๋ฐฐ์ด
๐ท Integer [] -> int [] ๋ณํ
Integer[] a = {1, 2, 3, 4};
int[] b = Arrays.stream(a).mapToInt(Integer::intValue).toArray();
๐ท int [] -> Integer [] ๋ณํ
int[] a = {1, 2, 3, 4};
Integer[] b = Arrays.stream(a).boxed().toArray(Integer[]::new);
'๐ฏ Programming' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์คํ๋ง] JPA N+1 ๋ฌธ์ ํธ๋ฌ๋ธ ์ํ (2) | 2025.03.27 |
---|---|
[ISSUE] error: connect econnrefused (1) | 2025.02.17 |
[Github Action] build ์ค๋ฅ ์์ธ ๋ ์์ธํ ๋ณด๋ ๋ฒ (0) | 2024.10.08 |
[ISSUE] boolean์์ is๊ฐ ์๋ต๋๋ ๋ฌธ์ (0) | 2024.09.06 |