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

Question 1

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

अपने आप को लागू करना कठिन नहीं होना चाहिए, लेकिन मुझे लगा कि पहले यहां के लोगों से क्यों नहीं पूछा गया?

Question 2

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

वैकल्पिक रूप से, कॉमन्स कलेक्शंस (या commons-collections4, जेनेरिक संस्करण के लिए) में एक Listऐसा है जो आप पहले से ही चाहते हैं: SetUniqueList/ SetUniqueList<E>।

Question 3

यहाँ मैंने क्या किया और यह काम करता है।

यह मानते हुए कि मेरे पास ArrayListपहले काम करने के लिए एक नया काम था LinkedHashMap।

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

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

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

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

Question 4

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

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);
        }
    }
}

Question 5

सूची के साथ सेट को क्यों नहीं अलग करना चाहिए, जैसे:

new ArrayList( new LinkedHashSet() )

यह किसी ऐसे व्यक्ति के लिए अन्य कार्यान्वयन को छोड़ देता है जो संग्रह का वास्तविक स्वामी है; ;-)

Question 6

आपको गंभीरता से ढोलक के जवाब पर विचार करना चाहिए:

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

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

Question 7

मुझे कुछ इस तरह की आवश्यकता थी, इसलिए मैं कॉमन्स संग्रह में गया और इसका इस्तेमाल किया SetUniqueList, लेकिन जब मैंने कुछ प्रदर्शन परीक्षण चलाए, तो मैंने पाया कि यदि मैं एक का उपयोग करना चाहता हूं Setऔर एक विधि Arrayका उपयोग करना चाहता हूं तो यह मामले की तुलना में अनुकूलित नहीं लगता है Set.toArray()।

SetUniqueTestले लिया 1 समय: 20 पार भरने के लिए और उसके बाद 1,00,000 स्ट्रिंग्स अन्य कार्यान्वयन है, जो एक बड़ी बात अंतर नहीं है की तुलना में।

इसलिए, यदि आप प्रदर्शन के बारे में चिंता करते हैं, तो मैं आपको सेट का उपयोग करने की सलाह देता हूं औरSetUniqueList जब तक आपको वास्तव में तर्क की आवश्यकता नहीं होती है, तब तक उपयोग करने के बजाय एक सरणी प्राप्त करेंSetUniqueList , फिर आपको अन्य समाधानों की जांच करने की आवश्यकता होगी ...

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

public static void main(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

}

सादर, मोहम्मद स्लीम

Question 8

ध्यान दें: यह सबलिस्ट कार्यान्वयन को ध्यान में नहीं रखता है।

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));
    }

}

Question 9

संग्रह इंटरफेस के लिए प्रलेखन कहते हैं:

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

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

Question 10

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

Question 11

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

Question 12

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

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;
    }
}

मेरे पास एक TestCollections वर्ग है जो इस तरह दिखता है:

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);
    }
}

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