En este laboratorio, aprenderá sobre los beneficios de usar Strings inmutables en la programación Java. Comprenderá por qué las Strings en Java son inmutables por defecto y cómo esta característica puede mejorar el rendimiento general y la seguridad de sus aplicaciones. Al final de este laboratorio, podrá crear y utilizar eficazmente Strings inmutables en sus programas Java.
En este paso, creará un nuevo archivo Java llamado ImmutableStringDemo.java en su directorio ~/project. Este archivo contendrá todo el código Java para este laboratorio.
Primero, asegúrese de estar en el directorio ~/project. Puede verificar su directorio actual usando el comando pwd:
pwdDebería ver una salida similar a esta:
/home/labex/projectAhora, cree el archivo ImmutableStringDemo.java usando el comando touch:
touch ImmutableStringDemo.javaDespués de crear el archivo, puede abrirlo en el editor WebIDE para comenzar a escribir su código Java.
En Java, los objetos String son inmutables, lo que significa que su valor no puede cambiarse después de su creación. Esta elección de diseño ofrece varios beneficios, incluida la seguridad, la seguridad en hilos (thread safety) y optimizaciones de rendimiento a través del String pool.
El String pool es un área de memoria especial dentro del heap que almacena literales de String. Cuando crea un literal de String, Java primero verifica si un String idéntico ya existe en el pool. Si es así, se devuelve la referencia del String existente, lo que ahorra memoria. Si no, se crea un nuevo String en el pool y se devuelve su referencia.
Agreguemos la estructura básica de una clase Java y demostremos la creación de Strings. Abra ImmutableStringDemo.java en el WebIDE y agregue el siguiente código:
// ~/project/ImmutableStringDemo.java
public class ImmutableStringDemo {
public static void main(String[] args) {
// Creando un literal de String
String name = "LabexUser";
System.out.println("Nombre inicial: " + name);
// Creando Strings que podrían usar el String pool
String str1 = "Hello";
String str2 = "Hello"; // Esto probablemente se referirá al mismo objeto que str1 en el String pool
System.out.println("str1: " + str1);
System.out.println("str2: " + str2);
System.out.println("str1 == str2: " + (str1 == str2)); // Comprueba si se refieren al mismo objeto
// Creando un String usando la palabra clave 'new'
// Esto siempre crea un nuevo objeto en el heap, incluso si el literal existe en el pool
String str3 = new String("Hello");
System.out.println("str3: " + str3);
System.out.println("str1 == str3: " + (str1 == str3)); // Comprueba si se refieren al mismo objeto
}
}Guarde el archivo después de agregar el código.
Ahora, compile y ejecute el programa Java para ver la salida. En la terminal, ejecute los siguientes comandos:
javac ImmutableStringDemo.java
java ImmutableStringDemoDebería ver una salida similar a esta:
Nombre inicial: LabexUser
str1: Hello
str2: Hello
str1 == str2: true
str3: Hello
str1 == str3: falseEsta salida demuestra que str1 y str2 se refieren al mismo objeto en el String pool, mientras que str3 (creado con new String()) es un objeto distinto en el heap, a pesar de que su contenido es idéntico.
La inmutabilidad es crucial para la seguridad y la seguridad en hilos (thread safety) en Java. Cuando un String es inmutable, su valor no puede ser modificado por ninguna parte del programa después de su creación. Esto evita que código malicioso altere datos sensibles almacenados en Strings, como contraseñas o URLs.
Además, los objetos inmutables son inherentemente seguros para hilos (thread-safe). Múltiples hilos pueden acceder a un String inmutable de forma concurrente sin necesidad de sincronización externa, ya que no hay riesgo de que un hilo modifique el String mientras otro lo está leyendo.
Demostremos esto agregando la palabra clave final a un String y creando un ejemplo simple y seguro para hilos (thread-safe).
Modifique su archivo ImmutableStringDemo.java de la siguiente manera. Declararemos un String final a nivel de clase para hacerlo accesible a nuestra clase ThreadSafeTask.
// ~/project/ImmutableStringDemo.java
import java.util.HashMap;
public class ImmutableStringDemo {
// Declarar un String final para seguridad y seguridad en hilos (thread safety)
private static final String SECURE_PASSWORD = "MySecurePassword123";
// Clase interna para demostrar la seguridad en hilos (thread safety)
static class ThreadSafeTask implements Runnable {
private final String password; // La contraseña se pasa como un String inmutable
public ThreadSafeTask(String password) {
this.password = password;
}
@Override
public void run() {
System.out.println("Hilo " + Thread.currentThread().getName() + " accediendo a la contraseña: " + password);
// Simular algo de trabajo
try {
Thread.sleep(50);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
public static void main(String[] args) {
// ... (el código anterior para name, str1, str2, str3 permanece aquí) ...
String name = "LabexUser";
System.out.println("Nombre inicial: " + name);
String str1 = "Hello";
String str2 = "Hello";
System.out.println("str1: " + str1);
System.out.println("str2: " + str2);
System.out.println("str1 == str2: " + (str1 == str2));
String str3 = new String("Hello");
System.out.println("str3: " + str3);
System.out.println("str1 == str3: " + (str1 == str3));
System.out.println("\n--- Demostrando Seguridad y Seguridad en Hilos (Thread Safety) ---");
// Usando el String final
System.out.println("Contraseña Segura: " + SECURE_PASSWORD);
// Demostrar la seguridad en hilos (thread safety) con la contraseña inmutable
for (int i = 0; i < 3; i++) {
Thread thread = new Thread(new ThreadSafeTask(SECURE_PASSWORD), "Thread-" + (i + 1));
thread.start();
}
// Esperar a que los hilos terminen (opcional, para una salida más limpia)
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}Nota: La palabra clave final asegura que la variable SECURE_PASSWORD solo pueda ser asignada una vez. Dado que String en sí mismo es inmutable, esto hace que el contenido de SECURE_PASSWORD no pueda ser modificado. La clase ThreadSafeTask accede de forma segura a este String inmutable desde múltiples hilos.
Guarde el archivo. Luego, compile y ejecute el programa nuevamente:
javac ImmutableStringDemo.java
java ImmutableStringDemoDebería ver una salida similar a esta, con los mensajes de acceso de los hilos apareciendo en un orden no determinista:
Nombre inicial: LabexUser
str1: Hello
str2: Hello
str1 == str2: true
str3: Hello
str1 == str3: false
--- Demostrando Seguridad y Seguridad en Hilos (Thread Safety) ---
Contraseña Segura: MySecurePassword123
Thread Thread-1 accediendo a la contraseña: MySecurePassword123
Thread Thread-2 accediendo a la contraseña: MySecurePassword123
Thread Thread-3 accediendo a la contraseña: MySecurePassword123La inmutabilidad de los Strings los hace ideales para su uso como claves en colecciones basadas en hash como HashMap y HashSet. Dado que el valor de un String nunca cambia, su hashCode() puede calcularse una vez y almacenarse en caché. Las llamadas posteriores a hashCode() devolverán el valor almacenado en caché, lo que generará mejoras significativas de rendimiento, especialmente cuando los Strings se utilizan frecuentemente como claves.
Si los Strings fueran mutables, su código hash podría cambiar después de ser insertados en un HashMap, lo que haría imposible recuperar el objeto utilizando el código hash original.
Agreguemos código a ImmutableStringDemo.java para demostrar el uso de String en un HashMap.
Agregue el siguiente código al método main de su archivo ImmutableStringDemo.java, después de la demostración de seguridad en hilos (thread safety):
// ~/project/ImmutableStringDemo.java
import java.util.HashMap; // Asegúrese de que esta importación esté al principio de su archivo
public class ImmutableStringDemo {
private static final String SECURE_PASSWORD = "MySecurePassword123";
static class ThreadSafeTask implements Runnable {
private final String password;
public ThreadSafeTask(String password) {
this.password = password;
}
@Override
public void run() {
System.out.println("Thread " + Thread.currentThread().getName() + " accessing password: " + password);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
public static void main(String[] args) {
// ... (el código anterior para name, str1, str2, str3 y seguridad en hilos permanece aquí) ...
String name = "LabexUser";
System.out.println("Initial name: " + name);
String str1 = "Hello";
String str2 = "Hello";
System.out.println("str1: " + str1);
System.out.println("str2: " + str2);
System.out.println("str1 == str2: " + (str1 == str2));
String str3 = new String("Hello");
System.out.println("str3: " + str3);
System.out.println("str1 == str3: " + (str1 == str3));
System.out.println("\n--- Demonstrating Security and Thread Safety ---");
System.out.println("Secure Password: " + SECURE_PASSWORD);
for (int i = 0; i < 3; i++) {
Thread thread = new Thread(new ThreadSafeTask(SECURE_PASSWORD), "Thread-" + (i + 1));
thread.start();
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("\n--- Demonstrating Hashcode Caching ---");
HashMap<String, Integer> studentScores = new HashMap<>();
String studentName1 = "Alice";
String studentName2 = "Bob";
String studentName3 = "Alice"; // Esto se referirá al mismo "Alice" en el String pool
studentScores.put(studentName1, 95);
studentScores.put(studentName2, 88);
studentScores.put(studentName3, 92); // Esto actualizará el valor para "Alice"
System.out.println("Student Scores: " + studentScores);
System.out.println("Alice's score: " + studentScores.get("Alice"));
System.out.println("Bob's score: " + studentScores.get("Bob"));
// Demostrar que incluso si intentamos "cambiar" un String, se crea uno nuevo
String originalString = "Java";
System.out.println("Original String: " + originalString + ", HashCode: " + originalString.hashCode());
String modifiedString = originalString.concat(" Programming"); // Crea un nuevo String
System.out.println("Modified String: " + modifiedString + ", HashCode: " + modifiedString.hashCode());
System.out.println("Original String (after concat): " + originalString + ", HashCode: " + originalString.hashCode());
}
}Guarde el archivo. Luego, compile y ejecute el programa nuevamente:
javac ImmutableStringDemo.java
java ImmutableStringDemoDebería ver una salida similar a esta, incluyendo las demostraciones de HashMap y hashcode:
Initial name: LabexUser
str1: Hello
str2: Hello
str1 == str2: true
str3: Hello
str1 == str3: false
--- Demonstrating Security and Thread Safety ---
Secure Password: MySecurePassword123
Thread Thread-1 accessing password: MySecurePassword123
Thread Thread-2 accessing password: MySecurePassword123
Thread Thread-3 accessing password: MySecurePassword123
--- Demonstrating Hashcode Caching ---
Student Scores: {Bob=88, Alice=92}
Alice's score: 92
Bob's score: 88
Original String: Java, HashCode: 2301506
Modified String: Java Programming, HashCode: -1479700901
Original String (after concat): Java, HashCode: 2301506Observe cómo el hash code de originalString permanece igual incluso después de llamar a concat, porque concat devuelve un objeto String nuevo, dejando el original intacto.
En este laboratorio, ha aprendido sobre el concepto fundamental de los Strings inmutables en la programación Java. Exploró por qué los Strings son inmutables por defecto y cómo esta elección de diseño contribuye a la optimización de la memoria a través del String pool. También comprendió los beneficios críticos de la inmutabilidad, incluida la seguridad mejorada para datos sensibles, la seguridad inherente en hilos (thread safety) para operaciones concurrentes y el rendimiento mejorado en colecciones basadas en hash debido al almacenamiento en caché de hashcode. Al completar los ejercicios prácticos, ha adquirido experiencia práctica en la creación y utilización efectiva de Strings inmutables en sus aplicaciones Java.
