Thêm và xóa các mục vào một danh sách không cần thiết của Guava ImmutableList

Question

Trong ổi, có cách hiệu quả để thêm hoặc xóa các mục vào một số ImmutableList (tạo Danh sách mới trong tiến trình).

Cách đơn giản nhất tôi có thể đưa ra là thế này:

private ImmutableList<String> foos = ImmutableList.of(); 

public void addFoo(final String foo) { 
    if (this.foos.isEmpty()) { 
     foos = ImmutableList.of(foo); 
    } else { 
     foos = ImmutableList.<String>builder().addAll(foos).add(foo).build(); 
    } 
} 

public void removeFoo(final String foo) { 
    final int index = this.foos.indexOf(foo); 
    if (index > -1) { 
     final Builder<String> builder = ImmutableList.<String>builder(); 
     if (index > 0) builder.addAll(this.foos.subList(0, index)); 
     final int size = this.foos.size(); 
     if (index < size - 1) builder.addAll(this.foos.subList(index+1, size)); 
     this.foos = builder.build(); 
    } 
} 

Những gì tôi muốn tránh làm là thế này:

public void removeFoo(final String foo) { 
    final ArrayList<String> tmpList = Lists.newArrayList(this.foos); 
    if(tmpList.remove(foo))this.foos=ImmutableList.copyOf(tmpList); 
} 

Nhưng tiếc là nó là như vậy đơn giản hơn nhiều so với bất kỳ Guava- chỉ có phương pháp tôi có thể nghĩ đến. Tôi đã bỏ lỡ một cái gì đó?

Answer 1

ConcurrentModificationException không thực sự liên quan đến đồng thời và đồng bộ hóa. Truy cập List có thể thay đổi đồng thời có thể làm hỏng và/hoặc ném ngoại lệ (được chuẩn bị cho cả 3 khả năng). Bạn mã không thể thất bại theo cách này, nhưng với đa luồng nó không hoạt động hoặc là:

• Nếu không đồng bộ và không foos là volatile, không có gì bảo đảm rằng thread khác bao giờ sẽ thấy những thay đổi mà bạn đã thực hiện.
• Ngay cả với volatile, có thể xảy ra một số thay đổi bị mất, ví dụ: khi hai chủ đề thêm mục vào foos, cả hai có thể bắt đầu bằng giá trị ban đầu và sau đó viết một lần cuối cùng.).

Mã bạn đang cố gắng tránh là không có gì để tránh.

• "Tôi phải tạo bộ sưu tập trung thừa" - vâng, nhưng không có bữa ăn trưa miễn phí:
  • xác định kích thước của kết quả trước, có nghĩa là một sự lặp lại bổ sung thông qua toàn bộ danh sách
  • hoặc phân bổ một mảng đủ lớn và sao chép phạm vi cần thiết trong danh sách kết quả
  • hoặc phân bổ một mảng đủ lớn và chỉ sử dụng một phần của nó (tiết kiệm thời gian và lãng phí bộ nhớ)
  • hoặc tạo chế độ xem không thay đổi (tiết kiệm cả thời gian và bộ nhớ, nhưng có thể mất thời gian sau)
• AFAIK Câu trả lời của Frank thực hiện khả năng đầu tiên, tốt nếu vị từ nhanh.
• "Tôi phải kết hợp bộ sưu tập java.util với ổi ImmutableCollections, trong khi tôi muốn gắn bó với một mô hình." - vâng, nhưng để tắt bộ sưu tập thì cần thu thập bộ sưu tập có thể thay đổi. Các ImmutableList.Builder chỉ bao gồm các trường hợp phổ biến nhất cho phép để xử lý chúng một cách nhỏ gọn.

Bạn có thể muốn xem persistent collections, được tối ưu hóa cho các hoạt động như vậy. Tuy nhiên, bạn không nên mong đợi ví dụ: danh sách liên tục nhanh như ArrayList hoặc ImmutableList.

Answer 2

Bạn có thể loại bỏ bằng cách lọc, mà không tạo ra một trung gian ArrayList hoặc người xây dựng, và chỉ đi qua danh sách một lần:

public void removeFoo(final String foo) { 
    foos = ImmutableList.copyOf(Collections2.filter(foos, 
      Predicates.not(Predicates.equalTo(foo))); 
} 

Để thêm, tôi không thấy một giải pháp tốt hơn.