Páginas

La raiz cuadrada en Math.pow()


la sintaxis, el funcionamiento y por qué se usa 1.0 / 4.0 (decimal) en Math.pow.

Sintaxis general de Math.pow()


Math.pow(base, exponente)

Significado:

  • base → es el número al que le vas a aplicar la potencia.
  • exponente → es el número por el cual se eleva la base.

Resultado:

Devuelve un número de tipo double que representa el resultado de base ^ exponente.

Ejemplos simples:


Math.pow(2, 3)   // 2^3 = 8
Math.pow(5, 2)   // 5^2 = 25
Math.pow(9, 0.5) // 9^(1/2) = 3 (raíz cuadrada)

en si usaremos

Math.pow(numero,1.0/n)

n= raiz en orden de n

Cómo se usa para raíces:


RaízFórmula en potenciaEquivalente con Math.pow
√x (raíz cuadrada)x^(1/2)Math.pow(x, 1.0 / 2.0)
∛x (raíz cúbica)x^(1/3)Math.pow(x, 1.0 / 3.0)
⁴√x (raíz cuarta)x^(1/4)Math.pow(x, 1.0 / 4.0)
⁵√x (raíz quinta)x^(1/5)Math.pow(x, 1.0 / 5.0)

¿Por qué se usa 1.0 / 4.0 y no 1 / 4?

Muy importante:

  • En Java, si escribes 1 / 4, ambos son enteros → resultado = 0
  • Pero si escribes 1.0 / 4.0, estás usando números tipo double,

✅ Correcto:


Math.pow(numero, 1.0 / 4.0) // calcula raíz cuarta

❌ Incorrecto:


Math.pow(numero, 1 / 4) // resultado 0 → Math.pow(numero, 0) = 1 siempre

Ejemplo explicado



double numero = 16;
double raizCuarta = Math.pow(numero, 1.0 / 4.0);
System.out.println(raizCuarta);

Cálculo interno:


1.0 / 4.0 = 0.25
16 ^ 0.25 = 2.0

✅ Resultado: 2.0

Resumen visual


OperaciónCódigoResultado si numero = 81
Raíz cuadradaMath.pow(numero, 1.0 / 2.0)9
Raíz cúbicaMath.pow(numero, 1.0 / 3.0)4.3267
Raíz cuartaMath.pow(numero, 1.0 / 4.0)3
Raíz quintaMath.pow(numero, 1.0 / 5.0)2.408

Syntaxis de un switch anidado JAVA

La sintaxis para integrar un switch dentro de otro switch en Java (lo que se llama un switch anidado) es así:


// Solicitar la primera variable
int variable1 = leer.nextInt();

switch (variable1) {
  case 1:
    // Código del primer caso

    // Solicitar la variable dentro del caso 1 (para el otro switch)
    int variable2 = leer.nextInt();

    switch (variable2) {
      case 1:
        // Código del subcaso 1
        break;
      case 2:
        // Código del subcaso 2
        break;
      default:
        // Si no coincide ningún caso del segundo switch
        break;
    }
    break; // Cerramos el case 1 del primer switch

  case 2:
    // Código del segundo caso

    // Solicitar la variable para otro switch
    int variable3 = leer.nextInt();

    switch (variable3) {
      case 1:
        // Código del subcaso 1
        break;
      case 2:
        // Código del subcaso 2
        break;
      default:
        // Si no coincide ningún caso del segundo switch
        break;
    }
    break; // Cerramos el case 2 del primer switch

  default:
    // Si no coincide ningún caso del primer switch
    break;
}

ejemplo:


import java.util.Scanner;

public class EjemploSwitchAnidado {
    public static void main(String[] args) {
        Scanner leer = new Scanner(System.in);

        System.out.println("=== MENÚ PRINCIPAL ===");
        System.out.println("1. Operaciones básicas");
        System.out.println("2. Operaciones con raíces");
        System.out.print("Elige una opción: ");
        int variable1 = leer.nextInt(); // primera decisión

        switch (variable1) {
            case 1:
                // Primer submenú
                System.out.println("\n--- Operaciones Básicas ---");
                System.out.println("1. Sumar");
                System.out.println("2. Restar");
                System.out.println("3. Multiplicar");
                System.out.println("4. Dividir");
                System.out.print("Elige una opción: ");
                int variable2 = leer.nextInt(); // segunda decisión

                System.out.print("Ingresa el primer número: ");
                double num1 = leer.nextDouble();
                System.out.print("Ingresa el segundo número: ");
                double num2 = leer.nextDouble();

                switch (variable2) {
                    case 1:
                        System.out.println("Resultado: " + (num1 + num2));
                        break;
                    case 2:
                        System.out.println("Resultado: " + (num1 - num2));
                        break;
                    case 3:
                        System.out.println("Resultado: " + (num1 * num2));
                        break;
                    case 4:
                        if (num2 != 0)
                            System.out.println("Resultado: " + (num1 / num2));
                        else
                            System.out.println("Error: división entre cero");
                        break;
                    default:
                        System.out.println("Opción no válida en el submenú.");
                        break;
                }
                break; // cierra el case 1 del primer switch

            case 2:
                // Segundo submenú
                System.out.println("\n--- Operaciones con Raíces ---");
                System.out.println("1. Raíz cuadrada");
                System.out.println("2. Raíz cúbica");
                System.out.println("3. Raíz cuarta");
                System.out.print("Elige una opción: ");
                int variable3 = leer.nextInt(); // segunda decisión en este caso

                System.out.print("Ingresa un número: ");
                double numero = leer.nextDouble();

                switch (variable3) {
                    case 1:
                        System.out.println("Raíz cuadrada: " + Math.sqrt(numero));
                        break;
                    case 2:
                        System.out.println("Raíz cúbica: " + Math.cbrt(numero));
                        break;
                    case 3:
                        System.out.println("Raíz cuarta: " + Math.pow(numero, 1.0 / 4.0));
                        break;
                    default:
                        System.out.println("Opción no válida en el submenú de raíces.");
                        break;
                }
                break; // cierra el case 2 del primer switch

            default:
                System.out.println("Opción no válida en el menú principal.");
                break;
        }

        leer.close();
    }
}

Qué hace este programa:

  • Muestra un menú principal con dos opciones: 1. Operaciones básicas y 2. Operaciones con raíces.
  • Si eliges 1, se abre un submenú para sumar, restar, multiplicar o dividir (usando switch dentro del switch).
  • Si eliges 2, se abre otro submenú con opciones de raíces usando los métodos de Math.

ahora con opcion de salida:


import java.util.Scanner;

public class CalculadoraSwitchAnidado {
    public static void main(String[] args) {
        Scanner leer = new Scanner(System.in);
        int variable1;

        do {
            System.out.println("\n=== MENÚ PRINCIPAL ===");
            System.out.println("1. Operaciones básicas");
            System.out.println("2. Operaciones con raíces");
            System.out.println("3. Salir");
            System.out.print("Elige una opción: ");
            variable1 = leer.nextInt(); // opción del menú principal

            switch (variable1) {
                case 1:
                    System.out.println("\n--- Operaciones Básicas ---");
                    System.out.println("1. Sumar");
                    System.out.println("2. Restar");
                    System.out.println("3. Multiplicar");
                    System.out.println("4. Dividir");
                    System.out.print("Elige una opción: ");
                    int variable2 = leer.nextInt(); // submenú de operaciones básicas

                    System.out.print("Ingresa el primer número: ");
                    double num1 = leer.nextDouble();
                    System.out.print("Ingresa el segundo número: ");
                    double num2 = leer.nextDouble();

                    switch (variable2) {
                        case 1:
                            System.out.println("Resultado: " + (num1 + num2));
                            break;
                        case 2:
                            System.out.println("Resultado: " + (num1 - num2));
                            break;
                        case 3:
                            System.out.println("Resultado: " + (num1 * num2));
                            break;
                        case 4:
                            if (num2 != 0)
                                System.out.println("Resultado: " + (num1 / num2));
                            else
                                System.out.println("Error: división entre cero");
                            break;
                        default:
                            System.out.println("Opción no válida en el submenú.");
                            break;
                    }
                    break;

                case 2:
                    System.out.println("\n--- Operaciones con Raíces ---");
                    System.out.println("1. Raíz cuadrada");
                    System.out.println("2. Raíz cúbica");
                    System.out.println("3. Raíz cuarta");
                    System.out.println("4. Raíz quinta");
                    System.out.print("Elige una opción: ");
                    int variable3 = leer.nextInt(); // submenú de raíces

                    System.out.print("Ingresa un número: ");
                    double numero = leer.nextDouble();

                    switch (variable3) {
                        case 1:
                            System.out.println("Raíz cuadrada: " + Math.sqrt(numero));
                            break;
                        case 2:
                            System.out.println("Raíz cúbica: " + Math.cbrt(numero));
                            break;
                        case 3:
                            System.out.println("Raíz cuarta: " + Math.pow(numero, 1.0 / 4.0));
                            break;
                        case 4:
                            System.out.println("Raíz quinta: " + Math.pow(numero, 1.0 / 5.0));
                            break;
                        default:
                            System.out.println("Opción no válida en el submenú de raíces.");
                            break;
                    }
                    break;

                case 3:
                    System.out.println("Saliendo del programa...");
                    break;

                default:
                    System.out.println("Opción no válida, intenta de nuevo.");
                    break;
            }

        } while (variable1 != 3); // el menú se repite hasta que elija salir

        leer.close();
    }
}

Cómo funciona

  • Usa un bucle do...while para repetir el menú principal hasta que el usuario elija 3 (Salir).
  • Dentro del switch principal hay dos switch anidados:
  • Uno para operaciones básicas (suma, resta, etc.).
  • Otro para raíces (cuadrada, cúbica, etc.).
  • Se usa la clase Math para los cálculos de raíces.
  • Si el usuario digita una opción incorrecta, muestra un mensaje y vuelve al menú.

Estructura de Control switch

el switch es una estructura de control que permite ejecutar diferentes bloques de código según el valor de una variable o expresión. Es una alternativa más limpia que usar muchos if-else.

Sintaxis del switch

  
switch (expresion) {
    case valor1:
        // Código si expresion == valor1
        break;

    case valor2:
        // Código si expresion == valor2
        break;

    case valor3:
        // Código si expresion == valor3
        break;

    default:
        // Código si ninguno de los casos anteriores coincide
        break;
}

  

Explicación paso a paso

  • switch (expresion)

    La expresión se evalúa una sola vez. Su resultado se compara con cada case.

    Puede ser de tipo:

    int, byte, short, char, String, o enum (tipos enumerados).

  • case valor:

    Si el valor del case coincide con el de la expresión, se ejecuta el bloque de código asociado.

  • break;

    Sirve para salir del switch una vez que se ejecuta un caso. Si no se pone break, el programa seguirá ejecutando los siguientes casos (esto se llama fall-through).

  • default:

    Se ejecuta si ningún case coincide. Es opcional, pero recomendable.

Ejemplo básico


int dia = 3;

switch (dia) {
    case 1:
        System.out.println("Lunes");
        break;
    case 2:
        System.out.println("Martes");
        break;
    case 3:
        System.out.println("Miércoles");
        break;
    case 4:
        System.out.println("Jueves");
        break;
    case 5:
        System.out.println("Viernes");
        break;
    case 6:
        System.out.println("Sábado");
        break;
    case 7:
        System.out.println("Domingo");
        break;
    default:
        System.out.println("Día inválido");
        break;
}


Salida:


Miércoles

Versión moderna (Java 14 en adelante)

Java también permite una versión más corta usando expresiones switch:

  
import java.util.Scanner;

public class Mavenproject2 {
    public static void main(String[] args) {
        Scanner leer = new Scanner(System.in);
        System.out.println("digita el numero del dia 1-7");
        int dia = leer.nextInt();
    String resultado = switch (dia) {
    case 1 -> "Lunes";
    case 2 -> "Martes";
    case 3 -> "Miércoles";
    case 4 -> "Jueves";
    case 5 -> "Viernes";
    case 6 -> "Sábado";
    case 7 -> "Domingo";
    default -> "Día inválido";
};

System.out.println(resultado);

        
        leer.close();
    }
}
  

Cuando Usamos el switch y el if

Situación Estructura Recomendación
Comparar variables con valores fijos 1,2,3,4,5 o 'A', 'B' switch Usar cuando se trabaja con una misma variable que puede tener varios valores exactos.
Comparar condiciones lógicas <, >, ==, >=, != if(){} else if(){} Usar cuando se deben evaluar expresiones lógicas o relacionales.
Evaluar varias opciones exactas switch Recomendado para múltiples casos con valores definidos (como menús u opciones).
Solo dos caminos posibles if(){} else{} Usar cuando solo hay dos resultados posibles: verdadero o falso.

Los switch en POO son para mayormente hacer menus

En los menús, el switch se usa para evaluar la opción que el usuario elige —y esa opción puede venir, por ejemplo, desde un Scanner, desde un método de un objeto, o desde un atributo.


import java.util.Scanner;

public class MenuEjemplo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int opcion;

        System.out.println("=== MENÚ DE OPCIONES ===");
        System.out.println("1. Registrar usuario");
        System.out.println("2. Mostrar usuarios");
        System.out.println("3. Salir");
        System.out.print("Selecciona una opción: ");
        opcion = sc.nextInt();

        switch (opcion) {
            case 1:
                System.out.println("Has elegido registrar un usuario.");
                break;
            case 2:
                System.out.println("Mostrando lista de usuarios...");
                break;
            case 3:
                System.out.println("Saliendo del programa...");
                break;
            default:
                System.out.println("Opción no válida.");
                break;
        }
    }
}

Entonces sí:

  • El switch sirve para controlar menús (uno de sus usos más comunes).
  • Se usa para evaluar la opción que el usuario selecciona.
  • Puede estar dentro de un objeto (como una clase Menu, Tienda, Sistema, etc.).

Diferencia entre else if y if anidados

Ambos permiten evaluar múltiples condiciones, pero funcionan de manera diferente:

else if - Condiciones mutuamente excluyentes

Solo se ejecuta UNA opción. Cuando encuentra una condición verdadera, ignora el resto.

    
public class EjemploElseIf {
    public static void main(String[] args) {
        int nota = 85;
        
        if (nota >= 90) {
            System.out.println("Excelente");
        } else if (nota >= 80) {
            System.out.println("Muy bien");
        } else if (nota >= 70) {
            System.out.println("Bien");
        } else {
            System.out.println("Necesitas mejorar");
        }
    }
}
    

Resultado: Muy bien

Solo imprime UNA opción, aunque 85 también es >= 70.

if anidados - Condiciones independientes dentro de otras

Evalúa condiciones una dentro de otra. Cada if interno solo se evalúa si el externo es verdadero.


public class EjemploIfAnidados {
    public static void main(String[] args) {
        boolean tieneLicencia = true;
        int edad = 20;
        
        if (tieneLicencia) {
            System.out.println("Tiene licencia");
            
            if (edad >= 18) {
                System.out.println("Puede conducir solo");
            } else {
                System.out.println("Debe ir acompañado");
            }
        }
    }
}

Comparación Visual

else if: (una sola opción)


¿nota >= 90? → NO
¿nota >= 80? → SÍ → "Muy bien" → SE DETIENE
¿nota >= 70? → No se evalúa        

if anidados:(condiciones dentro de otras)


¿tieneLicencia? → SÍ → "Tiene licencia"
    └─ ¿edad >= 18? → SÍ → "Puede conducir solo"        

Ejemplo donde se ve la diferencia clara

Con else if:


int numero = 10;

if (numero > 5) {
    System.out.println("Mayor que 5");
} else if (numero > 0) {
    System.out.println("Mayor que 0");
}

Resultado: Mayor que 5 (solo uno)

Con if independientes (no anidados):


int numero = 10;

if (numero > 5) {
    System.out.println("Mayor que 5");
}
if (numero > 0) {
    System.out.println("Mayor que 0");
}

Resultado:


Mayor que 5
Mayor que 0

(ambos se ejecutan porque son independientes)

¿Cuándo usar cada uno?

  • else if: Cuando solo quieres que se ejecute UNA opción (calificaciones, menús, categorías)
  • if anidados: Cuando necesitas verificar condiciones adicionales DENTRO de otra condición (permisos, validaciones por niveles)

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ónequals()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)

next() vs nextLine()

Método


MétodoQué leeCuándo se detieneEjemplo
next()Lee una palabra (sin espacios)Se detiene cuando encuentra un espacio o enterSi escribes Santiago José, solo leerá Santiago.
nextLine()Lee toda la línea completa (con espacios incluidos)Se detiene cuando encuentra un enterSi escribes Santiago José, leerá Santiago José.

Entonces:

    
Scanner sc = new Scanner(System.in);

System.out.print("Nombre: ");
String nombre = sc.next(); // Lee solo una palabra

System.out.print("Nombre completo: ");
String nombreCompleto = sc.nextLine(); // Lee toda la línea
       
    

Si tú escribes:

    
Santiago José
    
  • next() → toma solo “Santiago”
  • nextLine() → toma “Santiago José”

El problema con los valores en blanco (el famoso "salto fantasma")

Sucede cuando mezclas next() y nextLine(). next(), nextInt(), nextDouble(), etc. dejan un enter pendiente en el buffer del teclado.

Por Ejemplo:

    
System.out.print("Edad: ");
int edad = sc.nextInt();  // usuario escribe: 25 + ENTER

System.out.print("Nombre: ");
String nombre = sc.nextLine(); // ¡problema!
    

Aquí el nextLine() lee el ENTER pendiente del nextInt(), y por eso parece que “salta” la lectura (nombre queda vacío).

Solución:

Después de usar nextInt(), nextDouble(), o next(), consume el ENTER antes de usar nextLine():

    
System.out.print("Edad: ");
int edad = sc.nextInt();
sc.nextLine(); // <- limpia el buffer

System.out.print("Nombre completo: ");
String nombre = sc.nextLine(); // ahora sí funciona bien
    

¿Qué significa “tener cuidado con los valores en blanco o los búferes”?

  • Buffer: una especie de “memoria temporal” donde se guardan los datos que escribes antes de que el programa los lea.
  • Si el buffer tiene un ENTER pendiente, nextLine() lo toma como una línea vacía.
  • Por eso se dice “ten cuidado con los valores en blanco”, porque pueden venir de ese ENTER que quedó “guardado”.

Ejemplo limpiando buffer:

codigo con buffer:

    
        import java.util.Scanner; 
        public class Mavenproject2 { 
            public static void main(String[] args) { 
                Scanner sc = new Scanner(System.in); 
                String nombre,nombreCompleto; 
                System.out.print("Nombre: "); 

                nombre = sc.next(); // Lee solo una palabra 

                System.out.println("Nombre completo: "); 
                nombreCompleto = sc.nextLine(); // Lee toda la línea 
                System.out.println("los nombres son"); 
                System.out.println(nombre); 
                System.out.println(nombreCompleto); 
                sc.close(); 
    

Como se Arregla?

Cuando escribes JUAN SEBAS y presionas Enter:

  • next() lee solo "JUAN".
  • El espacio y el ENTER (\n) quedan en el buffer.

Entonces, cuando llega a esta línea:

nombreCompleto = sc.nextLine();

El nextLine() lee ese ENTER pendiente, y por eso no te pide escribir nada nuevo. Por eso parece que se “salta” la lectura y te deja nombreCompleto vacío.

Solución:

Tienes que limpiar el buffer antes de usar nextLine():

codigo sin buffer:

    
import java.util.Scanner;

public class Mavenproject2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String nombre, nombreCompleto;

        System.out.print("Nombre: ");
        nombre = sc.next(); // Lee solo una palabra (hasta espacio)

        sc.nextLine(); // <- Limpia el ENTER pendiente del buffer

        System.out.print("Nombre completo: ");
        nombreCompleto = sc.nextLine(); // Lee toda la línea

        System.out.println("Los nombres son:");
        System.out.println(nombre);
        System.out.println(nombreCompleto);

        sc.close();
    }
}
    

RESULTADO:

    
Nombre: JUAN
Nombre completo: JUAN SEBAS
    

La clave es esa línea:

 sc.nextLine(); // limpia el buffer

¿Cuándo aparece el problema?

El problema del "salto fantasma" solo pasa cuando mezclas distintos métodos del Scanner, por ejemplo:

  • nextInt() → deja un salto de línea pendiente.
  • next() → deja el ENTER pendiente después de la palabra.

Pero si usas solo nextLine(), no hay nada que limpiar.

ejemplo:

    
import java.util.Scanner;
public class Mavenproject2 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String nombre, nombreCompleto;

        System.out.print("Nombre: ");
        nombre = sc.nextLine();

        System.out.print("Nombre completo: ");
        nombreCompleto = sc.nextLine();

        System.out.println("Los nombres son:");
        System.out.println(nombre);
        System.out.println(nombreCompleto);

        sc.close();
    }
}

    

Resumen:

Situación¿Necesita limpiar el buffer (sc.nextLine() extra)?
Solo usas nextLine()❌ No
nextLine()✅ Sí
Quieres saltarte una línea intencionalmente✅ Sí (opcional)

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ónRecomendación
Comparar texto sin distinguir mayúsc/minúsccadena1.equalsIgnoreCase(cadena2)
Evitar NullPointer"const".equalsIgnoreCase(posibleNull) o comprobar null antes
Ignorar espacios en extremoscadena.trim().equalsIgnoreCase(otra.trim())
Comparaciones en varios idiomasNormalizar 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.