Streamの終端処理

void forEach(Consumer<? super T> action)

要素を順に処理する ※forEachメソッドは並列ストリームでは順序を保証しない為、順序を保証したいならforEachOrderedメソッドを使うこと

Stream.of("beckham", "zidane", "ronald").forEach(v -> System.out.println(v));

Optional findFirst()

最初の要素をOptionalで記述する ※並列ストリームで何でもよいので1件だけ取得するのであればfindAnyメソッドを使った方がパフォーマンスが良い

Optional<String> optional = Stream.of("beckham", "zidane", "ronald").findFirst();
System.out.println(optional.get());

boolean allMatch(Predicate<? super T> predicate)

boolean anyMatch(Predicate<? super T> predicate)

boolean noneMatch(Predicate<? super T> predicate)

それぞれ条件を満たす要素の存在をチェックする

System.out.println(IntStream.of(1, 3, 2).allMatch(v -> v >= 2)); // false ※全ての要素が条件を満たすか？
System.out.println(IntStream.of(1, 3, 2).anyMatch(v -> v >= 2)); // true ※いずれかの要素が条件を満たすか？
System.out.println(IntStream.of(1, 3, 2).noneMatch(v -> v >= 4)); // true ※条件を満たす要素が存在しないか？

Object toArray()

A toArray(IntFunction<A[]> generator)

要素の配列を返却する

int[] array = IntStream.of(1, 3, 2).toArray();
Person[] men = people.stream().toArray(Person[]::new);

R collect(Supplier supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

このストリームの要素に対して可変リダクション操作を実行する。 Collectionの入れ替えなんかで利用する。

List<String> list = Stream.of("beckham", "zidane", "ronald").collect(Collectors.toList());
Set<String> set = Stream.of("beckham", "zidane", "ronald").collect(Collectors.toSet());
Map<String, String> map = Stream.of("beckham", "zidane", "ronald").collect(Collectors.toMap(String::toString, String::toString));

Optional min(Comparator<? super T> comparator)

Optional max(Comparator<? super T> comparator)

指定されたComparatorによる順序に従って、最小／最大の要素を取得する

Optional<Integer> min = List.of(3, 8, 7, 10, 5, 1, 9, 2, 4, 6).stream().min(Comparator.naturalOrder());
Optional<Integer> max = List.of(3, 8, 7, 10, 5, 1, 9, 2, 4, 6).stream().max(Comparator.naturalOrder());

long count()

要素の個数を取得する

long count = List.of(3, 8, 7, 10, 5, 1, 9, 2, 4, 6).stream().count();

int sum()

OptionalDouble average()

合計／平均を求める

int sum = IntStream.of(3, 8, 7, 10, 5, 1, 9, 2, 4, 6).sum();
OptionalDouble average = IntStream.of(3, 8, 7, 10, 5, 1, 9, 2, 4, 6).average();

Optional reduce(BinaryOperator accumulator)

T reduce(T identity, BinaryOperator accumulator)

U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator combiner)

リダクションを実行する

Optional<String> optional = Stream.of("beckham", "zidane", "ronald").reduce((result, str) -> result + "/" + str);

// 初期値あり、非nullなので戻り値はOptionalではない
String reduce = Stream.of("beckham", "zidane", "ronald").reduce("figo", (result, str) -> result + "/" + str);

// Streamの型と最終結果の型が異なる場合に使用する
Integer reduce = Stream.of("beckham", "zidane", "ronald").parallel().reduce(
        0, // 初期値
        // 個々の要素を処理してまとめる
        (result, value) -> { 
            System.out.println("##################");
            System.out.println(result);
            System.out.println(value);
            return result += value.length();
        }, 
        // 並列処理の結果をまとめる
        (result1, result2) -> {
            System.out.println(result1);
            System.out.println(result2);
            return result1 + result2;
        });

R collect(Supplier supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

<R,A> R collect(Collector<? super T,A,R> collector)

要素をコレクションにまとめる

List<String> result = Stream.of("beckham", "zidane", "ronald")
    .collect(
            ArrayList<String>::new, 
            (list, str) -> list.add(str),
            (list1, list2) -> list1.addAll(list2));

List<String> result = Stream.of("beckham", "zidane", "ronald")
    .collect(
        Collector.of(   
            ArrayList<String>::new,
            ArrayList<String>::add,
            (list1, list2) -> {
                list1.addAll(list2);
                return list1;
            },
            Collector.Characteristics.IDENTITY_FINISH
        )
    );

String collect = Stream.of("beckham", "zidane", "ronald").collect(Collectors.joining(",", "<", ">"));
System.out.println(collect); // <beckham,zidane,ronald>