java - मैं ArrayList से बार-बार तत्वों को कैसे हटा सकता हूं?

15 Answers

यद्यपि ArrayList को HashSet कनवर्ट करना प्रभावी रूप से डुप्लीकेट को हटा देता है, अगर आपको सम्मिलन आदेश को संरक्षित करने की आवश्यकता है, तो मैं आपको इस संस्करण का उपयोग करने का सुझाव दूंगा

// list is some List of Strings
Set<String> s = new LinkedHashSet<>(list);

फिर, यदि आपको एक List संदर्भ वापस पाने की आवश्यकता है, तो आप रूपांतरण कन्स्ट्रक्टर का फिर से उपयोग कर सकते हैं।

java list collections arraylist duplicates

मेरे पास Strings का Strings , और मैं इससे बार-बार तारों को हटाना चाहता हूं। मैं यह कैसे कर सकता हूँ?




यदि आप डुप्लिकेट नहीं चाहते हैं, तो List बजाय Set उपयोग SetList को एक Set कनवर्ट करने के लिए आप निम्न कोड का उपयोग कर सकते हैं:

// list is some List of Strings
Set<String> s = new HashSet<String>(list);

यदि वास्तव में आवश्यक है तो आप एक ही List को एक List में वापस बदलने के लिए उसी निर्माण का उपयोग कर सकते हैं।




मान लें कि हमारे पास String की एक सूची है जैसे:

List<String> strList = new ArrayList<>(5);
// insert up to five items to list.        

फिर हम कई तरीकों से डुप्लिकेट तत्वों को हटा सकते हैं।

जावा 8 से पहले

List<String> deDupStringList = new ArrayList<>(new HashSet<>(strList));

Guava का उपयोग करना

List<String> deDupStringList2 = Lists.newArrayList(Sets.newHashSet(strList));

जावा 8 का प्रयोग करना

List<String> deDupStringList3 = strList.stream().distinct().collect(Collectors.toList());

नोट: अगर हम सम्मिलन आदेश को बनाए रखना चाहते हैं तो हमें LinkedHashSet के स्थान पर LinkedHashSet का उपयोग करने की आवश्यकता है।




Guava से एक विकल्प के रूप में ImmutableSet भी है ( here प्रलेखन है):

ImmutableSet.copyOf(list);



आप इसे इस तरह से भी कर सकते हैं, और ऑर्डर को सुरक्षित रख सकते हैं:

// delete duplicates (if any) from 'myArrayList'
myArrayList = new ArrayList<String>(new LinkedHashSet<String>(myArrayList));



यह समस्या को हल कर सकता है:

private List<SomeClass> clearListFromDuplicateFirstName(List<SomeClass> list1) {

Map<String, SomeClass> cleanMap = new LinkedHashMap<String, SomeClass>();
for (int i = 0; i < list1.size(); i++) {
     cleanMap.put(list1.get(i).getFirstName(), list1.get(i));
}
List<SomeClass> list = new ArrayList<SomeClass>(cleanMap.values());
return list;
}



यदि आप किसी तृतीय-पक्ष लाइब्रेरी का उपयोग करने के इच्छुक हैं, तो आप ग्रहण संग्रह (पूर्व में जीएस संग्रह) में विधि distinct() उपयोग कर सकते हैं।

ListIterable<Integer> integers = FastList.newListWith(1, 3, 1, 2, 2, 1);
Assert.assertEquals(
    FastList.newListWith(1, 3, 2),
    integers.distinct());

एक सेट में कनवर्ट करने के बजाय distinct() का उपयोग करने का लाभ और फिर सूची में वापस यह है कि distinct() प्रत्येक सूची की पहली घटना को बनाए रखने, मूल सूची के क्रम को संरक्षित करता है। यह एक सेट और एक सूची दोनों का उपयोग करके लागू किया गया है।

MutableSet<T> seenSoFar = UnifiedSet.newSet();
int size = list.size();
for (int i = 0; i < size; i++)
{
    T item = list.get(i);
    if (seenSoFar.add(item))
    {
        targetCollection.add(item);
    }
}
return targetCollection;

यदि आप अपनी मूल सूची को ग्रहण संग्रह प्रकार में परिवर्तित नहीं कर सकते हैं, तो आप एक ही एपीआई प्राप्त करने के लिए ListAdapter का उपयोग कर सकते हैं।

MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();

नोट: मैं ग्रहण संग्रह के लिए एक कमिटर हूं।




जब आप ArrayList भर रहे हैं, तो प्रत्येक तत्व के लिए एक शर्त का उपयोग करें। उदाहरण के लिए:

    ArrayList< Integer > al = new ArrayList< Integer >(); 

    // fill 1 
    for ( int i = 0; i <= 5; i++ ) 
        if ( !al.contains( i ) ) 
            al.add( i ); 

    // fill 2 
    for (int i = 0; i <= 10; i++ ) 
        if ( !al.contains( i ) ) 
            al.add( i ); 

    for( Integer i: al )
    {
        System.out.print( i + " ");     
    }

हमें एक सरणी मिलेगी {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}




कोड:

List<String> duplicatList = new ArrayList<String>();
duplicatList = Arrays.asList("AA","BB","CC","DD","DD","EE","AA","FF");
//above AA and DD are duplicate
Set<String> uniqueList = new HashSet<String>(duplicatList);
duplicatList = new ArrayList<String>(uniqueList); //let GC will doing free memory
System.out.println("Removed Duplicate : "+duplicatList);

नोट: निश्चित रूप से, स्मृति ओवरहेड होगा।




जैसा कि पहले कहा गया है, आपको तत्वों की एकता सुनिश्चित करने के लिए सूची के बजाय सेट इंटरफ़ेस को लागू करने वाले वर्ग का उपयोग करना चाहिए। यदि आपको तत्वों का क्रम रखना है, तो सॉर्टेडसेट इंटरफ़ेस का उपयोग तब किया जा सकता है; ट्रीसेट क्लास उस इंटरफ़ेस को लागू करता है।




        List<String> result = new ArrayList<String>();
        Set<String> set = new LinkedHashSet<String>();
        String s = "ravi is a good!boy. But ravi is very nasty fellow.";
        StringTokenizer st = new StringTokenizer(s, " ,. ,!");
        while (st.hasMoreTokens()) {
            result.add(st.nextToken());
        }
         System.out.println(result);
         set.addAll(result);
        result.clear();
        result.addAll(set);
        System.out.println(result);

output:
[ravi, is, a, good, boy, But, ravi, is, very, nasty, fellow]
[ravi, is, a, good, boy, But, very, nasty, fellow]



for(int a=0;a<myArray.size();a++){
        for(int b=a+1;b<myArray.size();b++){
            if(myArray.get(a).equalsIgnoreCase(myArray.get(b))){
                myArray.remove(b); 
                dups++;
                b--;
            }
        }
}



public Set<Object> findDuplicates(List<Object> list) {
        Set<Object> items = new HashSet<Object>();
        Set<Object> duplicates = new HashSet<Object>();
        for (Object item : list) {
            if (items.contains(item)) {
                duplicates.add(item);
                } else { 
                    items.add(item);
                    } 
            } 
        return duplicates;
        }



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

public static Object[] removeDuplicate(Object[] inputArray)
{
    long startTime = System.nanoTime();
    int totalSize = inputArray.length;
    Object[] resultArray = new Object[totalSize];
    int newSize = 0;
    for(int i=0; i<totalSize; i++)
    {
        Object value = inputArray[i];
        if(value == null)
        {
            continue;
        }

        for(int j=i+1; j<totalSize; j++)
        {
            if(value.equals(inputArray[j]))
            {
                inputArray[j] = null;
            }
        }
        resultArray[newSize++] = value;
    }

    long endTime = System.nanoTime()-startTime;
    System.out.println("Total Time-B:"+endTime);
    return resultArray;
}



सेट या हैशमैप इत्यादि जैसी किसी भी अन्य डेटा संरचना का उपयोग किए बिना मेरा जवाब यहां दिया गया है।

public static <T> ArrayList<T> uniquefy(ArrayList<T> myList) {

    ArrayList <T> uniqueArrayList = new ArrayList<T>();
    for (int i = 0; i < myList.size(); i++){
        if (!uniqueArrayList.contains(myList.get(i))){
            uniqueArrayList.add(myList.get(i));
        }
    }

    return uniqueArrayList;
}


Related