Je me demandais s'il y a une structure de données qui agit comme une obersservablecollection presque comme dans C # qui est capable de prendre un certain type.
ex:
dans C # Je suis capable de dire. . supposant que la bière de classe est faite et que nous pouvons changer la teneur en alcool de sorte que Je suis un programmeur C #, pas une grande partie d'un programmeur Java, alors je me demandais. En outre, il doit être capable de prendre un type personnalisé, pas générique.
7 Réponses :
org.apache.commons.évents.observable Observablation de classe
Veuillez noter que cette bibliothèque d'événements n'est pas stable et n'est pas activement développée car elle est dans la branche dormante d'Apache Commons. Par conséquent, vous ne trouverez aucune version de cette bibliothèque.
Bien sûr, vous pouvez le faire. Si vous aviez une classe appelée Soda, vous pouvez faire:
sodas.get(1).setSugar(255);
Pourquoi utiliseriez-vous une arrayliste au lieu d'une liste
La liste est l'interface, la flambée de la mise en œuvre. Les balises génériques n'ont pas montré avec les balises de code que je viens d'ajouter. (Happy Snarfblam)
Si vous souhaitez observer vos listes, c'est-à-dire être averti lorsque la liste des modifications, vous pouvez utiliser listes vitrées .
Si vous souhaitez simplement modifier des objets stockés dans vos listes, vous pouvez obtenir vos objets à l'aide de list.get (int index) ou en itérant la liste.
Si vous souhaitez créer automatiquement des objets de bière lors du stockage des chaînes dans la liste, vous devez probablement écrire votre propre wrapper de liste simple.
Il n'y a pas au moins dans Java Collections API
http: // Télécharger -llnw.oracle.com/javase/1.5.0/docs/guide/collections/designfaq.html#27
Vous pouvez créer une enveloppe ou un proxy
JavaFx a maintenant observabliste qui correspond à vos besoins, dans le cas où vous ne voulez pas dépendre de Javafx - voici une classe que j'ai écrite il y a un moment qui peut être utilisée à la place.
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);
}
}
structures de données observables ( Observablier , Observablap , etc.) est inclus dans Oracle Java 7U6 + dans le cadre de Le projet Javafx . Une bibliothèque correspondante pour OpenJDK est fournie par le Projet OpenJOWEx .
Voici un tutoriel sur Utilisation de collections Javafx .
et certains Exemple de code pour utiliser une liste observable Javafx à partir du tutoriel lié:
Vous pouvez envisager d'utiliser la classe JAVA.UTIL.OBERVABLE, voici un exemple:
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");
}
}
La principale caractéristique de la collection observable est que vous pouvez l'observer pour les modifications - c'est-à-dire d'obtenir des événements lorsque quelque chose dans la liste est ajouté / supprimé. Est-ce ce dont vous avez besoin ?