Die überwachung der änderungen an einer Sammlung

(HINWEIS: ich aktualisiert diesen Beitrag nach der Realisierung ein paar Fehler von meiner eigenen so ist dies nicht das original, sondern eine verfeinerte stattdessen)

Für diesen Zweck, die ich tun würde, zwei neue Schnittstellen ListListener und Listenable und dann würde ich eine neue Klasse erstellen, wie ListenableArrayList würde wickeln Sie jeden List Methode mit einem Aufruf von einem (oder mehreren) entsprechenden Methoden definiert, die in ListListener. Im code würde es so etwas wie dieses:

public class ListenableArrayList<T> extends ArrayList<T>
                                    implements Listenable<T> {

    private ArrayList<T> internalList;
    private ListListener<T> listener;

    /* .. */

    public void add(T item) {
        listener.beforeAdd(T item);
        internalList.add(item);
        listener.afterAdd(T item);
    }

    /* .. */

    public void setListener(ListListener<T> listener) {
        this.listener = listener;
    }

}

public interface ListListener<T> {
    /* .. */
    void beforeAdd(T item);
    void afterAdd(T item);
    /* .. */
}

public interface Listenable<T> {
    /* .. */
    void setListener(ListListener<T> listener);
    /* .. */
}

Der Grund, warum ich würd es so machen würden, dass für die Erstellung von wirklich ad-hoc-Hörer auf der fly, anstatt die Bindung des ListenableArrayList zu einigen konkreten Umsetzung. Zum Beispiel mit diesem wäre das folgende möglich:

Listenable<String> list = new ListenableArrayList<String>();

list.setListener(new ListListener<String>() {
    @Override
    public void beforeAdd(String item) {
        System.out.println("About to add element "+item+"...");
    }
    @Override
    public void afterAdd(String item) {
        System.out.println("...element "+item+" has been added.");
    }
});

Etwas unübersichtlich, vielleicht, aber auf der anderen Seite würde dies ermöglichen die einfache Erweiterung von Sammlungen, Sets und so weiter ziemlich leicht.

Normalerweise würde ich Folgendes tun:

public class MyBean {
    private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
    private List<String> names = new ArrayList<String>();
    public void addName(String name) {
        names.add(name);
        pcs.firePropertyChange("names", null, Collections.unmodifiableList(names));
    }
    public void addPropertyChangeListener(PropertyChangeListener l) {
        pcs.addPropertyChangeListener(l);
    }
    public void removePropertyChangeListener(PropertyChangeListener l) {
        pcs.removePropertyChangeListener(l);
    }
}

PropertyChangeSupport verwaltet die Zuhörer und feuert die Ereignisse in Ihrem Namen.

Durch die übergabe von null als "Alter Wert" es zwingt das Ereignis ausgelöst werden. (Es ist wahrscheinlich, dass die Hörer nicht wirklich über den alten Wert sowieso)

Für eine swing-GUI-event und ich würde in der Regel verwenden Sie einfach einen EventListenerList um die Arbeit zu tun für mich.

EDIT: auf das formulieren der Fragen: wie behandeln Sie Kollektionen, würde ich in der Regel verwenden Sie eine ähnliche Veranstaltung wie die Sammlungen geben, so zum Beispiel ein TreeModel Veranstaltung dauert in der Regel ein TreePath-argument, oder für etwas in eine Karte würde ich geben die Schlüssel.

Jedoch für einfache JavaBeans die häufigste ist, nehmen eine Liste/array und verwenden Sie einfach die index.

Sind Sie vielleicht auf der Suche für java.beans.PropertyChangeSupport?

Meiner Meinung nach, sollte man vermeiden PropertyChangeEvent. IndexedPropertyChangeEvent ist schlimmer, und sehr selten verwendet, von Swing sowieso. Es ist besser, um einzugrenzen, Ihre Typen und Feuer ein javax.swing.event.ChangeEvent oder ähnliches (auch wenn es nur ein Anruf Runnable).

Bestimmter Datentypen (wie Listen!), Verglaste Listen (oder gleichwertig) erwähnt in einem anderen Beitrag von Peter Štibraný scheint ein guter Weg zu gehen.