Java 8: Cách ưa thích để đếm số lần lặp của lambda?

Tôi đối mặt với cùng một vấn đề thường xuyên. Tôi cần đếm số lần chạy của lambda để sử dụng bên ngoài lambda. Ví dụ:

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

Vấn đề là runCount cần phải là số cuối cùng, vì vậy nó không thể là một int. Nó không thể là một Số nguyên bởi vì nó là bất biến. Tôi có thể làm cho nó biến mức lớp (tức là một trường) nhưng tôi sẽ chỉ cần nó trong khối mã này. Tôi biết có nhiều cách khác nhau, tôi chỉ tò mò giải pháp ưa thích của bạn cho việc này là gì? Bạn có sử dụng AtomicInteger hay tham chiếu mảng hay một số cách khác không?

Hãy để tôi định dạng lại ví dụ của bạn một chút để tiện cho việc thảo luận:

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

Nếu bạn thực sự cần tăng một bộ đếm từ bên trong lambda, cách thông thường để làm như vậy là tạo bộ đếm là một AtomicIntegerhoặc AtomicLongvà sau đó gọi một trong các phương thức tăng trên đó.

Bạn có thể sử dụng một phần tử inthoặc longmảng đơn lẻ , nhưng điều đó sẽ có các điều kiện về chủng tộc nếu luồng được chạy song song.

Nhưng lưu ý rằng luồng kết thúc bằng forEach, có nghĩa là không có giá trị trả về. Bạn có thể thay đổi forEachthành a peek, chuyển các mục đi qua, sau đó đếm chúng:

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

Điều này có phần tốt hơn, nhưng vẫn hơi kỳ quặc. Lý do là forEachvà peekchỉ có thể làm công việc của họ thông qua các tác dụng phụ. Phong cách chức năng mới nổi của Java 8 là để tránh các tác dụng phụ. Chúng tôi đã thực hiện một chút điều đó bằng cách trích xuất số gia của bộ đếm thành một counthoạt động trên luồng. Các tác dụng phụ điển hình khác là thêm các mục vào bộ sưu tập. Thông thường chúng có thể được thay thế bằng cách sử dụng bộ sưu tập. Nhưng không biết công việc thực tế bạn đang cố gắng làm là gì, tôi không thể đề xuất điều gì cụ thể hơn.

Để thay thế cho việc đồng bộ AtomicInteger rắc rối, người ta có thể sử dụng một mảng số nguyên . Miễn là tham chiếu đến mảng không nhận được một mảng khác được gán (và đó là điểm), nó có thể được sử dụng như một biến cuối cùng trong khi giá trị của các trường có thể thay đổi tùy ý.

    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");

Bạn không nên sử dụng AtomicInteger, bạn không nên sử dụng mọi thứ trừ khi bạn có lý do thực sự chính đáng để sử dụng. Và lý do sử dụng AtomicInteger có thể chỉ cho phép các truy cập đồng thời hoặc tương tự như vậy.

Khi nói đến vấn đề của bạn;

Giá đỡ có thể được sử dụng để giữ và gia tăng nó bên trong lambda. Và sau khi bạn có thể lấy nó bằng cách gọi 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");

Đối với tôi, đây là mẹo, hy vọng ai đó thấy nó hữu ích:

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

getAndIncrement () Tài liệu Java cho biết:

Tăng nguyên tử giá trị hiện tại, với các hiệu ứng bộ nhớ như được chỉ định bởi VarHandle.getAndAdd. Tương đương với getAndAdd (1).

Một cách khác để thực hiện việc này (hữu ích nếu bạn muốn số lượng của mình chỉ tăng lên trong một số trường hợp, chẳng hạn như nếu một hoạt động thành công) là như thế này, sử dụng mapToInt()và 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");

Như Stuart Marks đã lưu ý, điều này vẫn còn hơi kỳ lạ, vì nó không hoàn toàn tránh được các tác dụng phụ (tùy thuộc vào những gì đã foo()và bar()đang làm).

Và một cách khác để tăng một biến trong lambda có thể truy cập bên ngoài nó là sử dụng một biến lớp:

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++;
        });
    }
}

Trong ví dụ này, việc sử dụng một biến lớp cho một bộ đếm trong một phương thức có thể không hợp lý, vì vậy tôi sẽ thận trọng với nó trừ khi có lý do chính đáng. Giữ các biến lớp finalnếu có thể có thể hữu ích về mặt an toàn luồng, v.v. (xem http://www.javapractices.com/topic/TopicAction.do?Id=23 để thảo luận về cách sử dụngfinal ).

Để hiểu rõ hơn về lý do tại sao lambdas hoạt động theo cách họ làm, hãy https://www.infoq.com/articles/Java-8-Lambdas-A-Peek-Under-the-Hood có một cái nhìn chi tiết.

Nếu bạn không muốn tạo một trường vì bạn chỉ cần nó cục bộ, bạn có thể lưu trữ nó trong một lớp ẩn danh:

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

Kỳ lạ, tôi biết. Nhưng nó giữ cho biến tạm thời nằm ngoài phạm vi cục bộ.

Giảm cũng hoạt động, bạn có thể sử dụng nó như thế này

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

Một thay thế khác là sử dụng 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