Strings en Java

String saludo = "Hola, mundo";
String otroSaludo = "Hola, mundo";

// Ambas variables apuntan al MISMO objeto en el String Pool
System.out.println(saludo == otroSaludo); // true

String s1 = new String("Hola, mundo");
String s2 = new String("Hola, mundo");

// Son objetos DIFERENTES en memoria, aunque tengan el mismo contenido
System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true

char[] letras = {'J', 'a', 'v', 'a'};
String nombre = new String(letras);
System.out.println(nombre); // Java

// También se puede crear desde una porción del array
String sub = new String(letras, 0, 2); // "Ja"

byte[] datos = {72, 111, 108, 97};
String texto = new String(datos, java.nio.charset.StandardCharsets.UTF_8);
System.out.println(texto); // Hola

String s1 = "Java";
String s2 = new String("Java");
String s3 = s2.intern();

System.out.println(s1 == s2); // false — s2 está fuera del Pool
System.out.println(s1 == s3); // true  — intern() devuelve la referencia del Pool

String original = "Hola";
String modificado = original.toUpperCase();

System.out.println(original);   // Hola    (NO ha cambiado)
System.out.println(modificado); // HOLA    (nuevo objeto)
System.out.println(original == modificado); // false

// split(): divide un String en un array usando un delimitador (regex)
String csv = "Java,Python,C++,JavaScript";
String[] lenguajes = csv.split(",");
// lenguajes = ["Java", "Python", "C++", "JavaScript"]

for (String lang : lenguajes) {
    System.out.println(lang);
}

// String.join(): une elementos con un delimitador
String unido = String.join(" - ", lenguajes);
System.out.println(unido); // Java - Python - C++ - JavaScript

// split() con límite
String datos = "nombre:edad:ciudad:país";
String[] partes = datos.split(":", 3);
// partes = ["nombre", "edad", "ciudad:país"] — solo 3 partes

String texto = "Java";

// Convertir a array de caracteres
char[] caracteres = texto.toCharArray();
// caracteres = ['J', 'a', 'v', 'a']

// Convertir a array de bytes (UTF-8)
byte[] bytes = texto.getBytes(java.nio.charset.StandardCharsets.UTF_8);
// bytes = [74, 97, 118, 97]

String a = "Hola";
String b = "Hola";
String c = new String("Hola");

// Con literales: == funciona (mismo objeto en el Pool)
System.out.println(a == b);       // true
System.out.println(a.equals(b));  // true

// Con new: == falla (objetos diferentes)
System.out.println(a == c);       // false  ← ¡CUIDADO!
System.out.println(a.equals(c));  // true   ← Correcto

// Comparación ignorando mayúsculas
System.out.println("hola".equalsIgnoreCase("HOLA")); // true

// Orden lexicográfico
System.out.println("abc".compareTo("abd")); // -1 (c < d)
System.out.println("abc".compareTo("abc")); //  0 (iguales)
System.out.println("abd".compareTo("abc")); //  1 (d > c)

String nombre = "María";
int edad = 28;

// Concatenación simple — eficiente fuera de bucles
String mensaje = "Hola, " + nombre + ". Tienes " + edad + " años.";
System.out.println(mensaje);
// Salida: Hola, María. Tienes 28 años.

String saludo = "Hola".concat(", ").concat("mundo");
System.out.println(saludo); // Hola, mundo

// Nota: concat() solo acepta String. No convierte tipos automáticamente.
// Esto NO compila: "Edad: ".concat(28);
// Sí compila: "Edad: ".concat(String.valueOf(28));

// ❌ INEFICIENTE: crea un nuevo String en cada iteración → O(n²)
String resultado = "";
for (int i = 0; i < 10000; i++) {
    resultado += i + ", ";  // Cada += crea un objeto nuevo
}

// ✅ EFICIENTE: usar StringBuilder → O(n)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i).append(", ");
}
String resultado2 = sb.toString();

StringBuilder sb = new StringBuilder("Hola");

// append(): añade al final
sb.append(" mundo");        // "Hola mundo"

// insert(): inserta en una posición
sb.insert(5, "hermoso ");   // "Hola hermoso mundo"

// replace(): reemplaza un rango
sb.replace(5, 13, "bello"); // "Hola bello mundo"

// delete(): elimina un rango
sb.delete(5, 11);           // "Hola mundo"

// reverse(): invierte la cadena
sb.reverse();               // "odnum aloH"

// toString(): convierte a String inmutable
String resultado = sb.toString();

// Encadenamiento de métodos (method chaining)
String html = new StringBuilder()
    .append("<div>")
    .append("<p>Contenido</p>")
    .append("</div>")
    .toString();

String nombre = "Ana";
int edad = 25;
double salario = 2850.5;

// %s = String, %d = entero, %f = decimal
String info = String.format("Nombre: %s, Edad: %d, Salario: %.2f€", nombre, edad, salario);
System.out.println(info);
// Salida: Nombre: Ana, Edad: 25, Salario: 2850,50€

// Alineación y ancho
System.out.println(String.format("|%-15s|%5d|", "Producto", 42));
// Salida: |Producto       |   42|

// Relleno con ceros
System.out.println(String.format("Código: %05d", 42));
// Salida: Código: 00042

// Antes de Java 13
String json = "{\n" +
              "  \"nombre\": \"Ana\",\n" +
              "  \"edad\": 25\n" +
              "}";

// Con Text Blocks (Java 15+)
String jsonModerno = """
        {
          "nombre": "Ana",
          "edad": 25
        }
        """;

// Se pueden combinar con format
String plantilla = """
        Estimado/a %s:
        Su pedido #%d ha sido confirmado.
        Total: %.2f€
        """.formatted("Carlos", 1234, 99.95);

int numero = 42;
double decimal = 3.14;
boolean flag = true;

// Método 1: String.valueOf() — el más recomendado
String s1 = String.valueOf(numero);   // "42"
String s2 = String.valueOf(decimal);  // "3.14"
String s3 = String.valueOf(flag);     // "true"

// Método 2: concatenación con cadena vacía
String s4 = "" + numero;  // "42" — funcional pero menos explícito

// Método 3: métodos de las clases wrapper
String s5 = Integer.toString(numero);        // "42"
String s6 = Integer.toString(numero, 16);    // "2a" (hexadecimal)
String s7 = Integer.toBinaryString(numero);  // "101010" (binario)

// Conversión con control de errores
try {
    int n = Integer.parseInt("42");           // 42
    double d = Double.parseDouble("3.14");    // 3.14
    long l = Long.parseLong("1000000");       // 1000000
    boolean b = Boolean.parseBoolean("true"); // true
    
    // Nota: parseInt lanza NumberFormatException si la cadena no es válida
    int error = Integer.parseInt("abc"); // ¡NumberFormatException!
    
} catch (NumberFormatException e) {
    System.err.println("Error de conversión: " + e.getMessage());
}

String texto = "Mi teléfono es 612-345-678 y el de casa 914-222-333";

// matches(): comprueba si el String COMPLETO encaja con el patrón
System.out.println("12345".matches("\\d+")); // true (solo dígitos)
System.out.println("abc12".matches("\\d+")); // false

// replaceAll(): reemplaza TODAS las coincidencias
String sinNumeros = texto.replaceAll("\\d", "*");
System.out.println(sinNumeros);
// Mi teléfono es ***-***-*** y el de casa ***-***-***

// replaceFirst(): reemplaza solo la primera coincidencia
String primerReemplazo = texto.replaceFirst("\\d{3}-\\d{3}-\\d{3}", "[CENSURADO]");
System.out.println(primerReemplazo);
// Mi teléfono es [CENSURADO] y el de casa 914-222-333

// split() con regex
String datos = "nombre:  edad ;  ciudad";
String[] campos = datos.split("[;:]\\s*");
// campos = ["nombre", "edad", "ciudad"]

// Validación de email (patrón simplificado)
String email = "usuario@dominio.com";
boolean esValido = email.matches("[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}");
System.out.println(esValido); // true

public class ValidadorFormulario {

    /**
     * Valida un nombre de usuario.
     * Reglas: 3-20 caracteres, solo letras, números y guiones bajos.
     */
    public static String validarUsuario(String usuario) {
        if (usuario == null || usuario.isBlank()) {
            return "El nombre de usuario no puede estar vacío";
        }
        String limpio = usuario.trim();
        if (limpio.length() < 3 || limpio.length() > 20) {
            return "El usuario debe tener entre 3 y 20 caracteres";
        }
        if (!limpio.matches("[a-zA-Z0-9_]+")) {
            return "Solo se permiten letras, números y guiones bajos";
        }
        return null; // null = sin errores
    }

    /**
     * Valida un email con patrón regex.
     */
    public static String validarEmail(String email) {
        if (email == null || email.isBlank()) {
            return "El email no puede estar vacío";
        }
        String limpio = email.trim().toLowerCase();
        if (!limpio.matches("[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}")) {
            return "Formato de email no válido";
        }
        return null;
    }

    /**
     * Valida que la contraseña sea fuerte.
     * Reglas: mín 8 chars, al menos una mayúscula, una minúscula,
     *         un dígito y un carácter especial.
     */
    public static String validarPassword(String password) {
        if (password == null || password.length() < 8) {
            return "La contraseña debe tener al menos 8 caracteres";
        }
        StringBuilder errores = new StringBuilder();
        if (password.equals(password.toLowerCase())) {
            errores.append("- Falta al menos una letra mayúscula\n");
        }
        if (password.equals(password.toUpperCase())) {
            errores.append("- Falta al menos una letra minúscula\n");
        }
        if (!password.matches(".*\\d.*")) {
            errores.append("- Falta al menos un dígito\n");
        }
        if (!password.matches(".*[!@#$%^&*()_+\\-=\\[\\]{};':\",.<>?/].*")) {
            errores.append("- Falta al menos un carácter especial\n");
        }
        return errores.length() > 0 ? errores.toString() : null;
    }

    /**
     * Valida una edad proporcionada como String.
     */
    public static String validarEdad(String edadStr) {
        if (edadStr == null || edadStr.isBlank()) {
            return "La edad no puede estar vacía";
        }
        try {
            int edad = Integer.parseInt(edadStr.trim());
            if (edad < 18 || edad > 120) {
                return "La edad debe estar entre 18 y 120 años";
            }
        } catch (NumberFormatException e) {
            return "La edad debe ser un número entero válido";
        }
        return null;
    }

    /**
     * Ejecuta todas las validaciones y genera un informe.
     */
    public static String validarFormulario(String usuario, String email,
                                           String password, String edad) {
        StringBuilder informe = new StringBuilder();
        informe.append(String.format("=== Validación de registro ===%n"));
        informe.append(String.format("Usuario: %s%n", usuario));
        informe.append(String.format("Email:   %s%n%n", email));

        String[] campos = {"Usuario", "Email", "Contraseña", "Edad"};
        String[] errores = {
            validarUsuario(usuario),
            validarEmail(email),
            validarPassword(password),
            validarEdad(edad)
        };

        boolean formularioValido = true;
        for (int i = 0; i < campos.length; i++) {
            if (errores[i] != null) {
                informe.append(String.format("❌ %s: %s%n", campos[i], errores[i]));
                formularioValido = false;
            } else {
                informe.append(String.format("✅ %s: OK%n", campos[i]));
            }
        }

        informe.append(String.format("%nResultado: %s%n",
            formularioValido ? "REGISTRO VÁLIDO" : "REGISTRO RECHAZADO"));

        return informe.toString();
    }

    public static void main(String[] args) {
        // Caso 1: formulario válido
        System.out.println(validarFormulario(
            "ana_garcia", "ana@empresa.com", "Segura#2026", "28"));

        System.out.println("---");

        // Caso 2: formulario con errores
        System.out.println(validarFormulario(
            "ab", "correo-invalido", "1234", "dieciocho"));
    }
}

=== Validación de registro ===
Usuario: ana_garcia
Email:   ana@empresa.com

✅ Usuario: OK
✅ Email: OK
✅ Contraseña: OK
✅ Edad: OK

Resultado: REGISTRO VÁLIDO
---
=== Validación de registro ===
Usuario: ab
Email:   correo-invalido

❌ Usuario: El usuario debe tener entre 3 y 20 caracteres
❌ Email: Formato de email no válido
❌ Contraseña: - Falta al menos una letra mayúscula
- Falta al menos una letra minúscula
- Falta al menos un carácter especial

❌ Edad: La edad debe ser un número entero válido

Resultado: REGISTRO RECHAZADO

String input = scanner.nextLine();

// ❌ MAL: puede fallar si input no está en el Pool
if (input == "salir") { ... }

// ✅ BIEN: compara contenido siempre
if ("salir".equals(input)) { ... }

// ❌ MAL: se rompe si el usuario escribe texto
int edad = Integer.parseInt(scanner.nextLine());

// ✅ BIEN: con control de errores
try {
    int edad = Integer.parseInt(scanner.nextLine().trim());
} catch (NumberFormatException e) {
    System.out.println("Por favor, introduce un número válido.");
}

// ❌ MAL: O(n²) — crea un nuevo String en cada iteración
String csv = "";
for (String item : lista) {
    csv += item + ",";
}

// ✅ BIEN: O(n) — modifica un buffer mutable
String csv = String.join(",", lista);

// ✅ TAMBIÉN BIEN: con StringBuilder para lógica compleja
StringBuilder sb = new StringBuilder();
for (int i = 0; i < lista.size(); i++) {
    if (i > 0) sb.append(",");
    sb.append(lista.get(i));
}
String csv = sb.toString();

String nombre = "  Ana García  ";

// ❌ MAL: trim() NO modifica nombre, devuelve un nuevo String
nombre.trim();
nombre.toUpperCase();
System.out.println(nombre); // "  Ana García  " — ¡sin cambios!

// ✅ BIEN: asignar el resultado
nombre = nombre.trim();
nombre = nombre.toUpperCase();
System.out.println(nombre); // "ANA GARCÍA"

String valor = obtenerValor(); // puede devolver null

// ❌ MAL: si valor es null, lanza NullPointerException
if (valor.equals("esperado")) { ... }

// ✅ BIEN: literal primero (patrón defensivo)
if ("esperado".equals(valor)) { ... }

// ✅ TAMBIÉN BIEN: comprobación explícita de null
if (valor != null && valor.equals("esperado")) { ... }