संग्रह में डुप्लीकेट ढूंढना

Question

संग्रह में डुप्लिकेट ऑब्जेक्ट्स को खोजने और चिह्नित करने का सबसे अच्छा तरीका क्या है? आइए हम कहें कि हमारे पास एक सूची व्यक्ति है और हमारी डुप्लिकेट रणनीति पहले नाम और अंतिम नाम के सटीक मिलान पर आधारित है।

1. पहचानें सभी डुप्लिकेट
2. मार्क प्रत्येक डुप्लिकेट व्यक्ति दर्शाता है कि उसे एक नकली
3. प्रत्येक डुप्लिकेट व्यक्ति के लिए है, वस्तु की पहचान यह

की डुप्लिकेट है वहाँ ऐसा करने का एक आसान तरीका है यह अमरूद के साथ?

Answer 1

आप अमरूद ऐसा करने की जरूरत नहीं है:

List<Person> people = ... 
Map<Name, Person> peopleByName = new HashMap<>(); 
for (Person person : people) { 
    // Name is a simple value class with equality based on its fields 
    Name name = new Name(person.getFirstName(), person.getLastName()); 
    Person firstPersonWithName = peopleByName.get(name); 
    if (firstPersonWithName == null) { 
    peopleByName.put(name, person); 
    } else { 
    // or whatever you do to mark a duplicate 
    person.setDuplicateOf(firstPersonWithName); 
    } 
} 

जिसके अनुसार, यदि आप एक Map के बजाय एक अमरूद Table इस्तेमाल कर सकते हैं और Name बनाने के लिए की आवश्यकता होगी, से बचने के ... पंक्ति के रूप में पहले नाम का उपयोग कुंजी और कॉलम कुंजी के रूप में अंतिम नाम, कहते हैं।

एक और विकल्प Multimaps.index का उपयोग करके अपनी सूची में सभी लोगों को सूचीबद्ध करने के लिए उपयोग करना होगा। फिर किसी विशेष नाम पर मैप किए गए लोगों की हर सूची के लिए, पहला व्यक्ति आपकी सूची से उस नाम वाला पहला व्यक्ति होगा और अन्य डुप्लीकेट होंगे।

Answer 2

व्यक्ति ऑब्जेक्ट में .equals() को ओवरराइड करने का प्रयास क्यों न करें। फिर प्रत्येक व्यक्ति को 'डुप्लिकेटऑफ' या कुछ ऑब्जेक्ट में एक नया फ़ील्ड जोड़ें।

फिर सरणी पर लूप करें, प्रत्येक व्यक्ति को दूसरों के खिलाफ जांचें। यदि व्यक्तियों का डुप्लिकेट ओएफ 'फ़ील्ड शून्य है तो इसे छोड़ दें। यदि .equals() सत्य लौटाता है तो आप 'duplicateOf' फ़ील्ड सेट कर सकते हैं।

Answer 3

कक्षा व्यक्ति को boolean equals(Object o) लागू करना होगा।

आप कहीं भी हों:

तो फिर तुम डुप्लिकेट इस तरह से पा सकते हैं Collection<Person> list;

Person[] persons = list.toArray(); 
Integer[] duplicateOf = new Integer[persons.length]; 
Arrays.fill(duplicateOf, -1); 

// For all the values in the Collection 
for (int i = 0; i < persons.length; i++) { 

    // Find the duplicate 
    for (int j = 0; j < persons.length; j++) { 
    if (persons[i].equals(persons[j]) && i != j) 
     duplicateOf[j] = i; 
    } 
} 

अब आप सरणी duplicateOf जो आप इस तरह से पढ़ सकते हैं: तत्व j की डुप्लीकेट सूचकांक पर है duplicateOf[j]।

Answer 4

आप Guava's TreeMultimap का उपयोग करने का प्रयास कर सकते हैं।

आप व्यक्तियों की तुलना के लिए एक तुलनित्र के साथ आरंभ करने के लिए एक नया TreeMultimap बनाएं रूप में आप की तरह: TreeMultimap.create(Comparator, Ordering.arbitrary())

यहाँ एक इकाई परीक्षण है:

package org.test.guava; 

import java.util.Arrays; 
import java.util.Comparator; 
import java.util.List; 

import org.junit.Test; 

import com.google.common.collect.Multimap; 
import com.google.common.collect.Ordering; 
import com.google.common.collect.TreeMultimap; 

public class GuavaTest { 

    private static class Person { 
     private String name; 

     public Person(String name) { 
      this.name = name; 
     } 

     public String getName() { 
      return name; 
     } 

     @Override 
     public String toString() { 
      return "Person [name=" + name + "]"; 
     } 

    } 

    @Test 
    public void test() throws Exception { 
     List<Person> persons = Arrays.asList(new Person("person1"), new Person("person2"), new Person("person1")); 
     Comparator<Person> comparator = new Comparator<Person>() { 
      public int compare(Person o1, Person o2) { 
       return o1.getName().compareTo(o2.getName()); 
      } 
     }; 

     Multimap<Person, Person> groups = TreeMultimap.create(comparator, Ordering.arbitrary()); 
     for(Person person : persons) { 
      groups.put(person, person); 
     } 

     System.out.println(groups.asMap()); 
    } 

}