Hacer que el elemento ArrayList no distinga entre mayúsculas y minúsculas

Question

En mi aplicación Java necesito comparar el elemento de dos listas, ya sea similar o no.

En resumen Supongamos que tengo dos listas declarado como se muestra a continuación

List<String> a = new ArrayList<String>(); 
    a.add("one"); 
    a.add("three"); 
    a.add("two"); 
Collections.sort(a); 


List<String> a1 = new ArrayList<String>(); 
    a1.add("ONE"); 
    a1.add("two"); 
    a1.add("THREE"); 
Collections.sort(a); 

Si escribo una condición para la igualdad se produce un error ya que algunos de elemento de la lista se encuentra en diferentes casos como

if(a.equals(a1)){ 
    System.out.println("equal"); 
} else{ 
    System.out.println("not equal"); 
} 

Será mostrar el resultado "No es igual"

Así que por favor dígame cómo puedo hacer que el elemento de la lista no distinga entre mayúsculas y minúsculas en lenguaje Java solamente.

gracias y cuanto

Answer 1

¿Por qué no utilizar en su lugar un SortedSet con un comparador insensible a las mayúsculas y minúsculas? Con el comparador String.CASE_INSENSITIVE_ORDER

Su código se reduce a

Set<String> a = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); 
    a.add("one"); 
    a.add("three"); 
    a.add("two"); 


Set<String> a1 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); 
    a1.add("ONE"); 
    a1.add("two"); 
    a1.add("THREE"); 

Y CONDICIONES equals deben trabajar sin ningún problema

EDITAR modificado de acuerdo con los comentarios. Gracias a todos ustedes por corregirme.

Answer 2

Habría que hacerlo manualmente:

public boolean equalsIgnoreCase(List<String> l1, List<String> l2) { 
    if (l1.size() != l2.size()) { 
    return false; 
    } 
    Iterator<String> i1=l1.iterator(); 
    Iterator<String> i2=l2.iterator(); 
    while(i1.hasNext()) { 
    if (!i1.next().equalsIgnoreCase(i2.next()) { 
     return false; 
    } 
    } 
    return true; 
} 

Answer 3

Es necesario utilizar

Collections.sort(a, String.CASE_INSENSITIVE_ORDER); 

con el fin de resolver haciendo caso omiso caso, se puede utilizar el equalsIgnoreCase Método en String para comparar con los valores

Puede, por supuesto, crear su propio CaseIns clase ensitiveList, tenemos CaseInsensitiveSet & CaseInsensitiveMap en nuestra base de código

Answer 4

Deberá anular el método equals() en la lista para que haga lo que desee. Echa un vistazo a ArrayList.equals() actual y adáptalo para que se compare con equalsIgnoreCase en lugar de equals().

Answer 5

También puede envolver su cadena en una clase de ayuda y poner en práctica la es igual a & comparar métodos para ello.

public class StringWrapper implements Comparable<StringWrapper> { 
    private String value; 

    StringWrapper(Strig value) { 
     this.value = value; 
    } 

    @Override boolean equals(Object o) { 
     returns String.CASE_INSENSITIVE_ORDER.equals(
      (StringWrapper) o).value 
      this.value); 
    } 

    @Override int compareTo(StringWrapper sw) { 
     returns String.CASE_INSENSITIVE_ORDER.compare(
      this.value 
      sw.value);   
    } 

    @Override String toString() { 
     return this.value; 
    } 

    @Override int hashCode() { 
     return this.value.toLowerCase.hashCode(); 
    } 
} 

And then : 

List<StringWrapper> a = new ArrayList<StringWrapper>(); 
    a.add(StringWrapper("one")); 
    a.add(StringWrapper("TWO")); 
    a.add(StringWrapper("three")); 
Collections.sort(a); 

Answer 6

¿Qué le parece escribir una clase Wrapper en la lista que está utilizando, esto evitaría tener un almacenamiento incoherente de los elementos.

public class CaseInsensitiveStringList extends ArrayList<String> { 

    @Override 
    public void add(final int index, final String element) { 
     super.add(index, element.toLowerCase()); 
    } 

    @Override 
    public boolean add(final String o) { 
     return super.add(o.toLowerCase()); 
    } 

    @Override 
    public boolean addAll(final Collection<? extends String> c) { 
     final ArrayList<String> temp = new ArrayList<String>(c.size()); 
     for (final String s : c) { 
      temp.add(s.toLowerCase()); 
     } 
     return super.addAll(temp); 
    } 

    @Override 
    public boolean addAll(final int index, final Collection<? extends String> c) { 
     final ArrayList<String> temp = new ArrayList<String>(c.size()); 
     for (final String s : c) { 
      temp.add(s.toLowerCase()); 
     } 
     return super.addAll(index, temp); 
    } 
} 

Answer 7

lista de cadenas Para ordenar ignorando mayúsculas y minúsculas

Arrays.sort(myArray, Collator.getInstance());