¿Cómo elimino elementos repetidos de ArrayList?

Question

Yo tengo un ArrayList<String>, y quiero eliminar cadenas repetidas.¿Cómo puedo hacer esto?

Answer 1

Si no desea duplicados en un Collection, debe considerar por qué está usando un Set que permite duplicados. La forma más fácil de eliminar elementos repetidos es agregar el contenido a un ArrayList (que no permitirá duplicados) y luego agregar el <=> nuevamente al <=>:

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

Por supuesto, esto destruye el orden de los elementos en el <=>.

Answer 2

Aunque la conversión de ArrayList a HashSet elimina eficazmente los duplicados, si necesita preservar el orden de inserción, prefiero sugerirle que use esta variante

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

Luego, si necesita recuperar una referencia List, puede usar nuevamente el constructor de conversión.

Answer 3

En Java 8:

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

Tenga en cuenta que hashCode-equals para los miembros de la lista debe respetarse para que el filtrado funcione correctamente.

Answer 4

Si no desea duplicados, use un Establecer en lugar de un List. Para convertir un Set en un <=> puede usar el siguiente código:

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

Si es realmente necesario, puede usar la misma construcción para convertir un <=> de nuevo en un <=>.

Answer 5

Supongamos que tenemos una lista de String como:

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

Entonces podemos eliminar elementos duplicados de múltiples maneras.

Antes de Java 8

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

Nota: Si queremos mantener el orden de inserción, debemos usar LinkedHashSet en lugar de HashSet

Usar guayaba

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

Usando Java 8

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

Nota: en caso de que queramos recopilar el resultado en una implementación de lista específica , p. LinkedList entonces podemos modificar el ejemplo anterior como:

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

Podemos usar parallelStream también en el código anterior, pero puede no proporcionar los beneficios de rendimiento esperados. Consulte esta pregunta para obtener más información.

Answer 6

También puede hacerlo de esta manera y preservar el orden:

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

Answer 7

Aquí hay una manera que no afecta el orden de su lista:

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 es la lista original y l2 es la lista sin elementos repetidos (Asegúrese de que YourClass tenga el método de igualdad de acuerdo con lo que desea representar para la igualdad)

Answer 8

Las secuencias Java 8 proporcionan una forma muy simple de eliminar elementos duplicados de una lista. Usando el método distinto. Si tenemos una lista de ciudades y queremos eliminar duplicados de esa lista, se puede hacer en una sola línea:

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

Cómo eliminar duplicados elementos de una lista de arrays

Answer 9

También hay < code> ImmutableSet de Guava como una opción ( aquí está la documentación):

ImmutableSet.copyOf(list);

Answer 10

Es posible eliminar duplicados de la lista de matrices sin usar HashSet o una lista de matrices más .

Pruebe este código ..

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

La salida es

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

Answer 11

esto puede resolver el problema:

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

Probablemente un poco exagerado, pero disfruto este tipo de problema aislado. :)

Este código utiliza un conjunto temporal (para la verificación de unicidad) pero elimina elementos directamente dentro de la lista original. Dado que la eliminación de elementos dentro de una ArrayList puede inducir una gran cantidad de copia de la matriz, se evita el método remove (int).

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

Mientras estamos en ello, aquí hay una versión para LinkedList (¡mucho mejor!):

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

Use la interfaz de marcador para presentar una solución unificada para List:

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

EDITAR: Supongo que los genéricos realmente no agregan ningún valor aquí ... Oh, bueno. :)

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

Si está dispuesto a usar una biblioteca de terceros, puede usar el método distinct () en Colecciones Eclipse (anteriormente colecciones GS).

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

La ventaja de usar distinct () en lugar de convertir a un Set y luego volver a una Lista es que distinct () conserva el orden de la Lista original, conservando La primera aparición de cada elemento. Se implementa utilizando un conjunto y una lista.

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;

Si no puede convertir su Lista original en un tipo de Colecciones de Eclipse, puede usar ListAdapter para obtener la misma API.

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

Nota: soy un confirmador de Eclipse Collections.

Answer 15

Estas tres líneas de código pueden eliminar el elemento duplicado de ArrayList o de cualquier colección.

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

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

Answer 16

Cuando esté completando ArrayList, use una condición para cada elemento. Por ejemplo:

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

Obtendremos una matriz {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Answer 17

Si desea conservar su pedido, lo mejor es utilizar LinkedHashSet . Porque si desea pasar esta lista a una consulta de inserción al iterarla, el orden se conservará.

Prueba esto

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

Esta conversión será muy útil cuando desee devolver una Lista pero no un Conjunto.

Answer 18

Código :

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

Nota: Definitivamente, habrá sobrecarga de memoria.

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

Si está utilizando el tipo de modelo Lista < T > / ArrayList < T > . Espero que sea de ayuda.

---

Aquí está mi código sin usar ninguna otra estructura de datos como set o 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 hará el truco.

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

// salida: 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

Esto se utiliza para su lista de objetos personalizados

   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

puede usar el bucle anidado de la siguiente manera:

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

Como se dijo antes, debe usar una clase que implemente la interfaz Set en lugar de List para asegurarse de la unicidad de los elementos. Si tiene que mantener el orden de los elementos, se puede usar la interfaz SortedSet; la clase TreeSet implementa esa interfaz.

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

Si desea eliminar duplicados de ArrayList, busque la lógica siguiente,

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