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





collections duplicates (25)


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

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




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

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

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




        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]



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




यहां एक तरीका है जो आपकी सूची ऑर्डरिंग को प्रभावित नहीं करता है:

ArrayList l1 = new ArrayList();
ArrayList l2 = new ArrayList();

Iterator iterator = l1.iterator();

        while (iterator.hasNext())
        {
            YourClass o = (YourClass) iterator.next();
            if(!l2.contains(o)) l2.add(o);
        }

l1 मूल सूची है, और एल 2 दोहराए गए आइटमों के साथ सूची है (सुनिश्चित करें कि आपके क्लास के बराबर विधि है जो आप समानता के लिए खड़े रहना चाहते हैं)




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

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



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

ImmutableSet.copyOf(list);



import java.util.*;
class RemoveDupFrmString
{
    public static void main(String[] args)
    {

        String s="appsc";

        Set<Character> unique = new LinkedHashSet<Character> ();

        for(char c : s.toCharArray()) {

            System.out.println(unique.add(c));
        }
        for(char dis:unique){
            System.out.println(dis);
        }


    }
}



मान लें कि हमारे पास 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 का उपयोग करने की आवश्यकता है।




अगर आप अपने ऑर्डर को सुरक्षित रखना चाहते हैं तो LinkedHashSet का उपयोग करना सबसे अच्छा है। क्योंकि यदि आप इस सूची को इटरेट करके क्वेरी सम्मिलित करने के लिए पास करना चाहते हैं, तो ऑर्डर संरक्षित किया जाएगा।

इसे इस्तेमाल करे

LinkedHashSet link=new LinkedHashSet();
List listOfValues=new ArrayList();
listOfValues.add(link);

जब आप एक सूची वापस करना चाहते हैं लेकिन एक सेट नहीं चाहते हैं तो यह रूपांतरण बहुत उपयोगी होगा।




यदि आप Collection में डुप्लीकेट नहीं चाहते हैं, तो आपको यह समझना चाहिए कि आप एक Collection का उपयोग क्यों कर रहे हैं जो डुप्लिकेट की अनुमति देता है। दोहराए गए तत्वों को हटाने का सबसे आसान तरीका सामग्री को एक Set जोड़ना है (जो डुप्लिकेट की अनुमति नहीं देगा) और फिर ArrayList Set वापस जोड़ें:

List<String> al = new ArrayList<>();
// add elements to al, including duplicates
Set<String> hs = new HashSet<>();
hs.addAll(al);
al.clear();
al.addAll(hs);

बेशक, यह ArrayList में तत्वों के आदेश को नष्ट कर देता है।




कोड की यह तीन पंक्तियां ArrayList या किसी भी संग्रह से डुप्लिकेट तत्व को हटा सकती हैं।

List<Entity> entities = repository.findByUserId(userId);

Set<Entity> s = new LinkedHashSet<Entity>(entities);
entities.clear();
entities.addAll(s);



जब आप 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}




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

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

फिर, यदि आपको एक 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();

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




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

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



जावा 8 में:

List<String> deduped = list.stream().distinct().collect(Collectors.toList());

कृपया ध्यान दें कि सूची सदस्यों के लिए hashCode-equals अनुबंध फ़िल्टरिंग के लिए ठीक से काम करने के लिए सम्मानित किया जाना चाहिए।




आप नेस्टेड लूप का पालन कर सकते हैं:

ArrayList<Class1> l1 = new ArrayList<Class1>();
ArrayList<Class1> l2 = new ArrayList<Class1>();

        Iterator iterator1 = l1.iterator();
        boolean repeated = false;

        while (iterator1.hasNext())
        {
            Class1 c1 = (Class1) iterator1.next();
            for (Class1 _c: l2) {
                if(_c.getId() == c1.getId())
                    repeated = true;
            }
            if(!repeated)
                l2.add(c1);
        }



लिंक्ड हैशसेट चाल करेगा।

String[] arr2 = {"5","1","2","3","3","4","1","2"};
Set<String> set = new LinkedHashSet<String>(Arrays.asList(arr2));
for(String s1 : set)
    System.out.println(s1);

System.out.println( "------------------------" );
String[] arr3 = set.toArray(new String[0]);
for(int i = 0; i < arr3.length; i++)
     System.out.println(arr3[i].toString());

// आउटपुट: 5,1,2,3,4




यदि आप 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;
}



जावा 8 स्ट्रीम एक सूची से डुप्लिकेट तत्वों को हटाने के लिए एक बहुत ही सरल तरीका प्रदान करते हैं। विशिष्ट विधि का उपयोग करना। अगर हमारे पास शहरों की एक सूची है और हम उस सूची से डुप्लिकेट को हटाना चाहते हैं तो इसे एक ही पंक्ति में किया जा सकता है -

 List<String> cityList = new ArrayList<>();
 cityList.add("Delhi");
 cityList.add("Mumbai");
 cityList.add("Bangalore");
 cityList.add("Chennai");
 cityList.add("Kolkata");
 cityList.add("Mumbai");

 cityList = cityList.stream().distinct().collect(Collectors.toList());

सरणीसूची से डुप्लिकेट तत्वों को कैसे हटाएं




कोड:

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

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




हैशसेट या एक और सरणी सूची का उपयोग किए बिना सरणी सूची से डुप्लिकेट को हटाना संभव है।

इस कोड को आज़माएं ..

    ArrayList<String> lst = new ArrayList<String>();
    lst.add("ABC");
    lst.add("ABC");
    lst.add("ABCD");
    lst.add("ABCD");
    lst.add("ABCE");

    System.out.println("Duplicates List "+lst);

    Object[] st = lst.toArray();
      for (Object s : st) {
        if (lst.indexOf(s) != lst.lastIndexOf(s)) {
            lst.remove(lst.lastIndexOf(s));
         }
      }

    System.out.println("Distinct List "+lst);

आउटपुट है

Duplicates List [ABC, ABC, ABCD, ABCD, ABCE]
Distinct List [ABC, ABCD, ABCE]



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

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



एक विधि parseInt (स्ट्रिंग) एक प्राचीन int देता है

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

दूसरी विधि valueOf (स्ट्रिंग) एक नई इंटीजर () ऑब्जेक्ट देता है।

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);






java list collections arraylist duplicates