Nhận phần tử cuối cùng của Luồng / Danh sách trong một lớp lót

Làm cách nào để lấy phần tử cuối cùng của luồng hoặc danh sách trong đoạn mã sau?

Đâu data.careaslà List<CArea>:

CArea first = data.careas.stream()
                  .filter(c -> c.bbox.orientationHorizontal).findFirst().get();

CArea last = data.careas.stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .collect(Collectors.toList()).; //how to?

Như bạn có thể thấy để có được yếu tố đầu tiên, với một số yếu tố nhất định filter, không khó.

Tuy nhiên, nhận được phần tử cuối cùng trong một lớp lót là một nỗi đau thực sự:

• Có vẻ như tôi không thể lấy nó trực tiếp từ a Stream. (Nó chỉ có ý nghĩa đối với các luồng hữu hạn)
• Có vẻ như bạn không thể nhận được những thứ như first()và last()từ Listgiao diện, đó thực sự là một điều khó khăn.

Tôi không thấy bất kỳ đối số nào về việc không cung cấp một first()và last()phương thức trong Listgiao diện, vì các phần tử trong đó, được sắp xếp theo thứ tự và hơn nữa kích thước cũng được biết đến.

Nhưng theo câu trả lời ban đầu: Làm thế nào để lấy phần tử cuối cùng của một hữu hạn Stream?

Cá nhân, đây là gần nhất tôi có thể nhận được:

int lastIndex = data.careas.stream()
        .filter(c -> c.bbox.orientationHorizontal)
        .mapToInt(c -> data.careas.indexOf(c)).max().getAsInt();
CArea last = data.careas.get(lastIndex);

Tuy nhiên, nó liên quan đến việc sử dụng một indexOftrên mọi phần tử, điều mà bạn thường không muốn vì nó có thể làm giảm hiệu suất.

Có thể lấy phần tử cuối cùng bằng phương thức Stream :: Reduce . Danh sách sau đây chứa một ví dụ tối thiểu cho trường hợp chung:

Stream<T> stream = ...; // sequential or parallel stream
Optional<T> last = stream.reduce((first, second) -> second);

Việc triển khai này hoạt động cho tất cả các luồng có thứ tự (bao gồm cả các luồng được tạo từ Danh sách ). Đối với các luồng không có thứ tự , vì những lý do hiển nhiên không xác định được phần tử nào sẽ được trả về.

Việc triển khai hoạt động cho cả luồng tuần tự và song song . Thoạt nhìn điều đó có thể gây ngạc nhiên, và tiếc là tài liệu không trình bày rõ ràng. Tuy nhiên, đó là một tính năng quan trọng của luồng và tôi cố gắng làm rõ nó:

• Javadoc cho phương thức Stream :: Reduce các trạng thái, rằng nó " không bị ràng buộc phải thực thi tuần tự " .
• Javadoc cũng yêu cầu rằng "hàm tích lũy phải là một hàm liên kết , không can thiệp , không trạng thái để kết hợp hai giá trị" , điều này rõ ràng là trường hợp của biểu thức lambda (first, second) -> second.
• Javadoc dành cho các hoạt động rút gọn cho biết: "Các lớp luồng có nhiều dạng hoạt động giảm tổng quát, được gọi là Reduce () và collect () [..]" và "hoạt động giảm được xây dựng đúng cách vốn có thể song song hóa , miễn là hàm (s ) được sử dụng để xử lý các phần tử là liên kết và không trạng thái . "

Tài liệu dành cho các Bộ sưu tập có liên quan chặt chẽ thậm chí còn rõ ràng hơn: "Để đảm bảo rằng việc thực thi tuần tự và song song tạo ra kết quả tương đương , các hàm bộ sưu tập phải thỏa mãn các ràng buộc về nhận dạng và tính liên kết ."

Quay lại câu hỏi ban đầu: Đoạn mã sau đây lưu trữ một tham chiếu đến phần tử cuối cùng trong biến lastvà ném một ngoại lệ nếu luồng trống. Độ phức tạp là tuyến tính theo chiều dài của luồng.

CArea last = data.careas
                 .stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .reduce((first, second) -> second).get();

Nếu bạn có một Bộ sưu tập (hoặc tổng quát hơn một bộ Lặp lại), bạn có thể sử dụng Google Guava's

Iterables.getLast(myIterable)

như oneliner tiện dụng.

Một lớp lót (không cần luồng;):

Object lastElement = list.get(list.size()-1);

Ổi có phương pháp dành riêng cho trường hợp này:

Stream<T> stream = ...;
Optional<T> lastItem = Streams.findLast(stream);

Nó tương đương với stream.reduce((a, b) -> b)nhưng những người sáng tạo cho rằng nó có hiệu suất tốt hơn nhiều.

Từ tài liệu :

Thời gian chạy của phương pháp này sẽ nằm giữa O (log n) và O (n), hoạt động tốt hơn trên các luồng có thể phân chia hiệu quả.

Điều đáng nói là nếu luồng không có thứ tự thì phương thức này sẽ hoạt động như thế nào findAny().

Nếu bạn cần lấy N số phần tử cuối cùng. Đóng cửa có thể được sử dụng. Đoạn mã dưới đây duy trì một hàng đợi bên ngoài có kích thước cố định cho đến khi luồng đi đến cuối.

    final Queue<Integer> queue = new LinkedList<>();
    final int N=5;
    list.stream().peek((z) -> {
        queue.offer(z);
        if (queue.size() > N)
            queue.poll();
    }).count();

Một tùy chọn khác có thể là sử dụng thao tác giảm sử dụng danh tính làm Hàng đợi.

    final int lastN=3;
    Queue<Integer> reduce1 = list.stream()
    .reduce( 
        (Queue<Integer>)new LinkedList<Integer>(), 
        (m, n) -> {
            m.offer(n);
            if (m.size() > lastN)
               m.poll();
            return m;
    }, (m, n) -> m);

    System.out.println("reduce1 = " + reduce1);

Bạn cũng có thể sử dụng hàm bỏ qua () như bên dưới ...

long count = data.careas.count();
CArea last = data.careas.stream().skip(count - 1).findFirst().get();

nó rất đơn giản để sử dụng.