Modificar una lista de arreglos en Java

Question

Deseo buscar a través de un ArrayLst y eliminar las entradas que sean iguales.

Por ejemplo, si mi lista era: manzana, naranja, plátano, pera, melocotón, naranja,

luego "naranja" se suprimiría (ambas ocurrencias).

Ingenuamente, he intentado:

for(String word : userlist){ 

for(String otherword : userlist){ 

... 
} 
} 

donde escribí cómo .Remove (lastIndexOf (userword)) si es igual a la palabra y sus índices son diferentes.

Esto dio lugar a una excepción tras otra, y rápidamente me di cuenta de que estaba manipulando una lista mientras la repetía, lo que hacía que todo saliera mal.

Así que decidimos hacer una copia de la lista

ArrayList<String> copylist = userlist; 

for(String word : copylist){ 

    for(String otherword : copylist){ 

    if(word.equalsIgnoreCase(otherword) 
      && copylist.lastIndexOf(word)!=copylist.lastIndexOf(otherword)){ 

userlist.remove(userlist.lastIndexOf(word)); 
userlist.remove(userlist.lastIndexOf(otherword)); 
    } 

    } 
    } 

así que he intentado esto, y tenía problemas similares. Notablemente ConcurrentModificationException. Después de ajustarlo no puedo entenderlo, lo que en mi cabeza debería ser un proceso bastante fácil, para trabajar en Java. Por favor ayuda.

Answer 1

Actualmente no estás haciendo una copia de la lista. Estás declarando una nueva variable que tiene una referencia a la misma lista. Para hacer una copia de la lista, utilice:

ArrayList<String> copyList = new ArrayList<String>(userList); 

Sin embargo, me gustaría sugerir un enfoque diferente:

ArrayList<String> wordsToRemove = new ArrayList<String>(); 
Set<String> seenWords = new HashSet<String>(); 

for (String word : userList) 
{ 
    if (!seenWords.add(word)) 
    { 
     wordsToRemove.add(word); 
    } 
} 

for (String word : wordsToRemove) 
{ 
    // Keep removing it until it doesn't exist any more 
    while (userList.remove(word)) {} 
} 

Este no ignoran caso, sin embargo. Para hacer eso, tiene que ser un poco más inteligente:

Set<String> wordsToRemove = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); 
Set<String> seenWords = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); 

for (String word : userList) 
{ 
    if (!seenWords.add(word)) 
    { 
     wordsToRemove.add(word); 
    } 
} 

// Now we know the words we don't want, step through the list again and 
// remove them (case-insensitively, as wordsToRemove is case-insensitive) 
for (Iterator<String> iterator = userList.iterator(); it.hasNext() ;) 
{ 
    if (wordsToRemove.contains(word)) 
    { 
     iterator.remove(); 
    } 
} 

Answer 2

ArrayList<String> copylist = userlist; 

Esta línea asigna la lista de usuarios referencia a la lista de copia y no crea nuevo ArrayList. Apunta a la misma lista de arrays. Para hacer una nueva lista, la manera simple es crear una nueva lista y seguir agregando elementos en esta nueva lista después de verificar si el elemento ya está presente en la nueva lista o no.

ArrayList<String> newList = new ArrayList<String>(); 

foreach(String item in userList) { 
    if(newList.contains(item)==false) 
    { 
      newList.add(item); 
    } 
} 

Answer 3

Es un problema bien conocido: no se puede modificar el contenedor iterado. El truco para resolver es el uso del método remove del iterador:

Iterator<String> tblIter = array.iterator(); 
    while (tblIter.hasNext()) { 
     String entry = tblIter.next(); 
     if(entry.equals(.....)) 
     { 
      ... 
      tblIter.remove(); 
     } 
    } 

Answer 4

Si desea eliminar el elemento durante la iteración a través de la colección que ha de usar Iterator y Iterator.remove()

pero me gustaría para sugerirle una solución más fácil: ponga su lista en conjunto. Se elimina automáticamente los duplicados:

List<String> mylist = new ArrayList<String>(); 
// some initialization: there are duplicates 

Set<String> myset = new HashSet<String>(mylist); // no duplicates here. 

Puede seguir utilizando conjunto, ya que es recogida y se puede iterar sobre ella.Pero si necesita acceso aleatorio lista crea de nuevo:

newlist = new ArrayList<String>(myset); 

Los elementos de pedido en conjunto será "al azar" como resultado de hash. Si desea conservar el orden original, utilice LinkedHashSet en lugar de HashSet.

Answer 5

Si usted tiene control sobre cómo se agregan datos, puede crear su propio método de "añadir", algo como esto:

add(element) 
{ 
    if arrayList.contains(element) 
     arrayList.remove(arrayList.indexOf(element)) 

    else 
     arrayList.add(element) 
} 

por otro lado, si usted no tiene control sobre cómo/cuándo los datos se agregan, puede hacer un ciclo y tener una lógica similar a la anterior. Eche un vistazo a here para conocer los métodos apropiados.

Answer 6

import java.util.ArrayList; 
import java.util.HashSet; 
import java.util.List; 
import java.util.Set; 


public class Test { 
    public static void main(String[] args) { 
     List<String> a = new ArrayList<String>(); 
     a.add("apple"); 
     a.add("orange"); 
     a.add("banana"); 
     a.add("pear"); 
     a.add("peach"); 
     a.add("orange"); 
     System.out.println(a); 
     System.out.println(getSingleWordList(a)); 
    } 
    private static List<String> getSingleWordList(List<String> list) 
    { 
     Set<String> uniques = new HashSet<String>(); 
     Set<String> dups = new HashSet<String>(); 

     for (String a : list) 
      if (!uniques.add(a)) 
       dups.add(a); 


     uniques.removeAll(dups); 

     return new ArrayList<String>(uniques); 
    } 
} 

SALIDA

Input = [apple, orange, banana, pear, peach, orange]

Output = [pear, apple, banana, peach]

Answer 7

Si el objetivo es una colección sin elementos duplicados, analizar si una sería más apropiado que una lista.