buscar y reemplazar cantar. carbonizarse. en un <String> elemento ArrayList

Question

Tengo interés en iteración a través de (re: buscar y reemplazar los propósitos), dicen:

List<String> someList = new ArrayList<String>(); 

donde algunalista ya se rellena en un método anterior, y consta de, por ejemplo sólo una elementos de par, a la manera de, llaman [a: bX, b: Xc],

que el de buscar y reemplazar cadena (s) de interés son, por ejemplo:

String someString = "X"; 
String otherString = "Y"; 
String contentsTBD = ""; 

Ahora, lo ideal es que pensé que podría haber repiten a lo largo algunalista así:

public void readAndReplace() { 
    for (int i = 0; i < someList.size(); i++) { 
     if (someList.get(i).contains(someString)) { 
      someList.get(i).replace(someString, otherString); 
     } else { 
      ++i; 
     } 
    } 
    System.out.print(someList); 
} 

el que la impresión debe decir:

[a:bY, b:Yc] 

Entonces, pensé que esto podría funcionar:

public void readAndReplace() { 
    for (String s : someList) { 
     contentsTBD += s; 
    } 
    for (int i = 0; i < contentsTBD.length(); i++) { 
     if (contentsTBD.contains(someString)) { 
      contentsTBD.replaceAll(someString, otherString); 
     } else { 
      ++i; 
     } 
    } 
    System.out.print(contentsTBD); 
} 

pero luego rápidamente me di cuenta de que esto no tenía sentido desde mi referencia a que estaba perdido. Cualquier consejo sería realmente útil. Gracias.

Answer 1

• En primer lugar, no está almacenando su cadena reemplazada en ninguna parte. Se fue con el viento.

• En segundo lugar, su reemplazo no modificará la lista existente. Debería establecer la nueva cadena en la ubicación existente, ya que está utilizando el for-loop tradicional. O, puede tener una nueva lista y add valores modificados a esa lista.

• Recuerde, dado que String en Java es inmutable, todos los métodos de la clase String devuelven una nueva cadena. No modifican el existente. Por lo tanto, debe reasignar el String devuelto a uno nuevo.

probar este código: -

public void readAndReplace() 
    { 
     // You can also create a new list out of the existing list. 
     // That way, you won't need to modify the existing one. 
     List<String> newList = new ArrayList<String>(); 
     for(int i = 0; i < someList .size(); i++) 
     { 
      if(someList.get(i).contains(someString)) 
      { 
       newList.add(someList.get(i).replace(someString, otherString)); 
      //someList.set(i, someList.get(i).replace(someString, otherString)); 
      } else { 

       // If it not contains `someString`, add it as it is to newList 
       newList.add(someList.get(i)); 
      } 

     } 
     System.out.println(someList); // Original 
     System.out.println(newList); // New List 

    } 

Answer 2

¿Cuál es el problema con el primer enfoque?
Debería haber funcionado si eliminas el bloque else ('i' ya se incrementará con for-loop).

Además, su segundo enfoque no tiene sentido, no está utilizando i dentro del interior de bucle, excepto para incrementarlo, que no debería ser necesario (es?)

Answer 3

El problema es que la cadena es inmutable, así que no es modificado en el lugar de su lista y hay que actualizarlo:

someList.set(i, someList.get(i).replace(someString, otherString); 

también no necesita el bloque de otra persona, o que voy a saltar un elemento más.

Answer 4

Creo que su problema se relaciona con el hecho de que las cadenas son inmutables (es decir, hay contenidos no se puede cambiar).

Esta declaración en su primer ejemplo en realidad no hacer nada ...

someList.get(i).replace(someString, otherString); 

que probablemente hacer algo como

for(int i = 0; i < someList .size(); i++) 
{ 
    String value = someList.get(i); 
    if(value.contains(someString)) 
    { 

     value = value.replace(someString, otherString); 

     someList.set(i, value); 

    } 
} 

Además, yo no sé por qué se está incrementando i en la condición else

Answer 5

Editado explicación adicional, después de la sugerencia de MadProgrammer,

Punto 1: String es Immutable, y que está tratando de modificar la cadena con someList.get(i).replace(someString, otherString); que va a funcionar, pero no se reflejan dentro de su someList, para reflejar su algunalista usted tiene que llamar a la someList.set(i)

el punto 2: su bloque else es inútil como ya incrementingi el interior del for loop

intenta esto.

String oldStr=""; 
    for (int i = 0; i < someList.size(); i++) { 
     if (someList.get(i).contains(someString)) { 
      oldStr = someList.get(i).replace(someString, otherString); 
      someList.set(i, oldStr); 
     } 
    } 
    System.out.print(someList); 

ver cómo Inmutable trabajo en java immutable

Answer 6

Usted puede intentar algo como esto:

1. almacenar los valores dentro de ArrayList en primer lugar.

2. Use Iterator ya que está usando Genéricos.

   List<String> somelist = new ArrayList<String>(); 
   
   someList.add("Y"); 
   someList.add("X"); 
   someList.add("Z"); 
   
   Iterator itr = someList.iterator(); 
   while(itr.hasNext){ 
   String a = itr.next(); 
   String b = "Y"; 
   
   if(a.contains(b)){ 
   String c = b.replace("A"); 
   System.out.println(c); 
   
   } 
   else{ 
   System.out.println(b); 
   
   } 
   

Answer 7

Sé que esta pregunta es bastante viejo, pero yo estaba buscando lo mismo y pensé que me gustaría añadir lo que he encontrado por el bien de los demás.

La manera más fácil que encontré de hacerlo es con la clase ListIterator, que es una interfaz secundaria de Iterator que está diseñada para trabajar específicamente con Lists. Hace que este tipo de operación sea bastante simple:

public void replace(List<String> list) { 
    ListIterator<String> it = list.listIterator(); 
    while(it.hasNext()) { 
     it.set(it.next().replace("old_text","new_text")); 
    } 
} 

Se obvia la necesidad de trabajar con índices, lo que es bueno.