ArrayList'ten tekrarlanan öğeleri nasıl kaldırabilirim?

Bir var ArrayList<String>ve ondan tekrarlanan dizeleri kaldırmak istiyorum. Bunu nasıl yapabilirim?

A'da kopya istemiyorsanız, kopyalara Collectionneden Collectionizin veren bir kullandığınızı düşünmelisiniz . Yinelenen öğeleri kaldırmanın en kolay yolu, içeriği bir kopyaya Set(kopyalara izin vermeyecek şekilde) eklemektir ve ardından Setarkasına aşağıdakileri eklemektir ArrayList:

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

Tabii ki, bu, içindeki öğelerin sırasını yok eder ArrayList.

Her ne kadar etkin ArrayListbir HashSetşekilde dönüştürmek yinelenenleri kaldırsa da, kampanya siparişini korumanız gerekiyorsa, bu varyantı kullanmanızı öneririm

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

Daha sonra, bir Listreferansı geri almanız gerekirse , dönüşüm oluşturucuyu tekrar kullanabilirsiniz.

Java 8'de:

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

Filtrelemenin düzgün çalışması için liste üyeleri için hashCode-eşittir sözleşmesine uyulması gerektiğini lütfen unutmayın .

Şöyle bir listemiz olduğunu varsayalım String:

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

Ardından, yinelenen öğeleri birden çok şekilde kaldırabiliriz.

Java 8'den önce

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

Not: Kampanya siparişini korumak istiyorsak LinkedHashSet,HashSet

Guava'yı kullanma

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

Java 8'i kullanma

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

Not: biz sonucu toplamak istediğiniz durumda belirli liste uygulaması ör LinkedListo zaman yukarıdaki örneği olarak değiştirebilirsiniz:

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

parallelStreamYukarıdaki kodda da kullanabiliriz , ancak beklenen performans avantajları sağlamayabilir. Daha fazla bilgi için bu soruyu kontrol edin .

Kopya istemiyorsanız, yerine bir Küme kullanın List. Bir dönüştürmek için Listbir için Setaşağıdaki kodu kullanabilirsiniz:

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

Gerçekten gerekliyse, aynı yapıyı bir Setgeri dönüştürmek için kullanabilirsiniz List.

Ayrıca bu şekilde yapabilir ve düzeni koruyabilirsiniz:

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

Java 8 akışları, yinelenen öğeleri bir listeden kaldırmak için çok basit bir yol sağlar. Farklı yöntem kullanarak. Bir şehirler listemiz varsa ve bu listeden kopyaları kaldırmak istiyorsak, bu işlem tek bir satırda yapılabilir -

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

Bir arraylistten yinelenen öğeler nasıl kaldırılır

Liste sıralamanızı etkilemeyen bir yol:

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 orijinal listedir ve l2 yinelenen öğeler içermeyen listedir (Sınıfınızın eşitlik için ayakta durmak istediğiniz şeye göre eşittir yöntemine sahip olduğundan emin olun)

HashSet veya bir arraylist kullanmadan kopyaları arraylist'ten çıkarmak mümkündür .

Bu kodu deneyin ..

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

Çıktı

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

Orada da ImmutableSetgelen Guava bir seçenek (aynı burada belgelerdir):

ImmutableSet.copyOf(list);

bu sorunu çözebilir:

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

Muhtemelen biraz abartıldım, ama bu tür bir izole sorunun tadını çıkarıyorum. :)

Bu kod geçici bir Küme kullanır (benzersizlik denetimi için), ancak öğeleri doğrudan orijinal listenin içinde kaldırır. Bir ArrayList içindeki öğenin kaldırılması çok sayıda dizi kopyalamaya neden olabileceğinden, remove (int) yönteminden kaçınılır.

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

Biz oradayken, LinkedList için bir sürüm (çok daha güzel!):

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

Liste için birleştirilmiş bir çözüm sunmak için işaretleyici arabirimini kullanın:

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

DÜZENLEME: Sanırım jenerikler burada gerçekten bir değer katmıyor .. Ah güzel. :)

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

Bir üçüncü taraf kitaplığı kullanmak isteyen iseniz, yöntemi kullanabilirsiniz distinct()yılında Eclipse Koleksiyonları (eski GS Koleksiyonları).

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

Bir Kümeye distinct()dönüştürmek ve sonra tekrar Listeye dönüştürmek yerine kullanmanın avantajı distinct(), orijinal Listenin sırasını koruyarak her öğenin ilk oluşumunu koruyabilmesidir. Hem Set hem de Liste kullanılarak uygulanır.

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;

Orijinal Listenizi Eclipse Collections türüne dönüştüremiyorsanız, aynı API'yı almak için ListAdapter kullanabilirsiniz.

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

Not: Eclipse Collections için bir komisyoncuyum.

Bu üç kod satırı, çoğaltılan öğeyi ArrayList'ten veya herhangi bir koleksiyondan kaldırabilir.

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

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

ArrayList'i doldururken, her öğe için bir koşul kullanın. Örneğin:

    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} dizisi alacağız

Siparişinizi korumak istiyorsanız LinkedHashSet'i kullanmak en iyisidir . Çünkü bu listeyi yineleyerek bir ekleme sorgusuna iletmek isterseniz, sıra korunacaktır.

Bunu dene

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

Bu dönüşüm, bir Set döndürmek istediğinizde bir Set döndürmek istediğinizde çok yardımcı olacaktır.

Kod:

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

Not: Kesinlikle, bellek ek yükü olacaktır.

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

LinkedHashSet hile yapacak.

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

// çıktı: 5,1,2,3,4

        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]

Bu, Özel Nesneler listeniz için kullanılır

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

iç içe döngü aşağıdaki gibi kullanabilirsiniz:

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

Daha önce de belirtildiği gibi, öğelerin tekliğinden emin olmak için List yerine Set arabirimini uygulayan bir sınıf kullanmalısınız. Elemanların sırasını korumak zorunda kalırsanız, SortedSet arayüzü kullanılabilir; TreeSet sınıfı bu arabirimi uygular.

Model tipini kullanıyorsanız List <T> / ArrayList <T> yazın. Umarım size yardımcı olur.

İşte benim kod set veya hashmap gibi başka bir veri yapısı kullanmadan

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

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

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


    }
}

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

Yinelenenleri ArrayList'ten kaldırmak istiyorsanız, aşağıdaki mantığı bulmak anlamına gelir,

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