Java 8: кращий спосіб підрахувати ітерації лямбди?

Я часто стикаюся з тією ж проблемою. Мені потрібно підрахувати пробіги лямбди для використання поза лямбдою .

Наприклад:

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

Проблема в тому, що runCount повинен бути final, тому він не може бути int. Це не може бути, Integerтому що це незмінно . Я міг би зробити це змінною рівня класу (тобто полем), але вона мені знадобиться лише в цьому блоці коду.

Я знаю, що існують різні способи, мені просто цікаво, яке саме улюблене рішення для цього?
Чи використовуєте ви AtomicIntegerпосилання на масив чи інший спосіб?

Дозвольте трохи переформатувати ваш приклад задля обговорення:

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

Якщо вам дійсно потрібно збільшити лічильник зсередини лямбда, типовий спосіб зробити це - зробити лічильник знаком AtomicIntegerабо, AtomicLongа потім викликати на ньому один із методів збільшення.

Ви можете використовувати одноелемент intабо longмасив, але це матиме умови перегонів, якщо потік запускається паралельно.

Але зауважте, що потік закінчується forEach, а це означає, що не повертається значення. Ви можете змінити значення forEachна a 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()та 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");

Як зазначив Стюарт Маркс, це все-таки дивно, оскільки це не дозволяє повністю уникнути побічних ефектів (залежно від того, що 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++;
        });
    }
}

У цьому прикладі використання змінної класу для лічильника в одному методі, ймовірно, не має сенсу, тому я застерігаю від цього, якщо для цього немає вагомих причин. Зберігання змінних класу, 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);

Інша альтернатива - використання apache commons MutableInt.

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