Cadenas en Java

Cadenas en Java (String)

• En este tutorial vamos a ver las letras en Java.
• Antes imprimimos HOLA MUNDO en el terminal.
• "Hola mundo" es una letra literal (un valor de letra).

Extraer el literal a una variable

• Ahora vamos a extraer "Hola mundo" y guardarlo en una variable de letras.
• La clase String está definida en el paquete java.lang.
• No vemos import porque java.lang se importa automáticamente.

Crear un String (forma larga)

• Como es un tipo de referencia, podemos instanciarla con new.

public class Main {
    public static void main(String[] args) {
        String mensaje = new String("Hola mundo");
        System.out.println(mensaje); //  print line LN
    }
}

new String es redundante

• new String(...) es redundante.
• Hay una forma más corta de inicializar cadenas.

Crear un String (forma corta)

• En lugar de new, asignamos directamente el literal.
• Parece primitivo, pero es solo una forma abreviada.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo";
        System.out.println(mensaje); //  print line LN
    }
}

Strings son referencia (pero fáciles)

• Las cadenas son tipos de referencia en Java.
• Pero como se usan mucho, Java permite crearlas rápido.
• Al imprimir mensaje, obtenemos el mismo resultado.

Concatenación con +

• Podemos concatenar o unir una cadena con otra usando +.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje);
    }
}

Miembros de String (operador punto)

• Como String es una clase, tiene miembros.
• Con mensaje. vemos métodos/funciones disponibles.

endsWith: ¿termina con…?

• endsWith verifica si termina con una secuencia.
• En lugar de imprimir el mensaje, imprimamos la expresión.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje.endsWith("!"));
    }
}

Resultado booleano

• Devuelve un booleano: true o false.
• Si el mensaje no termina con "!", da false.

startsWith: ¿empieza con…?

• También existe startsWith.
• Si no empieza con lo indicado, devuelve false.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje.startsWith("!!"));
    }
}

length: longitud de la cadena

• length() devuelve el número de caracteres.
• Útil para validar entradas (por ejemplo, usuario ≤ 20 caracteres).

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje.length());
    }
}

indexOf: posición del primer match

• indexOf devuelve el índice de la primera ocurrencia.
• Si pasas "H", el índice es 0.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo";
        System.out.println(mensaje.indexOf("H"));
    }
}

indexOf: cuando NO existe

• Si el carácter/cadena no existe, devuelve -1.
• Con esto puedes verificar si contiene ciertas palabras o caracteres.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo";
        System.out.println(mensaje.indexOf("p"));
    }
}

replace: reemplazar caracteres

• replace reemplaza uno o más caracteres por otra cosa.
• Tiene dos parámetros: "target" y "replace".

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje.replace(")", "("));
    }
}

Parámetros vs argumentos

• Cuando escribimos un método, definimos parámetros (espacios reservados).
• Cuando llamamos al método, pasamos argumentos (valores reales).

void saludar(String nombre) {
    System.out.println("Hola " + nombre);
}

saludar("Ana");

Parámetros y argumentos (resumen)

• Parámetros → nombres en la definición (variables de entrada).
• Argumentos → valores concretos al llamar el método.

En este caso, "target" y "replace" son parámetros, pero “signo de exclamación” y “asterisco” son argumentos.

Ahora, ejecutemos este programa y veamos qué sucede. :) ->>>> :( .

Inmutabilidad de Strings

• replace NO modifica la cadena original.
• Devuelve una nueva cadena.
• En Java, las cadenas son inmutables.

Verificar: original no cambia

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje.replace(")", "("));
        System.out.println(mensaje);
    }
}

toLowerCase

• Convierte a minúsculas.
• La cadena original no se afecta.

public class Main {
    public static void main(String[] args) {
        String mensaje = "Hola mundo" + ":)";
        System.out.println(mensaje.toLowerCase());
    }
}

toUpperCase y trim

• También podemos convertir a mayúsculas.
• Y trim() elimina espacios extra al inicio y al final.

trim: espacios al inicio y final

public class Main {
    public static void main(String[] args) {
        String mensaje = "    Hola mundo" + ":)      ";
        System.out.println(mensaje);
        System.out.println(mensaje.trim());
    }
}