StreamApiとforeachどっちを使ったほうがいい？

Question

下記のようにリストのリストを作成して、最後に一括して要素(例：999)を追加する処理です

    public static void main(String args[]) {
        ArrayList<ArrayList<Integer>> data = new ArrayList<ArrayList<Integer>>();

        for (int i=0; i<=3; i++) {
            ArrayList<Integer> element = new ArrayList<Integer>();
            element.add(i*1);
            element.add(i*2);
            element.add(i*3);

            data.add(element);
        }

        data.forEach(e->e.add(999));
        System.out.println(data);
    }

結果

[[0, 0, 0, 999], [1, 2, 3, 999], [2, 4, 6, 999], [3, 6, 9, 999]]

ただ、いろいろ調べていく過程で

data.stream().map(e->e.add(999));

のように、stream apiを使う書き方もありました。
ただ、こちらの書き方では、ArrayList<ArrayList<Integer>>へキャストすることができなかったので挫折しました。

【質問】
① stream api と foreachの違いはなんでしょうか？foreachではdataが書き換わってしまうという事ぐらいでしょうか？(stream api は新しいcollectionに対しての操作という認識）
② 上記のプログラムのように foreachで処理することに問題はあるでしょうか？
③ stream apiを使うとしたら、どのように元のListにキャストするのでしょうか？

よろしくお願いいたします。

Answer 1

① stream api と foreachの違いはなんでしょうか？foreachではdataが書き換わってしまうという事ぐらいでしょうか？(stream api は新しいcollectionに対しての操作という認識）

凄く雑な言い方をするなら、
forEachメソッドは、拡張for文を使って記述するコレクションの要素への繰り返し操作を、
「for文の中身だけ」記述するやり方です。
for文の中身を記述するための型としてConsumerが定義されています。

一方Stream APIは、ベルトコンベアーか何かを使った流れ作業のベースを作り、
作業に必要なものを組み合わせて工場を作るようなイメージです。

forEachは各要素に逐次処理を行うだけですが、streamの場合はフィルタを掛けたり要素を変換したりといったことが比較的直観的に書けます。

両者ともに元のdataを書き換えることはありません。ただし、今回のように中身がArrayListのような可変オブジェクトである場合は、それが変更されることはありえます。

② 上記のプログラムのように foreachで処理することに問題はあるでしょうか？

全く問題ありません。先述の通り拡張for文でやってることと何ら変わりありません。

③ stream apiを使うとしたら、どのように元のListにキャストするのでしょうか？

「キャスト」という語を使うのは適切ではないです。先述の通りStreamはベルトコンベアーでの作業をしているような状態で、Streamそれ自体はコレクションではありません。最終的に適切な「終端操作」を行うことで結果を出します。
これの場合は、collectというメソッドを使ってコレクションにまとめます。

Answer 2

他の回答者とほぼ同じ内容ですがポストします。

準備

dataの初期化部分です。誰が書いてもあまり変わりません。for(...)ループでも同じ事ができます。

List<List<Integer>> data = null, data2 = null;
Supplier<List<List<Integer>>> supplier = 
  () -> IntStream.rangeClosed(0,3)
                 .mapToObj(k -> Arrays.asList(1*k,2*k,3*k))
                 .map(ArrayList::new) // to mutable list
                 .collect(Collectors.toList());
data = supplier.get();

forEach

① stream api と foreachの違いはなんでしょうか？

forEach()はCollectionとStreamの両方にあります。どちらも引数にConsumerを取ります。違いはThe Difference Between Collection.stream().forEach() and Collection.forEach()に書かれているとおり、Collectionが内部的にIteratorを使用するのに対してStreamはListを順にトラバースします。Iteratorを書き換えると処理順が変わります。この例でその必要はなさそうです。

data.forEach(e->e.add(999));
data.stream().forEach(e->e.add(999));

foreachではdataが書き換わってしまうという事ぐらいでしょうか？(stream api は新しいcollectionに対しての操作という認識）

data.stream().forEach()は元のデータを書き換える副作用があります(新しい出力を作らず終端処理で自己更新する)。(*swordoneさんのdata.forEach()は副作用ではないという意見に同意。以後、Stream処理が入力を汚すという意味で「副作用」を使います)

map/peek

さらに副作用のある例を2つ示します。map()は戻り値を返す必要があります。peek()は戻り値なしです。

data.stream().map(e -> {e.add(999);return e;}).collect(Collectors.toList());
data.stream().peek(e -> e.add(999)).collect(Collectors.toList());

③ stream apiを使うとしたら、どのように元のListにキャストするのでしょうか？

すでに(List<Integer>)のStreamになっているのでキャストできません。.collect(Collectors.toList())で、新しく外側のListを作ってもとの中身を格納します。

すべてを作り直す

中身をすべてコピーして新しく作るやり方です。入力はそのまま残り、副作用はありません。この方法だとdataを作る時にArrayList::newが不要になります。

data.stream()
    .map(e -> Stream.concat(e.stream(),Stream.of(999)).collect(Collectors.toList()))
    .collect(Collectors.toList());

② 上記のプログラムのように foreachで処理することに問題はあるでしょうか？

• Stream/Collectionは、どちらも副作用がある
• Streamは、filter/mapなどのメソッドチェーンが使えるので、データを加工するならStreamを使う
• Collectionは、Iteratorを書き換えて、処理の順番を変えることができる

Streamの利用

Streamhは並行処理で利用することがあり、副作用が起きないようにimmutableなコレクションを扱うほうがよい。また、immutableにしておけば、誤ってコレクションを更新しても例外が発生する。

Comments

[xebme]

修正しました。Stream処理が入力を汚すという意味で「副作用」を使う。以下は修正漏れ。
修正前：Stream/Collectionは、どちらも副作用がある
修正後：Streamは副作用がある

Answer 3

③ stream apiを使うとしたら、どのように元のListにキャストするのでしょうか？

dataの型を ArrayList<ArrayList<Integer>> にすることに拘るなら。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

class Main {
    public static void main(String args[]) {
        ArrayList<ArrayList<Integer>> data = IntStream.rangeClosed(1, 3)
            .mapToObj(i ->
                new ArrayList<>(List.of(i*1, i*2, i*3, 999))
            )
            .collect(Collectors.toCollection(ArrayList::new))
        ;

        System.out.println(data);
    }
}

---

① stream api と foreachの違いはなんでしょうか？foreachではdataが書き換わってしまうという事ぐらいでしょうか？(stream api は新しいcollectionに対しての操作という認識）

② 上記のプログラムのように foreachで処理することに問題はあるでしょうか？

修正： 論拠に乏しい記述であった為、修正します。詳細はコメントをご覧下さい。
Stream API にせよ List#forEach にせよ、副作用のある処理を書くには向かないように思います。
もちろん可能ではあるのですが、コードを読むときに少し引っ掛かりがあります。

Stream API は、副作用のある処理を書くのには向きません。
純朴なfor文で書いた方が素直に読めるのならそれが正解でしょう。

import java.util.ArrayList;
import java.util.List;

class Main {
    public static void main(String args[]) {
        ArrayList<ArrayList<Integer>> data = new ArrayList<>();
        for(int i = 1; i <= 3; ++i) {
            data.add(
                new ArrayList<>(List.of(i*1, i*2, i*3, 999))
            );
        }
        
        System.out.println(data);
    }
}

あるいは

for(var row: data) {
    row.add(999);
}

System.out.println(data);

Comments

[swordone]

Iterator#forEachの引数Consumerには、Streamで使うときのようなステートレス性は要求されていないため、forEachの場合は問題ないかと思います。本質的に拡張for文を使うのと何ら変わりないですから。

[LouiS0616]

確かにリファレンスを見ても私の主張に沿う記述はありませんでした。
それどころか『Consumerは他のほとんどの関数型インタフェースと異なり、副作用を介して動作することを期待されます。』と真逆のことが書いてあります。 (https://docs.oracle.com/javase/jp/13/docs/api/java.base/java/util/function/Consumer.html)

誤解を生まないよう回答に少し追記をしておきます。
ご指摘ありがとうございます。

[xebme]

参考になりました。質問のforEachにフォーカスする場合はということで納得しました。
Cosumerを純粋関数型処理からみてどうか。Consumerを畳み込みの出力用バッファに適用するなら関数型処理全体では純粋性を保てるので問題ないでしょう。関数型処理でConsumerに限らず入力を汚すのならやはり「副作用」ですね。

Answer 4

③ stream apiを使うとしたら、どのように元のListにキャストするのでしょうか？

ひとつの例です。

  public static void main(String args[]) {
    final List<ArrayList<Integer>> data =
        IntStream.rangeClosed(0, 3)
            .mapToObj(i ->
                IntStream.rangeClosed(1, 3)
                    .mapToObj(num -> Integer.valueOf(i * num))
                    .collect(Collectors.toList()
                    )
            )
            .map(ArrayList::new)
            .collect(Collectors.toList());
    System.out.println(data);

    data.forEach(it -> it.add(999));
    System.out.println(data);
  }

① stream api と foreachの違いはなんでしょうか？foreachではdataが書き換わってしまうという事ぐらいでしょうか？(stream api は新しいcollectionに対しての操作という認識）

data.forEach(it -> it.add(999));は、data.stream().forEach(it -> it.add(999));の短縮形|省略形だと捉えてみてはどうでしょうか？forEach()メソッドもStreamAPIの一部だ、と。ただ、forEach()メソッドの中身をみると実際の実装は違うようですけれど。

② 上記のプログラムのように foreachで処理することに問題はあるでしょうか？

たとえば、StreamAPIを使うとparallel()を挟むだけで簡単に並列処理ができたりしますね(この程度の処理ではむしろ効率悪くなりますけど)。

    final List<ArrayList<Integer>> data =
        IntStream.rangeClosed(0, 3)
            .parallel()
            .mapToObj(i ->

---

余談ですが、StreamAPIを使い始めて、collectとか使わなくちゃいけなくて、なんかめんどうくさいなぁ、とおもいはじめてKotlinをみると、ラクそうにみえてくるとおもいます。

  fun main(args: Array<String>) {
    val data: List<MutableList<Int>> =
        (0..3).map { i ->
          (1..3).map { num -> num * i }.toMutableList()
        }
    println(data)

    data.forEach { it.add(999) }
    println(data)
  }