Xóa và thu thập các phần tử bằng luồng Java

Question

Giả sử tôi có một số Collection và Predicate khớp với các yếu tố tôi muốn xóa khỏi Collection. Nhưng tôi không chỉ muốn loại bỏ chúng, tôi muốn di chuyển các yếu tố phù hợp vào một bộ sưu tập mới. Tôi muốn làm một cái gì đó như this trong Java 7:

List<E> removed = new LinkedList<>(); 
for (Iterator<E> i = data.iterator(); i.hasNext();) { 
    E e = i.next(); 
    if (predicate.test(e)) { 
     removed.add(e); 
     i.remove(); 
    } 
} 

Tôi tò mò nếu có một luồng/Java 8 cách để làm điều đó. Collections.removeIf() may đơn giản là trả về một boolean (thậm chí không đếm số lượng các yếu tố loại bỏ Quá xấu?). Tôi hình dung một cái gì đó như thế này (mặc dù dĩ nhiên .removeAndYield(Predicate) không tồn tại):

List<E> removed = data.removeAndYield(predicate).collect(Collectors.toList()); 

Lưu ý: Câu hỏi này là lấy cảm hứng từ a similar question; câu hỏi này là về trường hợp tổng quát hơn khi nhận luồng trên các mục bị xóa khỏi bộ sưu tập. Như đã chỉ ra trong câu hỏi được liên kết, giải pháp bắt buộc có thể dễ đọc hơn, nhưng tôi tò mò nếu điều này thậm chí có thể với các luồng.

Chỉnh sửa: Rõ ràng chúng tôi có thể chia nhiệm vụ thành hai bước riêng biệt và giả định cấu trúc dữ liệu thích hợp sẽ hiệu quả. Câu hỏi đặt ra là điều này có thể được thực hiện trên các bộ sưu tập tùy ý (có thể không có hiệu quả .contains() vv).

Answer 1

tôi muốn giữ nó đơn giản:

Set<E> removed = set.stream() 
    .filter(predicate) 
    .collect(Collectors.toSet()); 

set.removeAll(removed); 

Answer 2

Nếu bạn muốn có một cách chức năng để làm điều này, bạn có thể viết phương pháp riêng của mình.

static <E> Set<E> removeIf(Collection<? extends E> collection, Predicate<? super E> predicate) { 
    Set<E> removed = new HashSet<>(); 
    for (Iterator<? extends E> i = collection.iterator(); i.hasNext();) { 
     E e = i.next(); 
     if (predicate.test(e)) { 
      removed.add(e); 
      i.remove(); 
     } 
    } 
    return removed; 
} 

Điều này có thể được sử dụng để xóa tất cả các số lẻ khỏi List.

Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6)); 
Set<Integer> removed = removeIf(set, i -> i % 2 != 0); 
System.out.println(set); 
System.out.println(removed); 

Answer 3

Nếu bạn không phiền, hãy để tôi uốn cong yêu cầu của bạn một chút. :-)

Một đặc điểm của kết quả mong muốn là các phần tử phù hợp sẽ kết thúc trong một bộ sưu tập và các phần tử không khớp sẽ kết thúc trong một bộ sưu tập khác. Trong thế giới đột biến trước Java-8, cách dễ nhất để suy nghĩ về việc thu thập các yếu tố không phù hợp là xóa các yếu tố phù hợp khỏi bộ sưu tập gốc.

Nhưng là loại bỏ - sửa đổi các danh sách ban đầu - một phần nội tại của yêu cầu?

Nếu nó không phải là, thì kết quả có thể đạt được thông qua một hoạt động phân vùng đơn giản:

Map<Boolean, List<E>> map = data.stream().collect(partitioningBy(predicate)); 

Bản đồ kết quả thực chất là hai danh sách, trong đó có chứa các hợp (key = true) và không phù hợp (key = false) phần tử.

Lợi thế là kỹ thuật này có thể được thực hiện trong một lần truyền và song song nếu cần. Tất nhiên, điều này tạo ra một danh sách trùng lặp của các yếu tố không phù hợp so với loại bỏ các trận đấu từ bản gốc, nhưng đây là giá phải trả cho bất biến. Sự cân bằng có thể đáng giá.

Answer 4

Chỉ cần viết cho mình một chức năng tái sử dụng như thế này:

/** 
* Removes all matching element from iterator 
* 
* @param it 
* @param predicate 
*/ 
public static <E> void removeMatching(final Iterator<E> it, final Predicate<E> predicate) { 
    while (it.hasNext()) { 
     final E e = it.next(); 
     if (predicate.test(e)) { 
      it.remove(); 
     } 
    } 
} 

Tôi cũng không tìm thấy một giải pháp tồn tại trước đó cho Streams. Sử dụng iterator.remove() yêu cầu bộ nhớ ít hơn một bộ tạm thời.