Ignorar mayúsculas y minúsculas en Java

Para comprobar si dos cadenas de Java son iguales sin distinguir entre mayúsculas y minúsculas, usa equalsIgnoreCase(). Si necesitas cadenas normalizadas para procesarlas después, usa toUpperCase() o toLowerCase() y luego equals(). Para ordenar sin distinguir entre mayúsculas y minúsculas, usa compareToIgnoreCase().

Un String de Java es inmutable, por lo que toUpperCase() y toLowerCase() devuelven un String con el contenido convertido y dejan intacto el valor original. Estos métodos y equalsIgnoreCase() usan las reglas de conversión de mayúsculas y minúsculas de Java; no implementan el plegado completo de mayúsculas y minúsculas de Unicode propio de cada idioma. Elige el método según necesites comprobar igualdad, obtener valores normalizados u ordenar.

Ignorar mayúsculas y minúsculas con toUpperCase() en Java

Convierte ambas cadenas con toUpperCase(Locale.ROOT) y, después, compara los resultados con equals(). Locale.ROOT hace que la conversión no dependa de la configuración regional predeterminada de la máquina, lo cual resulta útil para normalizar datos de forma programática, como los identificadores. Los ejemplos habituales con caracteres ASCII no requieren una configuración regional predeterminada de inglés o de Estados Unidos.

import java.util.Locale;

public class UppercaseComparison {
    public static void main(String[] args) {
        String first = "icecream";
        String second = "IceCream";

        String normalizedFirst = first.toUpperCase(Locale.ROOT);
        String normalizedSecond = second.toUpperCase(Locale.ROOT);
        boolean equalIgnoringCase = normalizedFirst.equals(normalizedSecond);

        System.out.println(equalIgnoringCase);
    }
}

Este enfoque compara los valores String devueltos después de convertirlos. Usa Locale.ROOT cuando la conversión se destine a una comparación entre sistemas; el procesamiento de texto que tenga en cuenta el idioma puede requerir otro enfoque.

Ignorar mayúsculas y minúsculas con toLowerCase() en Java

La normalización a minúsculas sigue el mismo patrón: convierte ambas cadenas con toLowerCase(Locale.ROOT) y, después, compáralas con equals(). Indicar explícitamente la configuración regional evita que los resultados dependan de la configuración predeterminada del usuario. Usa este enfoque cuando las operaciones posteriores también necesiten los valores normalizados en minúsculas; para comprobar directamente si dos cadenas son iguales, equalsIgnoreCase() es más sencillo.

import java.util.Locale;

public class LowercaseComparison {
    public static void main(String[] args) {
        String first = "icecream";
        String second = "IceCream";

        String normalizedFirst = first.toLowerCase(Locale.ROOT);
        String normalizedSecond = second.toLowerCase(Locale.ROOT);
        boolean equalIgnoringCase = normalizedFirst.equals(normalizedSecond);

        System.out.println(equalIgnoringCase);
    }
}

Al igual que la conversión a mayúsculas, toLowerCase() devuelve un String con el contenido convertido y deja intacto el valor original; no sustituye al plegado de mayúsculas y minúsculas de Unicode propio de cada idioma.

Ignorar mayúsculas y minúsculas con equalsIgnoreCase() en Java

Para comprobar directamente si dos cadenas son iguales, llama a equalsIgnoreCase() en una de ellas y pasa la otra como argumento. Devuelve un valor booleano: true si las cadenas son iguales según la comparación de Java que ignora las mayúsculas y minúsculas, y false en caso contrario. Por ejemplo, "icecream".equalsIgnoreCase("IceCream") devuelve true.

public class IgnoreCaseEquality {
    public static void main(String[] args) {
        String first = "icecream";
        String second = "IceCream";

        boolean equalIgnoringCase = first.equalsIgnoreCase(second);
        System.out.println(equalIgnoringCase);
    }
}

La comparación no está adaptada a un idioma ni a una configuración regional concretos, y no realiza el plegado completo de mayúsculas y minúsculas de Unicode. Si una aplicación necesita reglas de comparación lingüística, usa una API diseñada para ese requisito en vez de dar por hecho que este método cubre las convenciones textuales de todos los idiomas.

Ignorar mayúsculas y minúsculas con compareToIgnoreCase() en Java

Usa compareToIgnoreCase() cuando necesites ordenar lexicográficamente sin distinguir entre mayúsculas y minúsculas, por ejemplo, al ordenar cadenas. Un resultado igual a cero significa que las cadenas se consideran iguales al ignorar las mayúsculas y minúsculas. Un resultado negativo indica que la primera cadena va antes que la segunda; uno positivo indica que va después. No se garantiza que el entero distinto de cero sea la diferencia entre los primeros caracteres que difieren.

public class IgnoreCaseOrdering {
    public static void main(String[] args) {
        String first = "apple";
        String second = "Banana";

        int comparison = first.compareToIgnoreCase(second);
        System.out.println(comparison < 0);
    }
}

El ejemplo imprime un valor booleano que indica la relación de orden. Si solo necesitas comprobar si las cadenas son iguales, usa equalsIgnoreCase().