Modo per verificare se due raccolte contengono gli stessi elementi, indipendentemente dall'ordine?

Question

Diciamo che ho due diversi hashsets come mostrato di seguito come posso verificare che due Hashset contengano gli stessi elementi e questi due hashsets siano uguali, indipendentemente dall'ordine degli elementi in collezione, si prega di avvisare .. !!

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

e l'altro è ..

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

Il POJO dipendente è ...

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; 

     }*/ 
} 

Answer 1

A meno che non sia necessario implementare il proprio metodo per qualche motivo, è sufficiente utilizzare h1.equals(h2). Una possibile implementazione è descritta di seguito.

1. Verificare se il numero di elementi è uguale. In caso contrario, restituire false.
2. Clone set 2 (se è necessario mantenere il set 2 dopo)
3. Iterare attraverso il set 1, controllare se ciascun elemento è stato trovato nel set di cloni 2. Se trovato, rimuovere dal set 2. Se non trovato, restituire false.
4. Se raggiungi la fine delle iterazioni e hai abbinato ogni elemento del set 1, i set sono uguali (poiché hai già confrontato le dimensioni dei 2 set).

Esempio:

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 
} 

Answer 2

Supponendo che hai eguali definiti e codice hash, ecco un modo. Non molto efficiente per i membri di grandi dimensioni.

1. Controllare il numero di elementi in ciascuno. Se non sono uguali, hai finito [non uguale].
2. Loop through Set1. Controlla se Set2 contiene ogni elemento, altrimenti non hai [non uguale]. altrimenti se si ottiene attraverso l'intera serie, sei uguale

UPDATE: Non sapevo di containsAll, che permette di risparmiare un sacco di problemi e fondamentalmente fa che l'algoritmo

int s1 = set1.size(); 
int s2 = set2.size(); 
if (s1 !=s2) return false; 
return set1.containsAll(set2); 

Answer 3

Se si desidera che i dati l'uguaglianza quindi implementa correttamente equals() e hashCode() e quindi è possibile utilizzare Collection.containsAll(...). Ovviamente, devi assicurarti di chiamarlo solo quando entrambe le tue raccolte hanno lo stesso numero di elementi altrimenti puoi semplicemente dire che non sono uguali.

Answer 4

Do:

setResult = set2.clone(); 

    if (setResult.retainAll(set1)){ 

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

} 

Answer 5

usare l'espressione di seguito.

set1.containsAll(set2) && set2.containsAll(set1) 

Answer 6

Citando AbstractSet.equals(Object) javadoc:

Restituisce vero se l'oggetto specificato è anche un insieme, i due insiemi hanno la stessa dimensione , e ogni membro del set indicato è contenuto in questa serie . Ciò garantisce che il metodo equals funzioni correttamente tra diverse implementazioni dell'interfaccia Set.

Quindi è sufficiente chiamare semplicemente set1.equals(set2). Restituirà true se e solo se il set contiene gli stessi elementi (supponendo che sia stato definito correttamente equals e sugli oggetti nei set).