यह जांचने के लिए कि क्या दो संग्रहों में ऑर्डर से स्वतंत्र, समान तत्व होते हैं?

Question

मान लें कि मेरे पास दो अलग-अलग हैशसेट हैं जो नीचे दिखाए गए हैं कि मैं कैसे देख सकता हूं कि दो हैशसेट में एक ही तत्व हैं और इन दो हैशसेट समान हैं, संग्रह में तत्वों के क्रम से स्वतंत्र हैं, कृपया सलाह दें .. !!

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

और अन्य एक है ..

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

कर्मचारी POJO है ...

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

जब तक आपको किसी कारण से अपनी विधि लागू करने की आवश्यकता नहीं है, तो बस h1.equals(h2) का उपयोग करें। एक संभावित कार्यान्वयन नीचे वर्णित है।

1. जांचें कि # तत्व समान हैं या नहीं। यदि नहीं, तो झूठी वापसी करें।
2. क्लोन सेट 2 (यदि आपको बाद में सेट 2 रखना है)
3. सेट 1 के माध्यम से Iterate, जांचें कि प्रत्येक तत्व क्लोन सेट 2 में मिलता है या नहीं। यदि पाया गया है, तो सेट 2 से हटाएं। यदि नहीं मिला, तो झूठी वापसी करें।
4. यदि आप पुनरावृत्तियों के अंत तक पहुंचते हैं और सेट 1 के प्रत्येक तत्व से मेल खाते हैं, तो सेट बराबर होते हैं (क्योंकि आप पहले से ही 2 सेट के आकार की तुलना करते हैं)।

उदाहरण:

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

मान लिया जाये कि आप परिभाषित बराबरी और hashCode है, यहाँ एक तरीका है। बड़े सदस्यों के लिए बहुत कुशल नहीं है।

1. प्रत्येक में तत्वों की # जांचें। यदि वे बराबर नहीं हैं, तो आप [बराबर नहीं] किए जाते हैं।
2. सेट 1 के माध्यम से लूप। जांचें कि क्या सेट 2 में प्रत्येक तत्व होता है, यदि नहीं किया जाता है [बराबर नहीं]। अन्यथा यदि आप पूरे सेट के माध्यम से मिलता है, आप बराबर

अद्यतन कर रहे हैं: मैं containsAll है, जो मुसीबत का एक बहुत बचाता है के बारे में पता नहीं था और मूल रूप से है कि एल्गोरिथ्म

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

Answer 3

आप डेटा चाहते हैं करता है समानता के बाद equals() और hashCode() सही ढंग से कार्यान्वित करें और फिर आप Collection.containsAll(...) का उपयोग कर सकते हैं। असभ्य, आपको यह सुनिश्चित करने की ज़रूरत है कि आप इसे केवल तब कॉल करें जब आपके दोनों संग्रहों में तत्वों की संख्या समान हो, अन्यथा आप कह सकते हैं कि वे बराबर नहीं हैं।

Answer 4

है:

setResult = set2.clone(); 

    if (setResult.retainAll(set1)){ 

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

} 

Answer 5

नीचे अभिव्यक्ति का प्रयोग करें।

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

Answer 6

AbstractSet.equals(Object) जावाडोक से हवाला देते हुए:

रिटर्न सच अगर दिए गए वस्तु भी एक सेट है, दो सेट एक ही आकार, और दिए गए समूह के हर सदस्य इस सेट में निहित है है । यह सुनिश्चित करता है कि बराबर विधि सेट इंटरफ़ेस के विभिन्न कार्यान्वयन में ठीक से काम करती है।

तो बस set1.equals(set2) पर कॉल करना पर्याप्त है। यह true लौटाएगा यदि केवल और यदि सेट में एक ही तत्व होते हैं (मानते हैं कि आपने सेट में ऑब्जेक्ट्स पर equals और hashCode सही ढंग से परिभाषित किया है)।