Stream

중간 연산

연산	형식	반환형식	연산의 인수	함수 디스크립터
filter	중간 연산	Stream<T>	Predicate<T>	T -> boolean
map	중간 연산	Stream<T>	Function<T, R>	T -> R
limit	중간 연산	Stream<T>
sorted	중간 연산	Stream<T>	Comparator<T>	(T, T) -> int
distinct	중간 연산	Stream<T>

최종 연산

연산	형식	목적
forEach	최종 연산	스트림의 각 요소를 소비하면서 람다를 적용한다. void를 반환
count	최종 연산	스트림의 요소 개수를 반환한다. long을 반환
collect	최종 연산	스트림을 리듀스해서 리스트, 맵, 정수 형식의 컬렉션을 만든다.

---

필터링과 슬라이싱

distinct

        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream()
            .filter(i -> i%2==0)
            .distinct()
            .forEach(System.out::println);

limit

        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4, 6);
        numbers.stream()
            .filter(i -> i%2==0)
            .distinct()
            .limit(2)
            .forEach(System.out::println);

skip

        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4, 6);
        numbers.stream()
            .filter(i -> i%2==0)
            .distinct()
            .skip(1)
            .forEach(System.out::println);

---

매핑

map

        List<Integer> nameSize = productList.stream()
                                    .map(Product::getName)
                                    .map(String::length)
                                    .collect(Collectors.toList());

Arrays.stream

       String strings[] = new String[]{"hello", "world"};
        Stream<String> strStream = Arrays.stream(strings);

잘못된 예

        List<String> charList = strStream
                .map(word -> word.split(""))
                .map(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());

Stream<String[]>

Stream<Stream<String>>

이 되기때문에 컴파일 에러가 난다.

flatMap : 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다.

        List<String> charList2 = strStream
                .map(word -> word.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());

---

검색과 매칭

쇼트서킷 기법을 이용함

anyMatch

        if(productList.stream().anyMatch(p -> p.name.equals("TV"))) {
            System.out.println("I have TV");
        }

allMatch

        if(productList.stream().allMatch(p -> p.price>300000)) {
            System.out.println("I haven't cheap product");
        }

noneMatch

        if(productList.stream().noneMatch(p -> p.price>300000)) {
            System.out.println("I have cheap product");
        }

findAny

        Optional<Product> product = productList.stream()
                .filter(p -> p.price>1000000)
                .findAny();

findFirst

        Optional<Product> product = productList.stream()
                .filter(p -> p.price>1000000)
                .findFirst();

---

리듀싱

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        int sum = numbers.stream().reduce(0, (a, b) -> a+b);

---

숫자형 스트림

IntStream에 경우 사용할 수 있는 메서드

sum, max, min, average 등

매핑

        int sumPrice = productList.stream()
                .mapToInt(Product::getPrice)
                .sum();

객체스트림으로 복원

        Stream<Integer> priceStream = productList.stream()
                .mapToInt(Product::getPrice)
                .boxed();

OptionalInt

        OptionalInt maxPrice = productList.stream()
                .mapToInt(Product::getPrice)
                .max();
        System.out.println(maxPrice.orElse(0));

range

        int oddSum = IntStream.range(0, 11)
                .filter(i -> i%2==1)
                .sum();

rangeClosed

        int evenSum = IntStream.rangeClosed(1, 10)
                .filter(i -> i%2==0)
                .sum();

---

스트림 만들기

값으로 스트림 만들기

        Stream<String> strStream = Stream.of("Hello", "World");

배열로 스트림 만들기

        String strings[] = new String[]{"Hello", "World"};
        Stream<String> strStream = Arrays.stream(strings);

파일로 스트림 만들기

        try {
            Stream<String> lines = Files.lines(Paths.get("example.txt"), Charset.defaultCharset());
            lines.flatMap(line -> Arrays.stream(line.split(" ")))
                .forEach(System.out::println);
        } catch(IOException e) {
            e.printStackTrace();
        }

함수로 무한 스트림 만들기

iterate

        Stream.iterate(1, i->i+1)
            .filter(i -> i%2==0)
            .limit(10)
            .forEach(System.out::println);

generate : Supplier를 통해 인수를 받는다

        Stream.generate(Math::random)
            .map(d -> d*44+1)
            .mapToInt(Double::intValue)
            .distinct()
            .limit(6)
            .forEach(System.out::println);