Comment utiliser les méthodes de collecte(removeAll() et retainAll()) pour les deux objets. (les objets sont en relation parent-enfant)

Je m'attendais à un résultat en-dessous, mais en fait non. Je voudrais savoir comment faire pour afficher les différences entre deux Collections. (les objets sont en relation parent-enfant)
Dans ce cas, puis-je utiliser la méthode standard comme removeAll() ou pouvez-vous recommander une autre approche comme l'utilisation d'apache commons. Merci.

CONSTRAINT
------------------------------
1.Item.class is unmodifiable(eg. I can not add equals method)
2.If id is same between two objects, they are assumed as same things.
------------------------------
EXPECTED
------------------------------
removed object are:
2
same object are:
1
3
add object are:
4
------------------------------
ACTUAL
------------------------------
removed object are:
1
2
3
same object are:
add object are:
1
3
4
------------------------------
package com.javastudy;
import java.util.ArrayList;
import java.util.List;
public class CollectionCompareToObjects {
public static void main(String[] args) {
List<Item> before = new ArrayList<Item>();
List<ItemEx> after = new ArrayList<ItemEx>();
before.add(new Item(1L));
before.add(new Item(2L)); //delete
before.add(new Item(3L));
after.add(new ItemEx(1L));
after.add(new ItemEx(3L));
after.add(new ItemEx(4L)); //added
List<Item> removed = new ArrayList<Item>(before);
removed.removeAll(after);
System.out.println("removed objects are:");
for(Item item : removed){
System.out.println(item.getId());
}
List<Item> same = new ArrayList<Item>(before);
same.retainAll(after);
System.out.println("same objects are:");
for(Item item : same){
System.out.println(item.getId());
}
List<Item> added = new ArrayList<Item>(after);
added.removeAll(before);
System.out.println("add objects are:");
for(Item item : added){
System.out.println(item.getId());
}
}
}
package com.javastudy;
public class Item {
private Long id;
public Item(Long id) {
this.id = id;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}
package com.javastudy;
public class ItemEx extends Item {
private String name;
public ItemEx(Long id) {
super(id);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

n'avez-vous pas poser la même question y a une heure?
Incertaine, certains plus intrants sont nécessaires
Je crois que oui, il semble que la classe ItemEx a été ajouté, mais la réponse est la même. Auto généré equals() utilisé par les OP dernière fois peut ne pas être adapté pour répondre aux exigences. Est les devoirs balises manquantes?
Je suis désolé, vous quittez le droit, il n'est pas clair. Je vais réécrire plus tard. Je veux juste savoir comment faire pour comparer deux collections de manière efficace. J'ai trouvé que si je l'utilise beaucoup pour des boucles, cela a fonctionné comme je l'espérais. Mais peut-être qu'il n'est pas sophistiqué.
double de Comment utiliser les méthodes de collecte(removeAll() et retainAll()) pour les deux objets.

OriginalL'auteur zono | 2010-12-16

9

Java collections comptent sur la equals et hashCode méthodes (ce dernier est utilisé par HashMaps, HashSets et autres).

Si vous voulez être en mesure d'utiliser la structure de données des capacités de Java collections (comme removeAll, retainAll etc.), vous devez fournir les objets avec une bonne implémentations de equals et hashCode.

Si vous ne pouvez pas modifier l' Item de classe, vous pouvez écrire une classe wrapper avec votre propre mise en œuvre de equals:
```
public class ItemWrapper {
private final Item item;
public ItemWrapper(Item item) {
this.item = item;
}
public Item getItem() {
return item;
}
@Override
public boolean equals(Object obj) {
return obj instanceof ItemWrapper && item.getId().equals(((ItemWrapper) obj).item.getId());
}
@Override
public int hashCode() {
return item.getId().hashCode();
}
}
```
Créer un nouveau ItemWrapper pour chaque original Item, stocker les ItemWrappers en Java collections, et d'utiliser les méthodes requises (removeAll/retainAll). Parcourir la collection et de récupérer les Items en appelant chaque ItemWrapper's getItem() méthode.

Votre autre option est de la sous-classe ArrayList, mais il semble comme une plus alambiqué solution.

Encore une autre option est de ne pas utiliser Java collections pour les supprimer/conserver la logique, la mise en œuvre vous-même à la place.

Merci beaucoup en effet. Je vais essayer de les mettre en œuvre me base sur supprimer/conserver la logique.
Ou d'implémenter l'interface Comparable et l'utilisation TreeSet au lieu de HashSet.
fonctionne parfaitement..

OriginalL'auteur Eli Acherkan

Vous devez vous connecter pour publier un commentaire.