Java中与C#的ObservableCollection相等的类

Question

我想知道是否存在一种数据结构，类似于 C# 中的 ObservableCollection，能够接受某种类型。

例如：

在 C# 中，我可以这样说...

 ObservableCollection<Beer> Beer = new ObservableCollection<Beer>();
 Beer.add("Bud"); <br>
 Beer.add("Coors");

假设已经制造了一个名为 Beer 的类，并且我们可以更改酒精含量，使其

 Beer[1].content = 5;

我想知道是否有适用于Java的数据结构，不知道是否有人了解。

---

我是一名C#程序员，不太懂Java，只是好奇。此外，它必须能够接受自定义类型，而非泛型。

- user188097

---

可观察集合的主要特点是您可以观察其变化 - 即在列表中添加/删除任何内容时获取事件。这符合您的需求吗？ - nos

Answer 1

org.apache.commons.events.observable ObservableCollection 类

- Robert Harvey

---

请注意，此事件库不稳定且未得到积极开发，因为它位于apache commons的休眠分支中。因此，您将找不到此库的任何发布版本。 - Arnold Pistorius

Answer 2

可观察数据结构（ObservableList，ObservableMap等）作为JavaFX项目的一部分包含在Oracle Java 7u6+中。 OpenJFX项目提供了OpenJDK的相应库。

这里是一个关于使用JavaFX集合的教程。

以下是从链接教程中使用JavaFX可观察列表的示例代码：

import java.util.List;
import java.util.ArrayList;
import javafx.collections.*;

public class CollectionsDemo {
  public static void main(String[] args) {
    // Use Java Collections to create the List.
    List<String> list = new ArrayList<String>();

    // Now add observability by wrapping it with ObservableList.
    ObservableList<String> observableList = FXCollections.observableList(list);
    observableList.addListener(new ListChangeListener() {
      @Override public void onChanged(ListChangeListener.Change change) {
        System.out.println("Detected a change! ");
      }
    });

    // Changes to the observableList WILL be reported.
    // This line will print out "Detected a change!"
    observableList.add("item one");

    // Changes to the underlying list will NOT be reported
    // Nothing will be printed as a result of the next line.
    list.add("item two");

    System.out.println("Size: "+observableList.size());
  }
}

- jewelsea

Answer 3

现在JavaFX有ObservableList来满足您的需求，如果您不想依赖JavaFX - 这里是我一段时间前写的一个类，可以代替使用。

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

/**
 *
 * @author bennyl
 */
public class ObservableList<T> implements List<T> {

    private List<T> wrapped;
    private LinkedList<Listener<T>> listeners = new LinkedList<>();

    public ObservableList(List wrapped) {
        this.wrapped = wrapped;
    }

    public void addListener(Listener l) {
        listeners.add(l);
    }

    public void removeListener(Listener l) {
        listeners.remove(l);
    }

    @Override
    public int size() {
        return wrapped.size();
    }

    @Override
    public boolean isEmpty() {
        return wrapped.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return wrapped.contains(o);
    }

    @Override
    public Iterator<T> iterator() {
        final Iterator<T> iterator = wrapped.iterator();
        return new Iterator<T>() {
            T current = null;

            @Override
            public boolean hasNext() {
                return iterator.hasNext();
            }

            @Override
            public T next() {
                return current = iterator.next();
            }

            @Override
            public void remove() {
                iterator.remove();
                fireRemoved(current);
            }
        };
    }

    private void fireRemoved(T... items) {
        fireRemoved(Arrays.asList(items));
    }

    @Override
    public Object[] toArray() {
        return wrapped.toArray();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return wrapped.toArray(a);
    }

    @Override
    public boolean add(T e) {
        if (wrapped.add(e)) {
            fireAdded(e);
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean remove(Object o) {
        if (wrapped.remove(o)) {
            fireRemoved((T) o);
            return true;
        }

        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return wrapped.containsAll(c);
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        if (wrapped.addAll(c)) {
            fireAdded(c);
            return true;
        }

        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> c) {
        if (wrapped.addAll(index, c)) {
            fireAdded(c);
        }

        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        if (wrapped.removeAll(c)) {
            fireRemoved((Collection<? extends T>) c);
            return true;
        }

        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        if (wrapped.retainAll(c)) {
            fireStracturalChange();
        }

        return false;
    }

    @Override
    public void clear() {
        wrapped.clear();
        fireStracturalChange();
    }

    @Override
    public boolean equals(Object o) {
        return wrapped.equals(o);
    }

    @Override
    public int hashCode() {
        return wrapped.hashCode();
    }

    @Override
    public T get(int index) {
        return wrapped.get(index);
    }

    @Override
    public T set(int index, T element) {
        T old = wrapped.set(index, element);
        fireRemoved(old);
        fireAdded(element);
        return old;
    }

    @Override
    public void add(int index, T element) {
        wrapped.add(index, element);
        fireAdded(element);
    }

    @Override
    public T remove(int index) {
        T old = wrapped.remove(index);
        fireRemoved(old);
        return old;
    }

    @Override
    public int indexOf(Object o) {
        return wrapped.indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        return wrapped.lastIndexOf(o);
    }

    @Override
    public ListIterator<T> listIterator() {
        return wrapped.listIterator();
    }

    @Override
    public ListIterator<T> listIterator(int index) {
        return wrapped.listIterator(index);
    }

    @Override
    public List<T> subList(int fromIndex, int toIndex) {
        return wrapped.subList(fromIndex, toIndex);
    }

    private void fireRemoved(Collection<? extends T> asList) {
        for (Listener<T> l : listeners) {
            l.onItemsRemoved(this, asList);
        }
    }

    private void fireAdded(T... e) {
        fireAdded(Arrays.asList(e));
    }

    private void fireAdded(Collection<? extends T> asList) {
        for (Listener<T> l : listeners) {
            l.onItemsAdded(this, asList);
        }
    }

    private void fireStracturalChange() {
        for (Listener<T> l : listeners) {
            l.onStracturalChange(this);
        }
    }

    public static interface Listener<T> {

        void onItemsAdded(ObservableList<T> source, Collection<? extends T> items);

        void onItemsRemoved(ObservableList<T> source, Collection<? extends T> items);

        void onStracturalChange(ObservableList<T> source);
    }
}

- bennyl

Answer 4

如果您想观察您的列表，例如在列表更改时得到通知，您可以使用 Glazed Lists。

如果您只想修改存储在列表中的对象，您可以使用 List.get(int index) 获取您的对象，或通过遍历列表获取其值。

如果您想将字符串存储到列表中自动创建 Beer 对象，您可能需要编写自己的简单列表包装器。

- Peter Štibraný

Answer 5

你可以考虑使用java.util.Observable类，这里是一个例子：

public class Try extends Observable{

  private static List<String> list = new ArrayList<String>();
  private static Try observableObj = new Try();

  public static List<String> getList(){
    observableObj.setChanged();
    observableObj.notifyObservers();
    return list;
  }


  public static void main(String[] args) throws RemoteException {

    Try2 observer1 = new Try2();
    Try2 observer2 = new Try2();
    observableObj.addObserver(observer1);
    observableObj.addObserver(observer2);

    System.out.println(getList().isEmpty());

  }
}

class Try2 implements Observer{

  @Override
  public void update(Observable arg0, Object arg1) {
    System.out.println(this.toString()+" has been notified");

  }
}

这样，每次访问ArrayList时，两个观察者都会收到通知。

- magicsign

Answer 6

在Java集合API中至少没有这个

http://download-llnw.oracle.com/javase/1.5.0/docs/guide/collections/designfaq.html#27

你可以创建一个包装器或代理

- yeraycaballero

Answer 7

当然可以。如果你有一个名为Soda的类，你可以这样做：

List<Soda> sodas = new ArrayList<Soda>();
sodas.add(new Soda("Coke"));
sodas.add(new Soda("Sprite"));

然后你可以这样做

sodas.get(1).setSugar(255);

- broschb

---

为什么要使用ArrayList而不是List<T>？ - Ed S.

List是接口，ArrayList是实现。没有代码标签，泛型标签无法显示。(开心的Snarfblam) - broschb