Façon de vérifier si deux Collections contiennent les mêmes éléments, indépendamment de l'ordre?

Disons que j'ai deux différents hashsets comme indiqué ci-dessous comment puis-je vérifier que les deux Hashset contiennent les mêmes éléments et ces deux hashsets sont égaux, indépendamment de l'ordre des éléments dans la collection, veuillez en informer..!!

Set set1=new HashSet();
          set.add(new Emp("Ram","Trainer",34000));
          set.add(new Emp("LalRam","Trainer",34000));

et l'autre est ..

Set set2=new HashSet();
          set.add(new Emp("LalRam","Trainer",34000));
          set.add(new Emp("Ram","Trainer",34000));

L'employé pojo est ...

class Emp //implements Comparable
{
      String name,job;
      public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    int salary;
      public Emp(String n,String j,int sal)
      {
         name=n;
         job=j;
         salary=sal;
       }
      public void display()
      {
        System.out.println(name+"\t"+job+"\t"+salary);
       }



  public boolean equals(Object o)
      {

         Emp p=(Emp)o;
          return this.name.equals(p.name)&&this.job.equals(p.job) &&this.salary==p.salary;
       }
   public int hashCode()
       {
          return name.hashCode()+job.hashCode()+salary;
       }


      /* public int compareTo(Object o)
       {
          Emp e=(Emp)o;
          return this.name.compareTo(e.name);
           //return this.job.compareTo(e.job);
        //  return this.salary-e.salary;

        }*/
}

D'abord définir des "égaux". Est égale à la référence ou equuivalent? Dans ce dernier cas, equals et hashcode définir pour les Emp de classe?
En supposant que Emp a bon remplacements pour equals() et hashCode() (ce qui n'est probablement, en raison de la présence dans une table de hachage), vous pouvez comparer les dénombrements sur les ensembles, et puis essayez d'ajouter tous les éléments d'un ensemble à l'autre. Si le add() méthode retourne jamais true, puis il y a une différence.
Ce n'est pas différent de la comparaison de toutes les autres collections. Voir: stackoverflow.com/questions/50098/.... Bien que ce est .net, java mise en œuvre devrait être à peu près la même. Je recommande Daniel Jennings ou mbillings réponse que je suis sûr que la plus haute voté réponse viole les directives de Microsoft conditions d'utilisation.
Tout d'abord, est n'est pas utile de discuter de l'élément de commande dans un Set. Les jeux ont aucun ordre implicite. Deuxièmement, vous n'avez pas spécifié de ce que vous entendez par "égaux". Pour les collections, il pourrait être la "les deux collections contiennent le même ensemble de références à des éléments réels" ou "Tous les éléments de la collection de comparaison d'égalité (via equals()) à leur élément correspondant dans la collection B". Vous semblez vouloir la dernière définition, qui est plus délicate à mettre en œuvre.
Cette question est un doublon et la bonne réponse est ici: stackoverflow.com/questions/1565214/...

OriginalL'auteur user1582269 | 2012-08-09

-4

Sauf si vous avez besoin pour mettre en œuvre votre propre méthode pour une raison quelconque, il suffit d'utiliser h1.equals(h2). Une possible mise en œuvre est décrite ci-dessous.
1. Vérifier si le nombre d'éléments est le même. Sinon, retourne false.
2. Clone de l'ensemble 2 (si vous avez besoin de garder de l'ensemble 2 après)
3. Itérer sur l'ensemble 1, vérifier si chaque élément est trouvé dans clone de l'ensemble 2. S'il est trouvé, retirez l'ensemble 2. Si pas trouvé, retourne false.
4. Si vous avez atteint la fin des itérations et ont correspondu à chaque élément de la série 1, les ensembles sont égaux (puisque vous déjà comparé les tailles des 2 ensembles).
Exemple:
```
public boolean isIdenticalHashSet <A> (HashSet h1, HashSet h2) {
    if ( h1.size() != h2.size() ) {
        return false;
    }
    HashSet<A> clone = new HashSet<A>(h2); //just use h2 if you don't need to save the original h2
    Iterator it = h1.iterator();
    while (it.hasNext() ){
        A = it.next();
        if (clone.contains(A)){ //replace clone with h2 if not concerned with saving data from h2
            clone.remove(A);
        } else {
            return false;
        }
    }
    return true; //will only return true if sets are equal
}
```
pourriez-vous s'il vous plaît poster le code qui va rendre la compréhension plus claire..!
Ce n'est pas une bonne réponse, la réponse ci-dessous doit avoir obtenu la marque de graduation.
set1.equals(set2); serait mieux
Je ne sais pas pourquoi il a fait l'objet de votes. Il est correct avec une explication.

OriginalL'auteur nyanshak
87

Citant AbstractSet.equals(Object) javadoc:

Retourne true si l'objet donné est aussi un ensemble, les deux ensembles ont le
même taille, et chaque membre de l'ensemble est contenu dans cet ensemble.
Cela garantit que la méthode equals fonctionne correctement à travers les différents
les implémentations de l'interface.

Il est donc suffisant de simplement appeler set1.equals(set2). Il sera de retour true si et seulement si l'ensemble contient les mêmes éléments (en supposant que vous avez correctement défini equals et hashCode sur les objets dans les décors).

Nice one! Ne sais pas qui est égal à a été défini pour les jeux!
Cette réponse est la bonne, et beaucoup plus simple que l'on a accepté la réponse. +1.

OriginalL'auteur Petr Pudlák
10

Utiliser le dessous de l'expression.
```
set1.containsAll(set2) && set2.containsAll(set1)
```
Ce serait plus cher que de faire un containsAll préfixé par une vérification de la taille, je pense.

OriginalL'auteur Aaron Kurtzhals
7

En supposant que vous avez défini equals et hashcode, voici un moyen. Pas très efficace pour les grandes membres de.
1. Vérifier le nombre d'éléments dans chaque. Si elles ne sont pas égales, que vous vous êtes fait [pas égal].
2. Boucle à travers Set1. Vérifier si Set2 contient chaque élément, si ce n'est que vous vous êtes fait [pas égal]. sinon, si vous obtenez par le biais de l'ensemble, vous êtes l'égal
Mise à JOUR: je ne savais pas à propos containsAll, ce qui permet d'économiser beaucoup d'ennuis et ne fait que l'algorithme de
```
int s1 = set1.size();
int s2 = set2.size();
if (s1 !=s2) return false;
return set1.containsAll(set2);
```
pourriez-vous s'il vous plaît poster le code qui va rendre la compréhension plus claire..!
MJB pourriez vous s'il vous plaît mettre à jour le code complet pour faire understanging clair..!!
cool man merci beaucoup..!!

OriginalL'auteur MJB
4

Si vous souhaitez que les données de l'égalité puis mettre correctement en œuvre equals() et hashCode() et puis vous pouvez utiliser Collection.containsAll(...). Bien sûr, vous devez vous assurer que vous appelez cela uniquement lorsque les deux collections ont le même nombre d'éléments sinon, vous pouvez simplement dire qu'ils ne sont pas égaux.

Grand! n'avait pas rappelé.
Il est incroyable de voir comment beaucoup de choses que vous pouvez trouver dans l'API standard si vous savez où chercher. 🙂

OriginalL'auteur Aravind R. Yarram

Faire:

  setResult = set2.clone();

  if ( setResult.retainAll( set1 ) ){

   //do something with results, since the collection had differences

}

OriginalL'auteur Edmon

0

1 - Obtenir une collection(que l'on pourrait nommer "les différences") qui contient des éléments d'une collection et l'autre qui n'a pas -

Collection différences = CollectionUtils.soustraire(Collection1, Collection2);

2 - Vérifier que la taille == 0;

Si oui, - les deux collections ont les mêmes éléments;
si il y a quelques différences et puis vous devrez l'imprimer tous les articles que "les différences".

Ne sais pas si cela dépend des éléments de commande.
Je suis en comparant les collections de cette façon

OriginalL'auteur Vladislav Filin

Vous devez vous connecter pour publier un commentaire.