Cách hay để có Người nghe Bộ sưu tập?

Question

Có cách nào tốt hơn để có một người nghe trên một bộ sưu tập java hơn là bọc nó trong một lớp thực hiện mô hình quan sát?

Answer 1

Bạn nên kiểm tra Glazed Lists

Nó chứa các lớp Danh sách thể quan sát được, mà sự kiện cháy bất cứ khi nào các yếu tố được thêm vào, gỡ bỏ, thay thế, vv

Answer 2

Vâng, nếu bạn không thực sự cần một phiên bản java.util.Collection hoặc Danh sách, bạn có thể sử dụng một DefaultListModel. Tôi không biết về bất kỳ triển khai Bộ sưu tập "thực" nào có hỗ trợ người nghe/người quan sát tích hợp.

Answer 3

Apache Events.

"Commons-Events cung cấp các lớp bổ sung để kích hoạt và xử lý sự kiện. Nó tập trung vào Khung công tác Java, cung cấp trang trí cho các bộ sưu tập khác kích hoạt sự kiện".

Answer 4

Bạn có thể sử dụng ForwardingSet, ForwardingList, vv, từ Guava để trang trí một trường hợp cụ thể với hành vi mong muốn.

Dưới đây là thực hiện của riêng tôi mà chỉ sử dụng API JDK đồng bằng:

// create an abstract class that implements this interface with blank implementations 
// that way, annonymous subclasses can observe only the events they care about 
public interface CollectionObserver<E> { 

    public void beforeAdd(E o); 

    public void afterAdd(E o); 

    // other events to be observed ... 

} 

// this method would go in a utility class 
public static <E> Collection<E> observedCollection(
    final Collection<E> collection, final CollectionObserver<E> observer) { 
     return new Collection<E>() { 
      public boolean add(final E o) { 
       observer.beforeAdd(o); 
       boolean result = collection.add(o); 
       observer.afterAdd(o); 
       return result; 
      } 

      // ... generate rest of delegate methods in Eclipse 

    }; 
    } 

Answer 5

có rất nhiều cách để đạt được điều này - thường tôi sử dụng phương pháp này

import java.lang.ref.WeakReference; 
import java.util.ArrayList; 
import java.util.Collection; 
import java.util.List; 

public class ObservableArrayList<E> extends ArrayList<E> { 

    private @interface MethodId { 
     private static final int REMOVE = 2; 
     private static final int ADD = 1; 
    } 

    public interface ListObserver<E> { 
     void onElementAdded(E element); 
     void onElementRemoved(E element); 
    } 

    public ObservableArrayList(int capacity) { 
     super(capacity); 
     ensureObserver(); 
    } 

    public ObservableArrayList() { 
     ensureObserver(); 
    } 

    public ObservableArrayList(Collection<? extends E> collection) { 
     super(collection); 
     ensureObserver(); 
    } 

    private List<WeakReference<ListObserver<E>>> _listObserverWeakRefList; 

    public void addObserver(ListObserver<E> observer) { 
     _listObserverWeakRefList.add(new WeakReference<ListObserver<E>> (observer)); 
    } 

    private void ensureObserver() { 
     if (_listObserverWeakRefList == null) { 
      _listObserverWeakRefList = new ArrayList<>(); 
     } 
    } 

    @Override 
    public boolean add(E object) { 
     super.add(object); 
     callObservable(MethodId.ADD, object); 
     return true; 
    } 

    @Override 
    public boolean remove(Object object) { 
     boolean removed = super.remove(object); 
     if (removed) callObservable(MethodId.REMOVE, object); 
     return removed; 
    } 

    private void callObservable(@MethodId int methodId, Object element) { 
     for (WeakReference<ListObserver<E>> observerRef : _listObserverWeakRefList) { 
      ListObserver<E> observer = observerRef.get(); 
      if (observer != null) { 
       switch (methodId) { 
        case MethodId.ADD: 
         observer.onElementAdded((E) element); 
         break; 
        case MethodId.REMOVE: 
         observer.onElementRemoved((E) element); 
         break; 
       } 
      } 
     } 
    } 

}