Diferencia entre equals() y equalsIgnoreCase()

Ambos métodos comparan cadenas de texto (String), pero con una diferencia importante:

equals() - Distingue mayúsculas y minúsculas

    
public class EjemploEquals {
    public static void main(String[] args) {
        String palabra1 = "HOLA";
        String palabra2 = "hola";
        
        if (palabra1.equals(palabra2)) {
            System.out.println("Son iguales");
        } else {
            System.out.println("Son diferentes");
        }
    }
}
    

Resultado: Son diferentes ❌

Porque "HOLA" ≠ "hola" (las mayúsculas y minúsculas son diferentes)

equalsIgnoreCase() - Ignora mayúsculas y minúsculas

    
public class EjemploEqualsIgnoreCase {
    public static void main(String[] args) {
        String palabra1 = "HOLA";
        String palabra2 = "hola";
        
        if (palabra1.equalsIgnoreCase(palabra2)) {
            System.out.println("Son iguales");
        } else {
            System.out.println("Son diferentes");
        }
    }
}
    

Resultado: Son iguales ✓

Porque ignora si las letras están en mayúscula o minúscula.

Comparación	equals()	equalsIgnoreCase()
"HOLA" vs "HOLA"	✓ true	✓ true
"hola" vs "hola"	✓ true	✓ true
"HOLA" vs "hola"	❌ false	✓ true
"Hola" vs "hOlA"	❌ false	✓ true

¿Cuándo usar cada uno?

• equals(): Cuando las mayúsculas/minúsculas son importantes (contraseñas, códigos exactos)
• equalsIgnoreCase(): Cuando no importan las mayúsculas (nombres de usuarios, búsquedas)

Uso del metodo equalsIgnoreCase()

Definición

equalsIgnoreCase() es un método de la clase String en Java que compara dos cadenas ignorando diferencias entre mayúsculas y minúsculas. Devuelve true si las cadenas tienen el mismo contenido al no distinguir entre 'A' y 'a'.

Sintaxis

boolean resultado = cadena1.equalsIgnoreCase(cadena2);

• cadena1 es el String que llama al método.
• cadena2 es el String con el que se compara.
• Devuelve true o false.

Advertencia: si cadena1 es null, llamar cadena1.equalsIgnoreCase(...) lanza NullPointerException. Para evitarlo, llama al método sobre una constante o comprueba null antes:

if (cadena1 != null && cadena1.equalsIgnoreCase(cadena2)) { ... }

O

"valor".equalsIgnoreCase(posibleNull);

¿Para qué sirve?

Se usa cuando quieres comparar textos sin importar si están en mayúsculas o minúsculas: validaciones de entrada del usuario, comprobaciones de comandos, igualdad de nombres, opciones de menú, etc.

3 ejemplos

Ejemplo 1 — Comparación simple

String a = "Hola";
String b = "hola";

if (a.equalsIgnoreCase(b)) {
    System.out.println("Son iguales ignorando mayúsculas/minúsculas"); // se imprime
} else {
    System.out.println("Diferentes");
}
    

Ejemplo 2 — Entrada del usuario (Scanner)

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
System.out.print("¿Deseas continuar? (si/no): ");
String respuesta = sc.nextLine();

if ("si".equalsIgnoreCase(respuesta)) {
    System.out.println("Continuando...");
} else {
    System.out.println("Saliendo...");
}
sc.close();

Aquí se usa "si".equalsIgnoreCase(respuesta) para evitar NullPointerException si respuesta fuera null.

Ejemplo 3 — Comparación segura con posible null y múltiples opciones

 String comando = obtenerComando(); // puede devolver null

if (comando != null) {
    if (comando.equalsIgnoreCase("iniciar")) {
        iniciarProceso();
    } else if (comando.equalsIgnoreCase("detener")) {
        detenerProceso();
    } else {
        System.out.println("Comando no reconocido");
    }
} else {
    System.out.println("No se recibió ningún comando");
}
   

Errores comunes

• Usar == para comparar String en Java (compara referencias, no contenido). Usa equals() o equalsIgnoreCase().
• Llamar equalsIgnoreCase sobre una variable que puede ser null sin verificarlo.
• No normalizar cadenas con acentos o caracteres Unicode antes de comparar en aplicaciones multilenguaje.

Reglas rápidas

Situación	Recomendación
Comparar texto sin distinguir mayúsc/minúsc	cadena1.equalsIgnoreCase(cadena2)
Evitar NullPointer	"const".equalsIgnoreCase(posibleNull) o comprobar null antes
Ignorar espacios en extremos	cadena.trim().equalsIgnoreCase(otra.trim())
Comparaciones en varios idiomas	Normalizar Unicode con java.text.Normalizer antes de comparar

Conclusión

equalsIgnoreCase() es una herramienta práctica para comparar cadenas en Java cuando no interesa la diferencia entre mayúsculas y minúsculas. Aplicada correctamente (gestionando null, trim() y normalización Unicode) evita errores comunes y hace las validaciones de texto más robustas.