Java 8：ラムダの反復をカウントするための好ましい方法は？

私はよく同じ問題に直面します。ラムダの外部で使用するために、ラムダの実行をカウントする必要があります。例えば：

myStream.stream().filter(...).forEach(item->{ ... ; runCount++);
System.out.println("The lambda ran "+runCount+"times");

問題は、runCountがfinalである必要があるため、intにすることはできないということです。不変であるため、整数にすることはできません。クラスレベルの変数（つまりフィールド）にすることもできますが、このコードブロックでのみ必要になります。私はさまざまな方法があることを知っています、私はこれのためにあなたの好ましい解決策は何ですか？AtomicIntegerまたは配列参照または他の方法を使用していますか？

議論のために、例を少し再フォーマットしましょう。

long runCount = 0L;
myStream.stream()
    .filter(...)
    .forEach(item -> { 
        foo();
        bar();
        runCount++; // doesn't work
    });
System.out.println("The lambda ran " + runCount + " times");

あなたがいる場合、実際にラムダ内からカウンタをインクリメントする必要があり、そうするための典型的な方法は、カウンタを作るANにあるAtomicIntegerか、AtomicLongそして、それにインクリメント方法のいずれかを呼び出します。

単一の要素intまたはlong配列を使用することもできますが、ストリームが並行して実行される場合、競合状態が発生します。

ただし、ストリームがで終わることに注意してくださいforEach。これは、戻り値がないことを意味します。をに変更するforEachとpeek、アイテムが通過し、カウントされます。

long runCount = myStream.stream()
    .filter(...)
    .peek(item -> { 
        foo();
        bar();
    })
    .count();
System.out.println("The lambda ran " + runCount + " times");

これはやや良いですが、それでも少し奇妙です。その理由は、ということですforEachし、peek唯一の副作用を経由して自分の仕事を行うことができます。Java 8の新しい機能スタイルは、副作用を回避することです。カウンターの増分をcountストリームの操作に抽出することで、その少しを実行しました。その他の典型的な副作用は、コレクションへのアイテムの追加です。通常、これらはコレクターを使用して置き換えることができます。しかし、あなたが実際にどのような仕事をしようとしているのかを知らなければ、これ以上具体的なことを提案することはできません。

面倒なAtomicIntegerを同期する代わりに、代わりに整数配列を使用できます。配列への参照に別の配列が割り当てられない限り（そしてそれがポイントです）、フィールドの値は任意に変更できますが、最終的な変数として使用できます。

    int[] iarr = {0}; // final not neccessary here if no other array is assigned
    stringList.forEach(item -> {
            iarr[0]++;
            // iarr = {1}; Error if iarr gets other array assigned
    });

AtomicInteger runCount = 0L;
long runCount = myStream.stream()
    .filter(...)
    .peek(item -> { 
        foo();
        bar();
        runCount.incrementAndGet();
    });
System.out.println("The lambda ran " + runCount.incrementAndGet() + "times");

あなたはいけません、あなたが使用するために本当に良い理由がない限り、あなたは物事を使用してはならない、のAtomicIntegerを使用します。また、AtomicIntegerを使用する理由は、同時アクセスなどのみを許可するためである可能性があります。

あなたの問題になると;

ホルダーは、ラムダ内で保持およびインクリメントするために使用できます。そして、runCount.valueを呼び出すことで取得できます

Holder<Integer> runCount = new Holder<>(0);

myStream.stream()
    .filter(...)
    .forEach(item -> { 
        foo();
        bar();
        runCount.value++; // now it's work fine!
    });
System.out.println("The lambda ran " + runCount + " times");

私にとって、これはトリックをしました、うまくいけば誰かがそれが役に立つと思うでしょう：

AtomicInteger runCount= new AtomicInteger(0);
myStream.stream().filter(...).forEach(item->{ ... ; runCount.getAndIncrement(););
System.out.println("The lambda ran "+runCount.get()+"times");

getAndIncrement（）Javaドキュメントの状態：

VarHandle.getAndAddで指定されたメモリ効果を使用して、現在の値をアトミックにインクリメントします。getAndAdd（1）と同等です。

これを行う別の方法（操作が成功した場合など、場合によってはカウントをインクリメントするだけにしたい場合に便利です）は、mapToInt()andを使用してsum()次のようになります。

int count = myStream.stream()
    .filter(...)
    .mapToInt(item -> { 
        foo();
        if (bar()){
           return 1;
        } else {
           return 0;
    })
    .sum();
System.out.println("The lambda ran " + count + "times");

Stuart Marksが指摘したように、これは副作用を完全に回避しているわけではないため、まだやや奇妙です（何foo()をしbar()ているかによって異なります）。

また、ラムダの外部からアクセスできるラムダ内の変数をインクリメントする別の方法は、クラス変数を使用することです。

public class MyClass {
    private int myCount;

    // Constructor, other methods here

    void myMethod(){
        // does something to get myStream
        myCount = 0;
        myStream.stream()
            .filter(...)
            .forEach(item->{
               foo(); 
               myCount++;
        });
    }
}

この例では、1つのメソッドでカウンターにクラス変数を使用することはおそらく意味がないので、正当な理由がない限り、注意します。final可能であればクラス変数を保持することは、スレッドセーフなどの観点から役立ちます（使用に関する説明については、http：//www.javapractices.com/topic/TopicAction.do？Id = 23を参照してくださいfinal）。

ラムダがそのように機能する理由をよりよく理解するために、https： //www.infoq.com/articles/Java-8-Lambdas-A-Peek-Under-the-Hoodに詳細があります。

ローカルでのみ必要なためにフィールドを作成したくない場合は、匿名クラスに格納できます。

int runCount = new Object() {
    int runCount = 0;
    {
        myStream.stream()
                .filter(...)
                .peek(x -> runCount++)
                .forEach(...);
    }
}.runCount;

奇妙な、私は知っています。ただし、一時変数はローカルスコープからも除外されます。

削減も機能します、このように使用できます

myStream.stream().filter(...).reduce((item, sum) -> sum += item);

もう1つの方法は、Apache CommonsMutableIntを使用することです。

MutableInt cnt = new MutableInt(0);
myStream.stream()
    .filter(...)
    .forEach(item -> { 
        foo();
        bar();
        cnt.increment();
    });
System.out.println("The lambda ran " + cnt.getValue() + " times");

AtomicInteger runCount = new AtomicInteger(0);

elements.stream()
  //...
  .peek(runCount.incrementAndGet())
  .collect(Collectors.toList());

// runCount.get() should have the num of times lambda code was executed