Java : ストリームの基本 (Stream)

Tweet

ストリームは、ListやSet、配列などの各要素に対して、

• 変換
• 絞り込み(フィルタ)
• 重複の除外
• 並び替え

といった操作を便利に行うことができるAPIです。
そんなストリームの基本的な使い方を解説していきます。

対象読者：ラムダ式をある程度理解しているかた

もし不安のあるかたは「ラムダ式の基本」も参考にしていただけたら幸いです。

概要

ストリームの簡単なデータ遷移図です。
もととなる１つのソースからストリームを生成して、中間操作（いくらでも可能）して、最後に終端操作を行って結果を得ます。

コード例も見てみましょう。

final var values = List.of("a", "b", "b", "c", "c", "c");
System.out.println(values); // [a, b, b, c, c, c]

final List<String> result = values.stream()
        .distinct()
        .map(s -> s.toUpperCase())
        .collect(Collectors.toList());

System.out.println(result); // [A, B, C]

1. values.stream() : Listからストリームを生成して
2. distinct() : 重複を除外して
3. map(s -> s.toUpperCase()) : 要素の文字列を大文字に変換して
4. collect(Collectors.toList()) : ストリームからListを得ます。

要素に対する操作を順番につなげるように記述できます。
それぞれの操作は独立しています。

パイプライン処理をご存じのかたは、そのイメージが近いと思います。

同じことをストリームなしで記述してみましょう。

final var values = List.of("a", "b", "b", "c", "c", "c");
System.out.println(values); // [a, b, b, c, c, c]

final List<String> result = new ArrayList<>();
for (final var value : values) {
    final var upperCase = value.toUpperCase();
    if (!result.contains(upperCase)) {
        result.add(upperCase);
    }
}

System.out.println(result); // [A, B, C]

ループ処理と重複除外と文字列変換が、密接に関連してしまった印象です。(つまり可読性が少し悪い)

ストリームの代表的な操作一覧

ストリームでできる代表的な操作を簡単にご紹介します。

生成

final Stream<String> stream = List.of("a", "b", "c").stream();

final List<String> result = stream.collect(Collectors.toList());
System.out.println(result); // [a, b, c]

final String[] array = {"a", "b", "c"};
final Stream<String> stream = Arrays.stream(array);

final List<String> result = stream.collect(Collectors.toList());
System.out.println(result); // [a, b, c]

// 0～9のIntStreamを生成します。
final IntStream stream = IntStream.range(0, 10);

final int[] result = stream.toArray();
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
System.out.println(Arrays.toString(result));

final Stream<String> stream = Stream.of("a", "b", "c");

final List<String> result = stream.collect(Collectors.toList());
System.out.println(result); // [a, b, c]

中間操作

// 各要素の文字列を大文字に変換(map)します。
{
    final Stream<String> stream = Stream.of("a", "b", "c");

    final List<String> result = stream.map(
            s -> s.toUpperCase()).collect(Collectors.toList());
    System.out.println(result); // [A, B, C]
}

// 16進数表記の文字列をIntegerに変換します。
{
    final Stream<String> stream = Stream.of("0x01", "0x10", "0xff");

    final List<Integer> result = stream.map(
            s -> Integer.decode(s)).collect(Collectors.toList());
    System.out.println(result); // [1, 16, 255]
}

// 大文字のみを取り出します(filter)。
final Stream<String> stream = Stream.of("a", "B", "c", "D");

final List<String> result = stream.filter(
        s -> s.matches("[A-Z]")).collect(Collectors.toList());
System.out.println(result); // [B, D]

// 重複を除外(distinct)します。
final Stream<String> stream = Stream.of("a", "b", "b", "c", "c", "c");

final List<String> result = stream.distinct().collect(Collectors.toList());
System.out.println(result); // [a, b, c]

// 昇順で並び替え(sorted)します。
final Stream<String> stream = Stream.of("c", "d", "a", "b");

final List<String> result = stream.sorted().collect(Collectors.toList());
System.out.println(result); // [a, b, c, d]

// 0～99の先頭5件を操作します。
final IntStream stream = IntStream.range(0, 100);

final int[] result = stream.limit(5).toArray();
System.out.println(Arrays.toString(result)); // [0, 1, 2, 3, 4]

// 各要素をコンソールへ出力します。
final Stream<String> stream = Stream.of("a", "b", "c");

//peek : a
//peek : b
//peek : c
final var result = stream
        .peek(s -> System.out.println("peek : " + s))
        .collect(Collectors.toList());

System.out.println(result); // [a, b, c]

// 中間操作を並列に実行します。
System.out.println("main thread id : " + Thread.currentThread().getId());

final Stream<String> stream = Stream.of("a", "b", "c");

final List<String> result = stream.parallel().map(s -> {
    System.out.println("map thread id : " + Thread.currentThread().getId());
    return s.toUpperCase();
}).collect(Collectors.toList());

System.out.println(result);

// 結果
// ↓
//main thread id : 16
//map thread id : 16
//map thread id : 20
//map thread id : 19
//[A, B, C]

終端操作

// ストリームの結果としてListを得ます。
{
    final Stream<String> stream = Stream.of("a", "b", "c");

    final List<String> list = stream.collect(Collectors.toList());
    System.out.println(list); // [a, b, c]
}

// ストリームの結果としてSetを得ます。
{
    final Stream<String> stream = Stream.of("a", "b", "c");

    final Set<String> set = stream.collect(Collectors.toSet());
    System.out.println(set); // [a, b, c]

}

// ストリームの結果として連結した文字列を得ます。
{
    final Stream<String> stream = Stream.of("a", "b", "c");

    final String str = stream.collect(Collectors.joining(" : "));
    System.out.println(str); // "a : b : c"
}

final Stream<String> stream = Stream.of("a", "b", "c");

final List<String> list = stream.toList();
System.out.println(list); // [a, b, c]

// 各要素をコンソールへ出力します。
final Stream<String> stream = Stream.of("a", "b", "c");

//forEach : a
//forEach : b
//forEach : c
stream.forEach(s -> System.out.println("forEach : " + s));

// 各要素をコンソールへ出力します。
final Stream<String> stream = Stream.of("a", "b", "c");

//forEachOrdered : a
//forEachOrdered : b
//forEachOrdered : c
stream.parallel().forEachOrdered(
        s -> System.out.println("forEachOrdered : " + s));

守るべきルール (副作用を起こさない)

ストリームを使う上で１つルールを守る必要があります。

ストリームAPIで指定する関数型インタフェースは、オブジェクトとしてではなく、本当に単純な関数として使うようにしましょう。
具体的には、関数(メソッド)のパラメータ(引数)とローカル変数のみを使うようにします。

関数の外にある変数にアクセスしてはいけません。
(あと、変数ではありませんが、競合する可能性のあるファイルへの入出力もよくありません)

公式API仕様では、関数の外に影響を及ぼすことを 副作用(side effect) と表現しています。

関数型インタフェースのFunctionを例にしてみます。
Functionの関数(メソッド)はapplyです。

まずは問題のない例です。

final Function<String, String> mapper = new Function<>() {
    @Override
    public String apply(String s) {
        final var local = s.repeat(3);
        return local.toUpperCase();
    }
};

final var stream = Stream.of("a", "b", "c");
final var result = stream.map(mapper).collect(Collectors.toList());

System.out.println(result); // [AAA, BBB, CCC]

このようにapplyメソッドのスコープに閉じた実装をします。
使っている変数は、

• applyメソッドのパラメータである s
• applyメソッドのローカル変数である local

のみです。

次に問題のある例です。

final var outer = new ArrayList<String>();

final var mapper = new Function<String, String>() {
    int count;

    @Override
    public String apply(String s) {
        count++;
        outer.add(s);
        return s + " : count = " + count;
    }
};

２つのルール違反をしています。

• applayメソッドの外にあるouter変数にアクセス
• applayメソッドの外にあるcount変数にアクセス

フィールドのcountもNGなのでご注意ください。

ラムダ式を使えばフィールドは作れないので少し安全になります。
ただ、outerのようなfinalな変数にはアクセスできてしまいますが…

このルールを守らないと、ストリームの結果は予期しないものとなる可能性があります。

実際にどのような問題が起こるのか見てみましょう。

// ※問題のある例です。
final var result = new ArrayList<String>();

final var stream = Stream.of("a", "b", "c", "d");
stream.map(s -> s.toUpperCase()).forEach(s -> result.add(s));

System.out.println(result); // [A, B, C, D]

これは、一見問題なく動いているように見えます。
しかし、ストリームを並列実行すると問題が発生します。

// ※問題のある例です。
final var result = new ArrayList<String>();

final var stream = Stream.of("a", "b", "c", "d");
stream.parallel().map(s -> s.toUpperCase()).forEach(s -> result.add(s));

System.out.println(result); // [C, B, A, D] や [C, A, D] など

parallelメソッドで並列に実行します。

順番がばらばらになるのはもちろん、[C, A, D]とサイズが小さくなってしまうこともあります。
これはArrayListのresult変数に複数スレッドから同時にアクセスされて競合が発生しているためです。

副作用を起こさないように結果を得るにはcollectメソッドを使います。

final var stream = Stream.of("a", "b", "c", "d");
final List<String> result = stream.parallel().map(s -> s.toUpperCase()).collect(Collectors.toList());

System.out.println(result); // [A, B, C, D]

ストリームを使うときは、副作用を起こさないように気をつけましょう。

もし、どうしても関数の外の変数にアクセスしたい場合、それはストリームを使うべきではないかもしれません。
よく検討してみましょう。

補足

公式API仕様にSystem.out.printlnは通常無害との記述があるので、本記事でもいくつかの例として使用しています。

中間操作と終端操作

ストリームAPIの操作は、大きく分けて中間操作と終端操作があります。

中間操作はいくらでもつなげることができます。
終端操作は１度のみです。

終端操作を行ったストリームは使用済みとなり、もう１度操作しようとすると例外が発生します。

final var stream = Stream.of("a", "b", "c");

//forEach : A
//forEach : B
//forEach : C
stream.map(s -> s.toUpperCase()).forEach(s -> System.out.println("forEach : " + s));

// forEachは終端操作なので、さらに操作しようとすると例外が発生します。

// IllegalStateException: stream has already been operated upon or closed
final var result = stream.collect(Collectors.toList());

遅延処理

ストリームの中間操作は、終端操作が実行されるまで実行されません。
これを遅延処理といいます。(遅延評価とも)

var stream = Stream.of("a", "b", "c");

System.out.println("-- 中間操作 --");

stream = stream.map(s -> {
    System.out.println("map : " + s);
    return s.toUpperCase();
});

System.out.println("-- 終端操作 --");

final var result = stream.collect(Collectors.toList());
System.out.println("result : " + result);

// 結果
// ↓
//-- 中間操作 --
//-- 終端操作 --
//map : a
//map : b
//map : c
//result : [A, B, C]

このように、中間処理のmapはすぐには実行されません。
終端処理のcollectを実行したときに処理されます。

並列性

parallelメソッドを使うと、各操作が並列に実行されます。
前述した副作用を起こさないように操作を記述すれば、並列処理に対して安全です。

大量の要素があるストリームでは、並列処理することでパフォーマンス向上が見込めます。
面倒なスレッドの管理も不要なので、お手軽ですね。

System.out.println("main thread id : " + Thread.currentThread().getId());

final Stream<String> stream = Stream.of("a", "b", "c");

final List<String> result = stream.parallel().map(s -> {
    System.out.println("map thread id : " + Thread.currentThread().getId());
    return s.toUpperCase();
}).collect(Collectors.toList());

System.out.println(result);

// 結果
// ↓
//main thread id : 16
//map thread id : 16
//map thread id : 20
//map thread id : 19
//[A, B, C]

IOチャネルから生成したストリームはcloseが必要

StreamインタフェースはAutoCloseableを実装します。

ただし、公式API仕様にもあるように、IOチャネル以外はcloseする必要はありません。
IOチャネルから生成したストリームは必ずcloseしましょう。

closeにはtry-with-resources文を使うのがおすすめです。

// --- PowerShell ---
//PS R:\java-work> cat .\aaa.txt
//XXX
//YYY
//ZZZ

final var path = Path.of("R:", "java-work", "aaa.txt");

try (final var stream = Files.lines(path)) {
    final var result = stream.collect(Collectors.toList());
    System.out.println(result); // [XXX, YYY, ZZZ]
}

公式ドキュメントのリンク

java.util.streamパッケージの説明ページです。
ストリームAPIについてかなり詳しく解説されています。

本記事では解説しきれていないこともあるので、一読することをおすすめします。

関連記事

• Optionalの基本
• ラムダ式の基本
• メソッド参照の基本

• API 使用例
  • Stream(ストリーム)
  • Stream.Builder
  • BaseStream
  • Collectors
  • DoubleStream
  • IntStream