์ด์ ์๊ฐ์๋ ์คํธ๋ฆผ์ด ์ด๋ ํ ๊ธฐ์ ์ด๊ณ ์ด๋ ํ ๋์ ์ฐ์ด๋ฉฐ ์ด๋ค ๋ฐฉ์๊ณผ ๊ณผ์ ์ ๊ฑฐ์ณ ์ฌ์ฉ๋๋์ง ์์๋ณด์์ต๋๋ค!
์ด๋ฒ ์๊ฐ์๋ ์ด๋ฌํ "์คํธ๋ฆผ์ ์์ฑํ๋ ๋ค์ํ ๋ฐฉ๋ฒ" ์ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค!
String[] arr = new String[] {"tomato", "banana", "watermelon"};
Stream<String> streamWasArray = Arrays.stream(arr);
Stream<String> streamWasArray2 = Arrays.stream(arr, 1, 2);
streamWasArray : "tomato", "banana", "watermelon"
streamWasArray2 : "banana", "watermelon"
Arrays ํด๋์ค์ stream ๋ฉ์๋๋ ๋ฐฐ์ด์ ํตํด ์คํธ๋ฆผ์ ์์ฑํด์ฃผ๋๋ฐ์.
๋ค์๊ณผ๊ฐ์ ๋๊ฐ์ง ์ฌ์ฉ๋ฒ์ผ๋ก ๋๋ฉ๋๋ค!
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream(); //stream : "a", "b", "c"
์ปฌ๋ ์ ์ ์คํธ๋ฆผ์ผ๋ก ๋ฐ๊พธ๋ ๋ฐฉ๋ฒ์ ๋จ์ํฉ๋๋ค. Collection ์ ๋ด์ฅ๋ stream ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค!
public Stream<T> streamOf(List<T> list) {
if(list == null || list.isEmpty()) return Stream.empty(); // stream :
else return list.stream();
}
๋ค์๊ณผ๊ฐ์ ์ํฉ์์, null ์ ๋ฐํํ ๊ฒฝ์ฐ, NullPointerException ๊ฐ์ ์ญ๊ฒจ์ด๊ฒ๋ค์ ๋ง๋ ์๋ ์๊ฒ ์ฃ ! ๊ทธ๋์ Stream ์์ Stream.empty() ๋ผ๋ ๋ฉ์๋๋ฅผ ํตํด ๋น ์คํธ๋ฆผ์ ์ ๊ณตํ๊ณ ์์ต๋๋ค.
Stream<String> builderStream = Stream.<String>builder()
.add("java").add("python").add("c++").add("html is not programming lang")
.build(); // builderStream : "java", "python", "c++", "html is not programming lang"
html ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๊ฐ ์๋๋๋ค
Stream ์ builder ํจํด์ ํตํด ์ง์ ์์ฑํ ์ ์์ต๋๋ค.
Stream<String> generateStream = Stream.generate(() -> "looooop").limit(5)
//generateStream : "looooop", "looooop", "looooop", "looooop", "looooop"
generate ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด Supplier<T> ๋ผ๋ ํจ์ํ ์ธํฐํ์ด์ค๋ฅผ ํตํ ๋๋ค๋ก ๊ฐ์ ๋ฃ์ ์ ์์ต๋๋ค. ์ฆ, ๋๋ค์์ ๋ฆฌํดํ๋ ๊ฐ์ด Stream ์ ์ธ์๋ก ๋ค์ด๊ฐ๋๋ค!
๋ค๋ง, generate ํจ์๋ก๋ ์ธ์๋ฅผ ๋ช๊ฐ ๋ฃ์๊ฒ์ธ์ง ์ ์ ์์ผ๋ฏ๋ก, generate() ๊ฐ ๋ฐํํ๋ stream ์ limit ํจ์๋ก ๋๋ค์์ ์ด ๋ช๋ฒ ์คํ์์ผ ์ธ์๋ก ๋ฃ์๊ฒ์ธ์ง๋ฅผ ์ ํ์ฌ์ผํฉ๋๋ค!
Stream<Integer> iteratedStream = Stream.iterate(10, n -> n - 2).limit(5);
//iteratedStream = 10, 8, 6, 4, 2
list(range(10,20,2)).stream()
stream.iterate ๋ฅผ ํ์ฉํ๋ฉด ์ด๊ธฐ๊ฐ๊ณผ, ์ด์ ์ธ์๊ฐ์ ํตํด ์คํธ๋ฆผ์ ๋ค์ด๊ฐ ์์๋ฅผ ๋ง๋ญ๋๋ค.
์ฆ ์ด๊ธฐ๊ฐ์ด n์ผ๋,
๋ผ๋ ๋ก์ง์ผ๋ก ์คํ๋๋๊ฒ์ด์ฃ !
Stream<Integer> ๋ Stream<String> ๊ฐ์ด ์ ๋๋ฆญ์ ์๋ง ์ฌ์ฉํ๋ค๋ฉด ๊ธฐ๋ณธํ์ ๋ํ ์คํธ๋ฆผ์ผ๋ก ๊ตฌํํ ์ ์์ง๋ง, ๊ธฐ๋ณธํ์ ์ ๋ํ ๋์ฑ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ๋ค์ ์ง์ํ๋ ๋๋ค๋ฅธ ํด๋์ค๋ค์ด ์์ต๋๋ค!
IntStream intStream = IntStream.range(1, 7); //intStream = 1, 2, 3, 4, 5, 6
LongStream longStream = LongStream.rangeClosed(1, 7); //longStream = 1, 2, 3, 4, 5, 6, 7
range : ์์์ธ๋ฑ์ค์ ์ข
๋ฃ์ธ๋ฑ์ค๋ฅผ ๋ฐ์ ์์์ธ๋ฑ์ค๋ถํฐ ์ข
๋ฃ์ธ๋ฑ์ค ์ด์ ์์๊น์ง์ ์์๋ก ์คํธ๋ฆผ์ ๋ง๋ญ๋๋ค.
rangeClosed : ์ฃผ ์ฌ์ฉ๋ฒ์ range ์ ๊ฐ์ผ๋, rangeClosed ๋ ์ข
๋ฃ์ธ๋ฑ์ค ๋ํ ํฌํจํ์ฌ ์คํธ๋ฆผ์ ๋ง๋ญ๋๋ค.
Stream<String> fileStream = Files.lines(
Paths.get("stream.txt"),
StandardCharsets.UTF_8)
);
Stream<Integer> boxedIntStream = IntStream.range(1, 5).boxed();
์ ์ ์ ์์ ์๋ง์ ๋ฐฉ๋ฒ์ผ๋ก ์คํธ๋ฆผ์ ์์ฑํ๋ค๋ฉด, ์ฌ๋ฌ๋ถ์ ์ฝ๋๋ ๋์ฑ ๋์ ๊ฐ๋ ์ฑ์ ๋์ธ ์ ์์ต๋๋ค! ์๋ฅผ๋ค์ด, 1๋ถํฐ 100๊น์ง์ ๋ชจ๋ ์์ฐ์๊ฐ์๋ ๋ฆฌ์คํธ๊ฐ ํ์ํ๋ค๋ฉด?
IntStream.rangeClosed(1, 100).boxed().collect(Collectors.toList());
//์ถํ ๋ฐฐ์ธ collect(Collectors.toList()) ๋ ์คํธ๋ฆผ์ List ์ ํํ๋ก ๋ณํํด์ฃผ๋ ๋ฉ์๋์
๋๋ค!
for ๋ฌธ์ผ๋ก ํ๋ค๋ฉด ์ ์ด๋ 3์ค์ด ๋์์ ๋ฌธ์ฅ์ด, ํ๋์ ๋ฌธ์ฅ์ผ๋ก ํด๊ฒฐ์ด ๋์์ต๋๋ค!
์ด๋ ๊ฒ ํธํ ์คํธ๋ฆผ! ๊ผญ ์จ์ฃผ์ค๊บผ์ฃ ? ๐
๊ทธ๋ผ ๋ค์์๊ฐ์ ์คํธ๋ฆผ์ ๊ฐ๊ณต๋ฒ์ผ๋ก ๋ค์ ์ฐพ์๋ต๊ฒ ์ต๋๋ค!!
๋ชจ๋ ๊ฑด๊ฐ์กฐ์ฌํ๊ณ ๋ค์์ ๋ง๋์~!!
[๋๋ค์] ๋๋ค์ ์ฌ์ฉ๋ฒ ๋ฐ ์์ (0) | 2023.04.12 |
---|---|
[์คํธ๋ฆผ]์คํธ๋ฆผ๋ถ์๊ธฐ (0) | 2023.04.12 |
[๋ฆฌ๋] ๋ฆฌ๋ ํด๋์ค (0) | 2023.04.12 |
[์คํธ๋ฆผ] ์คํธ๋ฆผ์ ๋ํ ์๋ฆฌ์ฆ. 5๊ฐ ๋ฐ๋ผ์ ๊ณต๋ถ (0) | 2023.04.12 |
[์คํธ๋ฆผ] ์ฐ์ต๋ฌธ์ (0) | 2023.04.12 |
๋๊ธ ์์ญ