๐ฎ [Programmers] ์ฝ๋ฉํ ์คํธ ์ฐ์ต > ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ > ์ง์์ ํฉ
์ด ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ๋ค๋ฅธ ์ฌ๋์ ์ฝ๋๋ฅผ ๋ดค๋๋ฐ, stream์ ์ด์ฉํ ์ฝ๋์๋ค. ๊ทธ ์ฝ๋๋ฅผ ๋ณด๊ณ stream์ ๋ํด ์ ๋ฆฌํด๋๋ฉด ์ข์ ๊ฑฐ ๊ฐ์ ์ด ํฌ์คํ ์ด๋ค!
IntStream์ Java 8์์ ๋์
๋ Stream API์ ์ผ์ข
์ผ๋ก, intํ ์์ ํ์
์ ํนํ๋ ์คํธ๋ฆผ์
๋๋ค.
IntStream์ ์ ์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ์ํ ์คํธ๋ฆผ์ผ๋ก, ์ผ๋ฐ์ ์ธ Stream<Integer>๋ณด๋ค ๋ ํจ์จ์ ์ด๋ฉฐ ์ซ์์ ๊ด๋ จ๋ ๋ค์ํ ์ฐ์ฐ(ํํฐ๋ง, ๋งคํ, ์ง๊ณ ๋ฑ)์ ์ง์ํฉ๋๋ค.
ํนํ ๋ฐ๋ณต ์์ ์ด๋ ์ ์ ์ฐ์ฐ์์ ์ฌ์ฉํ๋ฉด ์ฝ๋๊ฐ ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋ ์ฑ์ด ๋์์ง๊ณ , Java 8 ์ด์์ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ์ตํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
IntStream.range(startInclusive, endExclusive)
startInclusive๋ถํฐ endExclusive๊น์ง ์ฐ์๋ ์ ์ ์คํธ๋ฆผ ์์ฑ (๋์ ํฌํจ๋์ง ์์).
IntStream.range(1, 5).forEach(System.out::println);
// ์ถ๋ ฅ: 1, 2, 3, 4
IntStream.rangeClosed(startInclusive, endInclusive)
startInclusive๋ถํฐ endInclusive๊น์ง ์ฐ์๋ ์ ์ ์คํธ๋ฆผ ์์ฑ (๋ ํฌํจ).
IntStream.rangeClosed(1, 5).forEach(System.out::println);
// ์ถ๋ ฅ: 1, 2, 3, 4, 5
int[] array = {1, 2, 3, 4, 5};
IntStream.of(array).forEach(System.out::println);
// ์ถ๋ ฅ: 1, 2, 3, 4, 5
generate ๋ฉ์๋๋ก ๋ฌดํ ์คํธ๋ฆผ ์์ฑ
ํน์ ๊ฐ์ ๊ณ์ ๋ฐ๋ณตํ๊ฑฐ๋, ์กฐ๊ฑด ์์ด ๊ฐ์ ์์ฑ.
IntStream.generate(() -> 1).limit(5).forEach(System.out::println);
// ์ถ๋ ฅ: 1, 1, 1, 1, 1
iterate ๋ฉ์๋๋ก ๋ฌดํ ์คํธ๋ฆผ ์์ฑ
์ด๊ธฐ๊ฐ๊ณผ ๋ฐ๋ณต ๊ท์น์ ์ค์ .
IntStream.iterate(0, n -> n + 2).limit(5).forEach(System.out::println);
// ์ถ๋ ฅ: 0, 2, 4, 6, 8
filter
์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์๋ง ๋จ๊น.
IntStream.range(1, 10)
.filter(x -> x % 2 == 0)
.forEach(System.out::println);
// ์ถ๋ ฅ: 2, 4, 6, 8
map
๊ฐ ์์๋ฅผ ๋ณํํ์ฌ ์๋ก์ด ์คํธ๋ฆผ ์์ฑ.
IntStream.range(1, 5)
.map(x -> x * x)
.forEach(System.out::println);
// ์ถ๋ ฅ: 1, 4, 9, 16
reduce
int sum = IntStream.range(1, 5)
.reduce(0, Integer::sum);
System.out.println(sum);
// ์ถ๋ ฅ: 10 (1 + 2 + 3 + 4)sum
int sum = IntStream.rangeClosed(1, 5).sum();
System.out.println(sum);
// ์ถ๋ ฅ: 15average
OptionalDouble ๋ฐํ.IntStream.rangeClosed(1, 5)
.average()
.ifPresent(System.out::println);
// ์ถ๋ ฅ: 3.0max, min
int max = IntStream.range(1, 10).max().orElseThrow();
int min = IntStream.range(1, 10).min().orElseThrow();
System.out.println("Max: " + max + ", Min: " + min);
// ์ถ๋ ฅ: Max: 9, Min: 1distinct
IntStream.of(1, 2, 2, 3, 4, 4, 5)
.distinct()
.forEach(System.out::println);
// ์ถ๋ ฅ: 1, 2, 3, 4, 5sorted
IntStream.of(5, 3, 1, 4, 2)
.sorted()
.forEach(System.out::println);
// ์ถ๋ ฅ: 1, 2, 3, 4, 5boxed
์์ ํ์
์คํธ๋ฆผ์ Stream<Integer>๋ก ๋ณํ.
IntStream.range(1, 5)
.boxed()
.map(x -> x + 10)
.forEach(System.out::println);
// ์ถ๋ ฅ: 11, 12, 13, 14
ํจ์จ์ฑ
IntStream์ ์์ ํ์
(int) ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ฑ/์ธ๋ฐ์ฑ ๋น์ฉ์ด ์์ด์ ์ฑ๋ฅ์ด ๋ ์ข๋ค.Stream<Integer>๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ ๋ฐ CPU ์์์ ์ ๊ฒ ์๋น.์ง์ฐ ์ฐ์ฐ
filter, map, sorted ๋ฑ)๋ ์ง์ฐ ์คํ๋๋ค. ์ฆ, ์ต์ข
์ฐ์ฐ(sum, forEach ๋ฑ)์ด ํธ์ถ๋ ๋ ์คํ.๋ณ๋ ฌ ์ฒ๋ฆฌ
.parallel()์ ์ฌ์ฉํ๋ฉด ๊ฐ๋จํ ๋ณ๋ ฌ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋ค.
int sum = IntStream.rangeClosed(1, 1000)
.parallel()
.sum();
System.out.println(sum);
// ์ถ๋ ฅ: 500500
IntStream์ int ํ์
์ ํนํ๋์ด ์์ผ๋ฏ๋ก ๋ค๋ฅธ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ค๋ฉด ์ถ๊ฐ ๋ณํ์ด ํ์ํ๋ค(mapToObj, boxed ๋ฑ).
์์ฝ
IntStream์ ์ ์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ์ํ ์คํธ๋ฆผ์ผ๋ก, ๋ค์ํ ์ฐ์ฐ(ํํฐ๋ง, ๋งคํ, ์ง๊ณ ๋ฑ)์ ์ง์ํฉ๋๋ค.
ํนํ ๋ฐ๋ณต ์์
์ด๋ ์ ์ ์ฐ์ฐ์์ ์ฌ์ฉํ๋ฉด ์ฝ๋๊ฐ ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋
์ฑ์ด ๋์์ง๋๋ค.
Java 8 ์ด์์ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ์ตํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
[Programmers] ์ฝ๋ฉํ ์คํธ ์ฐ์ต > ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ > ์ง์์ ํฉ
import java.util.stream.IntStream;
class Solution {
public int solution(int n) {
return IntStream.rangeClosed(0, n)
.filter(e -> e % 2 == 0)
.sum();
}
}
import java.util.stream.IntStream; // IntStream ์ฌ์ฉ์ ์ํด ์คํธ๋ฆผ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ํฌํธ
๐ก
IntStream์ Java์ Stream API ์ค ์ ์์ ํนํ๋ ์คํธ๋ฆผ ํด๋์ค์ด๋ค.
โ๏ธ rangeClosed์ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์ฐ์๋ ์ ์ ์คํธ๋ฆผ์ ์์ฑํ๋ค.
โ๏ธ ์คํธ๋ฆผ์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฐ๋ ฅํ๊ณ ๊ฐ๊ฒฐํ ๋ฐฉ์์ผ๋ก, ํํฐ๋ง, ๋งคํ, ์ง๊ณ ๋ฑ์ ์์ ์ ์ง์ํ๋ค.
class Solution {
public int solution(int n) {
return IntStream.rangeClosed(0, n) // 0๋ถํฐ n๊น์ง ํฌํจํ๋ ์คํธ๋ฆผ ์์ฑ
.filter(e -> e % 2 == 0) // ์ง์๋ง ํํฐ๋ง (e % 2 == 0์ธ ์์๋ง ํต๊ณผ)
.sum(); // ๋จ์ ์์๋ฅผ ๋ชจ๋ ๋ํ ๊ฐ์ ๋ฐํ
}
}
1. IntStream.rangeClosed(0, n)
0๋ถํฐ n๊น์ง์ ์ฐ์๋ ์ ์๋ฅผ ํฌํจํ๋ ์คํธ๋ฆผ์ ์์ฑํ๋ค.
์๋ฅผ ๋ค์ด, n = 5๋ผ๋ฉด ์คํธ๋ฆผ์ [0, 1, 2, 3, 4, 5]๋ก ์์ฑ๋๋ค.
2. .filter(e -> e % 2 == 0)
๋๋ค์ e -> e % 2 == 0:
e๋ก ๋ฐ์์ e % 2 == 0 ์กฐ๊ฑด์ด true์ธ ๊ฒฝ์ฐ๋ง ํต๊ณผ์ํจ๋ค.๊ฒฐ๊ณผ์ ์ผ๋ก ์ง์๋ง ๋จ๊ธด๋ค.
[0, 1, 2, 3, 4, 5]๋ผ๋ฉด ํํฐ ๊ฒฐ๊ณผ๋ [0, 2, 4]์ด๋ค.3. .sum()
์คํธ๋ฆผ์ ๋จ์ ์๋ ๋ชจ๋ ์์๋ฅผ ๋ํ๋ค.
์๋ฅผ ๋ค์ด, [0, 2, 4]์ด๋ผ๋ฉด ๊ฒฐ๊ณผ๋ 0 + 2 + 4 = 6์ ๋๋ค.
4. ๋ฐํ๊ฐ