Java中C#ObservableCollection的等价物

我想知道是否有一种数据结构像OberservableCollection一样工作，就像在C#中一样，能够采用某种类型

例：

在C#中，我可以说

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

我想知道是否有人知道是否有这样一种数据结构可以与Java一起工作

---

---

我是一名C#程序员，不是一名Java程序员，所以我只是想知道。此外，它还必须能够接受自定义类型，而不是泛型。

org.apache.commons.events.observable

---

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

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

---

如果您希望观察列表，即在列表更改时收到通知，您可以使用

如果只想修改列表中存储的对象，可以使用或通过迭代列表来获取对象

---

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

至少在Java Collections api中没有

---

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

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);
    }
}

导入java.util.array；
导入java.util.Collection；
导入java.util.Iterator；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.ListIterator；
/**
*
*@作者本尼尔
*/
公共类ObservableList实现列表{
私人名单；
私有LinkedList侦听器=新LinkedList（）；
公共观察列表（列表包装）{
this.wrapped=wrapped；
}
公共void addListener（侦听器l）{
添加（l）；
}
公共无效删除侦听器（侦听器l）{
删除（l）；
}
@凌驾
公共整数大小（）{
返回wrapped.size（）；
}
@凌驾
公共布尔值为空（）{
return wrapped.isEmpty（）；
}
@凌驾
公共布尔包含（对象o）{
返回包装。包含（o）；
}
@凌驾
公共迭代器迭代器（）{
final Iterator Iterator=wrapped.Iterator（）；
返回新的迭代器（）{
T电流=零；
@凌驾
公共布尔hasNext（）{
返回iterator.hasNext（）；
}
@凌驾
公共交通工具{
返回current=iterator.next（）；
}
@凌驾
公共空间删除（）{
iterator.remove（）；
火焰移除（当前）；
}
};
}
已移除私人空间（T…项）{
fireRemoved（Arrays.asList（items））；
}
@凌驾
公共对象[]toArray（）{
return wrapped.toArray（）；
}
@凌驾
公共T[]toArray（T[]a）{
返回包装。到阵列（a）；
}
@凌驾
公共布尔加法（TE）{
如果（已包装，添加（e））{
（e）；
返回true；
}否则{
返回false；
}
}
@凌驾
公共布尔删除（对象o）{
如果（包裹。移除（o））{
除火（（T）o）；
返回true；
}
返回false；
}
@凌驾
公共布尔容器（集合c）{
包装好的退货。集装箱全部（c）；
}
@凌驾
公共布尔addAll（集合c）{
如果（包裹。移除所有（c））{
fireRemoved（（集合可观察的数据结构（，等）作为项目的一部分包含在Oracle Java 7u6+中。项目提供了相应的OpenJDK库

这里有一个关于的教程

以及一些使用链接教程中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());
  }
}

import java.util.List；
导入java.util.ArrayList；
导入javafx.collections.*；
公共类集合演示{
公共静态void main（字符串[]args）{
//使用Java集合创建列表。
列表=新的ArrayList（）；
//现在，通过使用ObservableList包装它来添加可观察性。
ObservableList ObservableList=FXCollections.ObservableList（列表）；
observableList.addListener（新的ListChangeListener（）{
@更改后重写公共void（ListChangeListener.Change）{
System.out.println（“检测到更改！”）；
}
});
//将报告可观察列表的更改。
//此行将打印“检测到更改！”
增加可观察列表（“第一项”）；
//不会报告对基础列表的更改
//下一行的结果将不会打印任何内容。
列表。添加（“第二项”）；
System.out.println（“大小：+observeList.Size（））；
}
}
< /代码> 您可以考虑使用java. UTIL可观察类，这里有一个例子：

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");

  }
}

public类Try扩展了可观察的{
私有静态列表=新的ArrayList（）；
private static Try observeOBJ=new Try（）；
公共静态列表getList（）{
observeObj.setChanged（）；
observeobj.notifyobsers（）；
退货清单；
}
公共静态void main（字符串[]args）引发RemoteException{
Try2 observer 1=新的Try2（）；
Try2 observer 2=新的Try2（）；
observeobj.addobservator（observ1）；
observeobj.addobservator（observ2）；
System.out.println（getList（）.isEmpty（））；
}
}
类Try2实现了Observer{
@凌驾
公共无效更新（可观察arg0，对象arg1）{
System.out.println（已通知此.toString（）+）；
}
}

这样，每次访问ArrayList时，两个观察者都会得到通知。
为什么要使用ArrayList而不是List？List是接口，ArrayList是实现。通用标记没有显示我刚才添加的代码标记。（happy Snarfblam）observable collection的主要功能是，您可以观察它的更改，即在添加/删除列表中的任何内容时获取事件。这就是您需要的吗？请注意，此事件库
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());
  }
}

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");

  }
}