mayor - comparar una cadena con otra en java

¿Cómo hago que mi comparación de cadenas sea insensible?

Question

Creé un programa Java para comparar dos cadenas:

String s1 = "Hello";
String s2 = "hello";
if (s1.equals(s2)) {
System.out.println("hai");
} else {
System.out.println("welcome");
}

Muestra "bienvenida". Entiendo que es sensible a mayúsculas y minúsculas. Pero mi problema es que quiero comparar dos cadenas sin mayúsculas y minúsculas. Es decir, espero que la salida sea hai .

Answer 1

En la API Java predeterminada tienes:

String.CASE_INSENSITIVE_ORDER

Por lo tanto, no necesita volver a escribir un comparador si debe usar cadenas con estructuras de datos ordenados.

String s = "some text here";
s.equalsIgnoreCase("Some text here");

Es lo que quiere para controles de igualdad puros en su propio código.

Solo para obtener más información sobre todo lo relacionado con la igualdad de Strings en Java. La función hashCode () de la clase java.lang.String "es sensible a mayúsculas y minúsculas":

public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}

Entonces, si quiere usar un Hashtable / HashMap con cadenas como claves, y tiene teclas como "SomeKey", "SOMEKEY" y "somekey" se ven igual, entonces tendrá que envolver su cadena en otra clase (no puede extender Cadena ya que es una clase final). Por ejemplo :

private static class HashWrap {
private final String value;
private final int hash;
public String get() {
return value;
}
private HashWrap(String value) {
this.value = value;
String lc = value.toLowerCase();
this.hash = lc.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o instanceof HashWrap) {
HashWrap that = (HashWrap) o;
return value.equalsIgnoreCase(that.value);
} else {
return false;
}
}
@Override
public int hashCode() {
return this.hash;
}
}

y luego usarlo como tal:

HashMap<HashWrap, Object> map = new HashMap<HashWrap, Object>();

Answer 2

Para ser inofensivo, puede usar

org.apache.commons.lang.StringUtils.equalsIgnoreCase(String, String)

o

org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence)

Answer 3

Puedes usar equalsIgnoreCase

Answer 4

Se puede encontrar más información sobre la cadena en la clase String y los tutoriales de cadenas

Answer 5

Tenga en cuenta que es posible que desee hacer nulos controles en ellos también antes de hacer su .equals o .equalsIgnoreCase.

Un objeto String nulo no puede llamar a un método igual.

es decir:

public boolean areStringsSame(String str1, String str2)
{
if (str1 == null && str2 == null)
return true;
if (str1 == null || str2 == null)
return false;
return str1.equalsIgnoreCase(str2);
}

Answer 6

use String.equalsIgnoreCase()

Use la referencia de la API de Java para encontrar respuestas como estas.

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

http://java.sun.com/j2se/1.5.0/docs/api/

Answer 7

use s1.equalsIgnoreCase (s2)
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.Object)

Answer 8

String.equalsIgnoreCase es la opción más práctica para la comparación de cadenas ingenua e insensible a mayúsculas y minúsculas.

Sin embargo, es bueno tener en cuenta que este método no realiza el plegamiento completo ni la descomposición de mayúsculas y minúsculas, por lo que no puede realizar la coincidencia sin cassettes como se especifica en el estándar Unicode. De hecho, las API de JDK no proporcionan acceso a la información sobre los datos de caracteres plegables de mayúsculas y minúsculas, por lo que este trabajo se delega mejor en una biblioteca de terceros probada y probada.

Esa biblioteca es ICU , y aquí es cómo se podría implementar una utilidad para la comparación de cadenas insensibles a mayúsculas y minúsculas:

import com.ibm.icu.text.Normalizer2;
// ...
public static boolean equalsIgnoreCase(CharSequence s, CharSequence t) {
Normalizer2 normalizer = Normalizer2.getNFKCCasefoldInstance();
return normalizer.normalize(s).equals(normalizer.normalize(t));
}

 String brook = "flu/u0308ßchen";
String BROOK = "FLÜSSCHEN";
assert equalsIgnoreCase(brook, BROOK);

La comparación ingenua con String.equalsIgnoreCase , o String.equals en String.equals superiores o minúsculas fallará incluso esta simple prueba.

(Sin embargo, tenga en cuenta que el caso predefinido de doblar sabor getNFKCCasefoldInstance es independiente de la configuración regional; para las configuraciones UCharacter.foldCase puede ser necesario un poco más de trabajo que involucre a UCharacter.foldCase ).

Answer 9

compareToIgnoreCase usar el método compareToIgnoreCase del objeto String .

int compareValue = str1.compareToIgnoreCase(str2);

if (compareValue == 0) significa que str1 es igual a str2 .

Answer 10

import java.lang.String; //contains equalsIgnoreCase()
/*
*
*/
String s1 = "Hello";
String s2 = "hello";
if (s1.equalsIgnoreCase(s2)) {
System.out.println("hai");
} else {
System.out.println("welcome");
}

Ahora saldrá: hai

Answer 11

public boolean newEquals(String str1, String str2)
{
int len = str1.length();
int len1 = str2.length();
if(len==len1)
{
for(int i=0,j=0;i<str1.length();i++,j++)
{
if(str1.charAt(i)!=str2.charAt(j))
return false;
}`enter code here`
}
return true;
}

Answer 12

• Lo mejor sería usar s1.equalsIgnoreCase(s2) : (ver javadoc )
• También puede convertirlos a mayúsculas / minúsculas y usar s1.equals(s2)