क्या वहां कोई डुप्लिकेट सूची कार्यान्वयन नहीं है?

Question

मुझे SortedSet के बारे में पता है, लेकिन मेरे मामले में मुझे ऐसा कुछ चाहिए जो List लागू करता है, और Set नहीं। तो क्या एपीआई या अन्य जगहों पर वहां कोई कार्यान्वयन है?

मुझे खुद को लागू करना मुश्किल नहीं होना चाहिए, लेकिन मुझे लगा कि लोगों को पहले यहां क्यों नहीं पूछना चाहिए?

Answer 1

ऐसा करने के लिए मानक पुस्तकालय में कोई जावा संग्रह नहीं है। LinkedHashSet<E>List के समान क्रमबद्ध करने के लिए संरक्षित करता है, हालांकि, यदि आप List में अपना सेट लपेटते हैं तो आप List के रूप में इसका उपयोग करना चाहते हैं तो आपको वह अर्थशास्त्र मिलेगा जो आप चाहते हैं। SetUniqueList/SetUniqueList<E>:

वैकल्पिक रूप से, Commons Collections (या commons-collections4, जेनेरिक वर्जन के लिए) जो कि आप पहले से ही चाहते हैं करता है एक List है।

Answer 2

क्यों प्रकार की तरह एक सूची के साथ एक सेट संपुटित नहीं,:

new ArrayList(new LinkedHashSet()) 

यह जो संग्रह ;-)

Answer 3

documentation for collection interfaces के एक असली मालिक है किसी के लिए अन्य कार्यान्वयन के पत्तों का कहना है:

सेट - एक संग्रह जिसमें डुप्लिकेट तत्व नहीं हो सकते हैं।
सूची - एक आदेश दिया गया संग्रह (कभी-कभी अनुक्रम कहा जाता है)। सूची में डुप्लिकेट तत्व हो सकते हैं।

तो यदि आप डुप्लिकेट नहीं चाहते हैं, तो शायद आपको एक सूची का उपयोग नहीं करना चाहिए।

Answer 4

मेरे सिर के शीर्ष पर, सूचियां डुप्लिकेट की अनुमति देती हैं। आप विरासत विधियों को कॉल करने से पहले की जांच के लिए को तुरंत add/insert फ़ंक्शंस को ओवरराइड कर सकते हैं। व्यक्तिगत उपयोग के लिए, आप केवल add विधि का उपयोग कर सकते हैं जो आप उपयोग करते हैं, और भविष्य में प्रोग्रामर अलग-अलग तरीके से सूची का उपयोग करने का प्रयास करते समय अपवाद फेंकने के लिए दूसरों को ओवरराइड कर सकते हैं।

Answer 5

तो आखिरकार मैंने यही किया। मैं उम्मीद करता हूं कि इससे किसी की मदद होगी।

class NoDuplicatesList<E> extends LinkedList<E> { 
    @Override 
    public boolean add(E e) { 
     if (this.contains(e)) { 
      return false; 
     } 
     else { 
      return super.add(e); 
     } 
    } 

    @Override 
    public boolean addAll(Collection<? extends E> collection) { 
     Collection<E> copy = new LinkedList<E>(collection); 
     copy.removeAll(this); 
     return super.addAll(copy); 
    } 

    @Override 
    public boolean addAll(int index, Collection<? extends E> collection) { 
     Collection<E> copy = new LinkedList<E>(collection); 
     copy.removeAll(this); 
     return super.addAll(index, copy); 
    } 

    @Override 
    public void add(int index, E element) { 
     if (this.contains(element)) { 
      return; 
     } 
     else { 
      super.add(index, element); 
     } 
    } 
} 

Answer 6

आप गंभीरता से की dhiller जवाब पर विचार करना चाहिए:, इसके बजाय

1. डुप्लिकेट कम लिस्ट में अपने वस्तुओं को जोड़ने के बारे में चिंता करने की, एक सेट (किसी भी कार्यान्वयन) में शामिल करें जो कि प्रकृति फिल्टर बाहर से डुप्लीकेट्स
2. जब आपको उस विधि को कॉल करने की आवश्यकता होती है जिसके लिए एक सूची की आवश्यकता होती है, तो इसे new ArrayList(set) (या new LinkedList(set), जो भी हो) में लपेटें।

मुझे लगता है कि समाधान आप NoDuplicatesList साथ तैनात ज्यादातर विधि के साथ, कुछ मुद्दे हैं, साथ ही आपके वर्ग संग्रह में डुप्लिकेट अपने addAll() विधि को पास किए जाने के लिए जाँच संभाल नहीं करता है।

Answer 7

मुझे ऐसा कुछ चाहिए, इसलिए मैं कॉमन्स संग्रह में गया और सेटयूनिकलिस्ट का उपयोग किया, लेकिन जब मैंने कुछ प्रदर्शन परीक्षण चलाया, तो मैंने पाया कि अगर मैं सेट का उपयोग करना चाहता हूं और प्राप्त करना चाहता हूं तो यह मामले की तुलना में अनुकूल नहीं लगता है Set.toArray() विधि का उपयोग करके एक ऐरे, SetUniqueTest ने भरने के लिए 20: 1 समय लिया और फिर अन्य कार्यान्वयन की तुलना में 100,000 स्ट्रिंग्स को पार किया, जो एक बड़ा सौदा अंतर है, इसलिए यदि आप प्रदर्शन के बारे में चिंता करते हैं, तो मैं आपको सलाह देता हूं सेट का उपयोग करें और SetUniqueList उपयोग करने के बजाय एक सरणी मिलता है, जब तक आप वास्तव में, SetUniqueList के तर्क की जरूरत है तो आप अन्य समाधान की जाँच करने की आवश्यकता है ...

परीक्षण कोड मुख्य विधि:

public static void (String [] args) {

SetUniqueList pq = SetUniqueList.decorate(new ArrayList()); 
Set s = new TreeSet(); 

long t1 = 0L; 
long t2 = 0L; 
String t; 


t1 = System.nanoTime(); 
for (int i = 0; i < 200000; i++) { 
    pq.add("a" + Math.random()); 
} 
while (!pq.isEmpty()) { 
    t = (String) pq.remove(0); 
} 
t1 = System.nanoTime() - t1; 

t2 = System.nanoTime(); 
for (int i = 0; i < 200000; i++) { 
    s.add("a" + Math.random()); 
} 

s.clear(); 
String[] d = (String[]) s.toArray(new String[0]); 
s.clear(); 
for (int i = 0; i < d.length; i++) { 
    t = d[i]; 

} 
t2 = System.nanoTime() - t2; 

System.out.println((double)t1/1000/1000/1000); //seconds 
System.out.println((double)t2/1000/1000/1000); //seconds 
System.out.println(((double) t1)/t2);  //comparing results 

}

सादर मोहम्मद स्लीम http://abusleem.net/blog

Answer 8

मैं सिर्फ इस तरह अपने खुद के छोटे से पुस्तकालय में अपने ही UniqueList बनाया:

package com.bprog.collections;//my own little set of useful utilities and classes 

import java.util.HashSet; 
import java.util.ArrayList; 
import java.util.List; 
/** 
* 
* @author Jonathan 
*/ 
public class UniqueList { 

private HashSet masterSet = new HashSet(); 
private ArrayList growableUniques; 
private Object[] returnable; 

public UniqueList() { 
    growableUniques = new ArrayList(); 
} 

public UniqueList(int size) { 
    growableUniques = new ArrayList(size); 
} 

public void add(Object thing) { 
    if (!masterSet.contains(thing)) { 
     masterSet.add(thing); 
     growableUniques.add(thing); 
    } 
} 

/** 
* Casts to an ArrayList of unique values 
* @return 
*/ 
public List getList(){ 
    return growableUniques; 
} 

public Object get(int index) { 
    return growableUniques.get(index); 
} 

public Object[] toObjectArray() { 
    int size = growableUniques.size(); 
    returnable = new Object[size]; 
    for (int i = 0; i < size; i++) { 
     returnable[i] = growableUniques.get(i); 
    } 
    return returnable; 
    } 
} 

मेरे पास एक टेस्टकोलेक्शन क्लास है जो इस तरह दिखता है:

package com.bprog.collections; 
import com.bprog.out.Out; 
/** 
* 
* @author Jonathan 
*/ 
public class TestCollections { 
    public static void main(String[] args){ 
     UniqueList ul = new UniqueList(); 
     ul.add("Test"); 
     ul.add("Test"); 
     ul.add("Not a copy"); 
     ul.add("Test"); 
     //should only contain two things 
     Object[] content = ul.toObjectArray(); 
     Out.pl("Array Content",content); 
    } 
} 

ठीक काम करता है। यह सब करता है कि यह एक सेट में जोड़ता है यदि उसके पास पहले से नहीं है और वहां एक ऐरेलिस्ट है जो वापसी योग्य है, साथ ही ऑब्जेक्ट सरणी भी है।

Answer 9

add विधि में, का उपयोग क्यों नहीं करते HashSet.consist() के बजाय डुप्लिकेट की जांच करें। HashSet.add() अन्य डुप्लिकेट और false अन्यथा true वापस करेगा।

Answer 10

यहां मैंने जो किया और यह काम करता है।

मान लीजिए कि मेरे पास एक नई LinkedHashMap बनाई गई पहली चीज़ के साथ काम करने के लिए ArrayList है।

LinkedHashSet<E> hashSet = new LinkedHashSet<E>() 

फिर मैं अपना नया तत्व LinkedHashSet पर जोड़ने का प्रयास करता हूं। ऐड विधि LinkedHasSet को परिवर्तित नहीं करती है और नया तत्व डुप्लिकेट होने पर गलत लौटाता है। तो यह एक शर्त बन जाती है जिसे मैं ArrayList में जोड़ने से पहले परीक्षण कर सकता हूं।

if (hashSet.add(E)) arrayList.add(E); 

डुप्लिकेट को सरणी सूची में जोड़ने से रोकने के लिए यह एक आसान और सुरुचिपूर्ण तरीका है। यदि आप चाहते हैं कि आप ArrayList को विस्तारित करने वाली कक्षा में ऐड विधि के अंदर और ओवरराइड कर सकें। तत्वों के माध्यम से लूप करके और ऐड विधि को कॉल करके addAll से निपटने के लिए बस याद रखें।

Answer 11

नोट: यह उपसूची खाते में कार्यान्वयन नहीं करता है।

import java.util.ArrayList; 
import java.util.Collection; 
import java.util.HashSet; 
import java.util.Set; 

public class UniqueList<T> extends ArrayList<T> { 

    private static final long serialVersionUID = 1L; 

    /** Unique elements SET */ 
    private final Set<T> set=new HashSet(); 

    /** Used by addAll methods */ 
    private Collection<T> addUnique(Collection<? extends T> col) { 
     Collection<T> unique=new ArrayList(); 
     for(T e: col){ 
      if (set.add(e)) unique.add(e); 
     } 
     return unique; 
    } 

    @Override 
    public boolean add(T e) { 
     return set.add(e) ? super.add(e) : false; 
    } 

    @Override 
    public boolean addAll(Collection<? extends T> col) { 
     return super.addAll(addUnique(col)); 
    } 

    @Override 
    public void add(int index, T e) { 
     if (set.add(e)) super.add(index, e); 
    } 

    @Override 
    public boolean addAll(int index, Collection<? extends T> col) { 
     return super.addAll(index, addUnique(col)); 
    } 

}