¿Cómo hago para que mi comparación de cadenas no distinga entre mayúsculas y minúsculas?

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 distingue entre mayúsculas y minúsculas. Pero mi problema es que quiero comparar dos cadenas sin distinción entre mayúsculas y minúsculas. Es decir, espero que la salida sea hai.

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

Utilice String.equalsIgnoreCase().

Utilice la referencia de la API de Java para encontrar respuestas como estas:

https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

https://docs.oracle.com/javase/1.5.0/docs/api/

String.equalsIgnoreCase es la opción más práctica para la comparación de cadenas ingenua que no distingue entre mayúsculas y minúsculas.

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

Esa biblioteca es ICU , y así es como se podría implementar una utilidad para la comparación de cadenas que no distingue entre 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);

Comparación ingenua con String.equalsIgnoreCase, oString.equals en cadenas mayúsculas o convertidas a mayúsculas fallará incluso esta simple prueba.

(Sin embargo, tenga en cuenta que el tipo de plegado de mayúsculas y minúsculas predefinido getNFKCCasefoldInstancees independiente de la configuración regional; para las configuraciones regionales turcas UCharacter.foldCasepuede ser necesario un poco más de trabajo )

Tienes que usar el compareToIgnoreCasemétodo del Stringobjeto.

int compareValue = str1.compareToIgnoreCase(str2);

if (compareValue == 0)significa str1iguales str2.

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

En la API de Java predeterminada tienes:

String.CASE_INSENSITIVE_ORDER

Por lo tanto, no es necesario que vuelva a escribir un comparador si usa cadenas con estructuras de datos ordenadas.

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

Es lo que desea para verificaciones de igualdad pura en su propio código.

Solo para obtener más información sobre cualquier cosa relacionada con la igualdad de cadenas en Java. La función hashCode () de la clase java.lang.String "distingue entre 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;
}

Por lo tanto, si desea usar una tabla hash / HashMap con cadenas como claves, y las claves como "SomeKey", "SOMEKEY" y "somekey" se consideran iguales, entonces tendrá que envolver su cadena en otra clase (no puede extender String 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 úselo como tal:

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

Tenga en cuenta que es posible que desee realizar comprobaciones nulas en ellos también antes de realizar 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);
}

Utilice s1.equalsIgnoreCase(s2): https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String) .

Puede utilizar equalsIgnoreCase

Puede encontrar más información sobre cadenas en Clases de cadenas y Tutoriales de cadenas

Para ser nullsafe, puede utilizar

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

o

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

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