كيف يمكنني إزالة تكرار عناصر من ArrayList?

Question

لدي ArrayList<String>, و أريد أن إزالة تكرار سلاسل من ذلك.كيف يمكن أن أفعل هذا ؟

Answer 1

إذا كنت لا تريد التكرارات في Collection، يجب عليك أن تنظر لماذا كنت تستخدم Collection الذي يسمح التكرارات. أسهل طريقة لإزالة العناصر المتكررة لإضافة المحتويات إلى Set (والتي لن تسمح مكررة) ثم قم بإضافة Set إلى ArrayList:

Set<String> set = new HashSet<>(yourList);
yourList.clear();
yourList.addAll(set);

وبطبيعة الحال، هذا يدمر ترتيب العناصر في ArrayList.

Answer 2

وعلى الرغم من تحويل ArrayList إلى HashSet فعال يزيل مكررة، إذا كنت بحاجة للحفاظ على النظام الإدراج، فما استقاموا لكم فاستقيموا بدلا أقترح عليك استخدام هذا البديل

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

وبعد ذلك، إذا كنت بحاجة إلى العودة إشارة List، يمكنك استخدامها مرة أخرى منشئ التحويل.

Answer 3

في جاوة 8:

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

تجدر الإشارة إلى أن في -يساوي شفرة التجزئة العقد لأعضاء القائمة ينبغي احترام للتصفية للعمل بشكل صحيح.

Answer 4

إذا كنت لا تريد مكررة، استخدم تعيين بدلا من ذلك من List. لتحويل List إلى Set يمكنك استخدام التعليمات البرمجية التالية:

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

إذا لزم الأمر حقا يمكنك استخدام نفس البناء لتحويل Set مرة أخرى إلى List.

Answer 5

لنفترض أن لدينا قائمة String مثل:

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

ثم يمكننا إزالة عناصر مكررة في عدة طرق.

قبل جافا 8

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

ملاحظة: إذا كنا نريد الحفاظ على الإدراج النظام ثم نحن بحاجة إلى استخدام LinkedHashSet في مكان HashSet

باستخدام الجوافة

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

باستخدام جافا 8

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

ملاحظة: في حال أردنا جمع النتيجة في قائمة محددة التنفيذ على سبيل المثال LinkedList ثم يمكننا تعديل المثال أعلاه كما يلي:

List<String> deDupStringList3 = strList.stream().distinct()
                 .collect(Collectors.toCollection(LinkedList::new));

يمكننا استخدام parallelStream أيضا في التعليمات البرمجية أعلاه ولكن قد لا تعطي المتوقع الفهرسه الفوائد.تحقق من هذا السؤال لمزيد من.

Answer 6

ويمكنك أيضا أن تفعل ذلك بهذه الطريقة، والحفاظ على النظام:

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

Answer 7

وهنا بطريقة لا تؤثر على لائحة الترتيب الخاص بك:

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 لائحة الأصلية، و L2 لائحة بدون بنود المتكررة (تأكد من YourClass لديه طريقة متساوين وفقا لما تريد الوقوف من أجل المساواة)

Answer 8

وجافا 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());

كيفية إزالة مكررة عناصر من arraylist على

Answer 9

وهناك أيضا ImmutableSet من الجوافة كخيار (<لأ href = "https://github.com/ جوجل / الجوافة / ويكي / ImmutableCollectionsExplained "يختلط =" noreferrer "> هنا هو وثائق):

ImmutableSet.copyOf(list);

Answer 10

من الممكن إزالة التكرارات من arraylist دون استخدام HashSet أو أكثر واحد arraylist.

جرب هذا الكود..

    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]

Answer 11

وهذا يمكن أن تحل المشكلة:

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

Answer 12

وربما مبالغة بعض الشيء، ولكن أنا أستمتع هذا النوع من مشكلة معزولة. :)

وهذا الرمز يستخدم مجموعة مؤقت (للتحقق التفرد) ولكن يزيل العناصر مباشرة داخل القائمة الأصلية. منذ إزالة عنصر داخل ArrayList يمكن أن تحفز على كمية كبيرة من نسخ مجموعة، يتم تجنب إزالة (الباحث) -method.

public static <T> void removeDuplicates(ArrayList<T> list) {
    int size = list.size();
    int out = 0;
    {
        final Set<T> encountered = new HashSet<T>();
        for (int in = 0; in < size; in++) {
            final T t = list.get(in);
            final boolean first = encountered.add(t);
            if (first) {
                list.set(out++, t);
            }
        }
    }
    while (out < size) {
        list.remove(--size);
    }
}

وبينما نحن في ذلك، وهنا نسخة لقائمة متصلة (أجمل كثيرا!):

public static <T> void removeDuplicates(LinkedList<T> list) {
    final Set<T> encountered = new HashSet<T>();
    for (Iterator<T> iter = list.iterator(); iter.hasNext(); ) {
        final T t = iter.next();
        final boolean first = encountered.add(t);
        if (!first) {
            iter.remove();
        }
    }
}

استخدم واجهة علامة لتقديم حل موحد للقائمة:

public static <T> void removeDuplicates(List<T> list) {
    if (list instanceof RandomAccess) {
        // use first version here
    } else {
        // use other version here
    }
}

وتحرير: أعتقد أن الأدوية الاشياء لا تضيف أي قيمة حقا هنا .. حسنا. :)

Answer 13

public static void main(String[] args){
    ArrayList<Object> al = new ArrayList<Object>();
    al.add("abc");
    al.add('a');
    al.add('b');
    al.add('a');
    al.add("abc");
    al.add(10.3);
    al.add('c');
    al.add(10);
    al.add("abc");
    al.add(10);
    System.out.println("Before Duplicate Remove:"+al);
    for(int i=0;i<al.size();i++){
        for(int j=i+1;j<al.size();j++){
            if(al.get(i).equals(al.get(j))){
                al.remove(j);
                j--;
            }
        }
    }
    System.out.println("After Removing duplicate:"+al);
}

Answer 14

إذا كنت على استعداد لاستخدام طرف ثالث مكتبة, يمكنك استخدام الأسلوب distinct() في الكسوف مجموعات (سابقا GS مجموعات).

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 للحصول على نفس API.

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

ملاحظة: أنا committer عن الكسوف مجموعات.

Answer 15

وهذه ثلاثة خطوط من التعليمات البرمجية يمكن إزالة عنصر تتكرر من ArrayList أو أي جمع.

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

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

Answer 16

وعندما كنت ملء 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}

Answer 17

إذا كنت ترغب في الحفاظ على النظام الخاص بك ثم فإنه من الأفضل استخدام LinkedHashSet.لأنه إذا كنت تريد أن تمر هذه القائمة إدراج الاستعلام عن طريق بالتكرار ، من أجل أن يتم الحفاظ عليها.

جرب هذا

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

هذا التحويل سوف تكون مفيدة جدا عندما تريد إرجاع قائمة ولكن لا مجموعة.

Answer 18

كود:

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

ملاحظة: بالتأكيد سيكون هناك ذاكرة العامة.

Answer 19

ArrayList<String> city=new ArrayList<String>();
city.add("rajkot");
city.add("gondal");
city.add("rajkot");
city.add("gova");
city.add("baroda");
city.add("morbi");
city.add("gova");

HashSet<String> hashSet = new HashSet<String>();
hashSet.addAll(city);
city.clear();
city.addAll(hashSet);
Toast.makeText(getActivity(),"" + city.toString(),Toast.LENGTH_SHORT).show();

Answer 20

إذا كنت تستخدم قائمة نوع نموذج / ArrayList . نأمل، فإنه من مساعدتك.

---

وهنا هو رمز بلادي دون استخدام أي بنية البيانات الأخرى مثل مجموعة أو hashmap

  for(int i = 0; i < Models.size(); i++) {
     for(int j = i + 1; j < Models.size(); j++)  {           

       if(Models.get(i).getName().equals(Models.get(j).getName())){    
                                Models.remove(j);

                                j--;
                            }
                        }
                    }

Answer 21

وLinkedHashSet سوف تفعل خدعة.

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

Answer 22

        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]

Answer 23

ويستخدم هذا لعهدك قائمة كائنات

   public List<Contact> removeDuplicates(List<Contact> list) {
    // Set set1 = new LinkedHashSet(list);
    Set set = new TreeSet(new Comparator() {

        @Override
        public int compare(Object o1, Object o2) {
            if (((Contact) o1).getId().equalsIgnoreCase(((Contact) o2).getId()) /*&&
                    ((Contact)o1).getName().equalsIgnoreCase(((Contact)o2).getName())*/) {
                return 0;
            }
            return 1;
        }
    });
    set.addAll(list);

    final List newList = new ArrayList(set);
    return newList;
}

Answer 24

ويمكنك استخدام حلقة متداخلة في التالي:

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

Answer 25

وكما ذكرت من قبل، يجب عليك استخدام فئة تنفيذ مجموعة واجهة عوضا عن قائمة للتأكد من حدانية العناصر. إذا كان لديك للحفاظ على ترتيب العناصر، واجهة SortedSet يمكن عندئذ استخدام. الطبقة TreeSet تنفذ تلك الواجهة.

Answer 26

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

Answer 27

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


    }
}

Answer 28

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

Answer 29

    ArrayList<String> list = new ArrayList<String>();
    HashSet<String> unique = new LinkedHashSet<String>();
    HashSet<String> dup = new LinkedHashSet<String>();
    boolean b = false;
    list.add("Hello");
    list.add("Hello");
    list.add("how");
    list.add("are");
    list.add("u");
    list.add("u");

    for(Iterator iterator= list.iterator();iterator.hasNext();)
    {
        String value = (String)iterator.next();
        System.out.println(value);

        if(b==unique.add(value))
            dup.add(value);
        else
            unique.add(value);


    }
    System.out.println(unique);
    System.out.println(dup);

Answer 30

إذا كنت تريد إزالة التكرارات من 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;
}