Memoria, Referencias y Mutabilidad

public static void ejemplo() {
    int edad = 25;           // 'edad' está en el Stack, contiene el valor 25
    double precio = 19.99;   // 'precio' está en el Stack, contiene el valor 19.99
    boolean activo = true;   // 'activo' está en el Stack, contiene true
    char letra = 'A';        // 'letra' está en el Stack, contiene 'A'
    
    int[] numeros;           // 'numeros' está en el Stack, pero solo es una REFERENCIA
                             // Por ahora vale null (no apunta a ningún arreglo)
}

public static void ejemplo() {
    // La variable 'numeros' está en el Stack (es una referencia)
    // El arreglo real {1, 2, 3} está en el Heap
    int[] numeros = new int[]{1, 2, 3};
    
    // La variable 'texto' está en el Stack (es una referencia)
    // El objeto String "Hola" está en el Heap
    String texto = "Hola";
}

public static int[] crearArreglo() {
    int[] arr = new int[]{1, 2, 3};  // arr en Stack, arreglo en Heap
    return arr;  // Retornamos la referencia (la dirección)
}
// Cuando termina el método, 'arr' desaparece del Stack
// PERO el arreglo sigue vivo en el Heap si alguien guardó la referencia

public static void main(String[] args) {
    int[] resultado = crearArreglo();  // 'resultado' guarda la referencia
    // El arreglo sigue existiendo porque 'resultado' apunta a él
    System.out.println(resultado[0]);  // Funciona: imprime 1
}

// === PRIMITIVOS: copian el VALOR ===
int a = 10;        // 'a' contiene el valor 10
int b = a;         // 'b' contiene una COPIA INDEPENDIENTE del valor 10
b = 20;            // Cambiar 'b' NO afecta a 'a'
System.out.println(a);  // Imprime: 10 (sin cambios)
System.out.println(b);  // Imprime: 20

// === REFERENCIAS: copian la DIRECCIÓN ===
int[] arr1 = {1, 2, 3};  // 'arr1' contiene dirección del arreglo (ej: 0x1234)
int[] arr2 = arr1;       // 'arr2' contiene COPIA de la dirección (también 0x1234)
                         // ¡AMBOS APUNTAN AL MISMO ARREGLO!
arr2[0] = 999;           // Modifica el arreglo a través de arr2
System.out.println(arr1[0]);  // Imprime: 999 (¡arr1 también ve el cambio!)

int[] numeros = null;  // La referencia existe pero no apunta a ningún arreglo
String texto = null;   // La referencia existe pero no apunta a ningún String

// La variable existe en el Stack, pero su valor es "nada"
// Es como tener un papel con la dirección borrada

int[] numeros = null;
String texto = null;

// Todas estas líneas causan NullPointerException:
int len = numeros.length;     // ❌ Intentar acceder a .length de null
int valor = numeros[0];       // ❌ Intentar acceder a un índice de null
int largo = texto.length();   // ❌ Intentar llamar método en null
char c = texto.charAt(0);     // ❌ Intentar llamar método en null

public static void procesarArreglo(int[] arr) {
    // Verificar ANTES de usar
    if (arr == null) {
        System.out.println("Error: el arreglo es null");
        return;  // Salir del método
    }
    
    // Ahora es seguro usar arr
    System.out.println("Tamaño: " + arr.length);
    for (int i = 0; i < arr.length; i = i + 1) {
        System.out.println(arr[i]);
    }
}

// Dos arreglos con el MISMO CONTENIDO pero en DIFERENTES lugares del Heap
int[] a = {1, 2, 3};  // Arreglo en dirección 0x1234
int[] b = {1, 2, 3};  // Otro arreglo en dirección 0x5678 (diferente!)
int[] c = a;          // 'c' apunta a la MISMA dirección que 'a': 0x1234

System.out.println(a == b);  // false — diferentes direcciones
System.out.println(a == c);  // true — misma dirección

// a y b tienen el MISMO CONTENIDO pero == dice false
// porque == pregunta "¿son el mismo objeto?" no "¿tienen el mismo contenido?"

import java.util.Arrays;

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};

System.out.println(a == b);              // false (diferentes objetos)
System.out.println(Arrays.equals(a, b)); // true (mismo contenido)

public static void duplicar(int numero) {
    // 'numero' es una COPIA del valor original
    numero = numero * 2;  // Solo modifica la copia local
    System.out.println("Dentro del método: " + numero);  // 20
}

public static void main(String[] args) {
    int valor = 10;
    duplicar(valor);
    System.out.println("Fuera del método: " + valor);  // 10 (sin cambios)
}

public static void modificarContenido(int[] arr) {
    arr[0] = 999;  // Modifica el arreglo original ✅
    // 'arr' tiene una COPIA de la dirección, pero apunta al MISMO arreglo
}

public static void main(String[] args) {
    int[] numeros = {1, 2, 3};
    
    System.out.println("Antes: " + numeros[0]);  // 1
    modificarContenido(numeros);
    System.out.println("Después: " + numeros[0]);  // 999 (¡modificado!)
}

public static void intentarReasignar(int[] arr) {
    // 'arr' es una COPIA de la referencia
    arr = new int[]{100, 200, 300};  // Solo cambia la COPIA local
    // El 'numeros' original sigue apuntando al arreglo viejo
}

public static void main(String[] args) {
    int[] numeros = {1, 2, 3};
    
    System.out.println("Antes: " + numeros[0]);  // 1
    intentarReasignar(numeros);
    System.out.println("Después: " + numeros[0]);  // 1 (sin cambios)
}

// ⚠️ Este método tiene efecto secundario: modifica el arreglo recibido
public static void ordenar(int[] arr) {
    // Algoritmo de ordenamiento que modifica arr directamente
    for (int i = 0; i < arr.length - 1; i = i + 1) {
        for (int j = 0; j < arr.length - 1 - i; j = j + 1) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// El efecto secundario es visible fuera del método
int[] datos = {5, 2, 8, 1};
ordenar(datos);
// datos ahora está ordenado: {1, 2, 5, 8}

// ✅ Función pura: no modifica nada, retorna un nuevo arreglo
public static int[] ordenarNuevo(int[] original) {
    // Crear una copia del arreglo
    int[] copia = new int[original.length];
    for (int i = 0; i < original.length; i = i + 1) {
        copia[i] = original[i];
    }
    
    // Ordenar la copia (no el original)
    for (int i = 0; i < copia.length - 1; i = i + 1) {
        for (int j = 0; j < copia.length - 1 - i; j = j + 1) {
            if (copia[j] > copia[j + 1]) {
                int temp = copia[j];
                copia[j] = copia[j + 1];
                copia[j + 1] = temp;
            }
        }
    }
    
    return copia;  // Retornar la copia ordenada
}

// ⚠️ Método con efecto secundario: modifica el arreglo recibido
public static void ordenarEnLugar(int[] arr) {
    // Ordena directamente 'arr', modificando el original
    // ... código de ordenamiento ...
}

// Uso:
int[] datos = {5, 2, 8, 1};

int[] datosOrdenados = ordenarNuevo(datos);
// datos sigue siendo {5, 2, 8, 1}
// datosOrdenados es {1, 2, 5, 8}

ordenarEnLugar(datos);
// datos ahora es {1, 2, 5, 8}

// Con primitivos: no se puede reasignar
final int constante = 10;
// constante = 20;  // ❌ Error de compilación

// Con referencias: no se puede reasignar, PERO se puede modificar contenido
final int[] numeros = {1, 2, 3};

numeros[0] = 999;            // ✅ Permitido: modificar CONTENIDO
System.out.println(numeros[0]);  // 999

// numeros = new int[5];     // ❌ Error: no se puede REASIGNAR la referencia

public static double calcularPromedio(int[] datos) {
    // Crear copia para trabajar de forma segura
    int[] copia = new int[datos.length];
    for (int i = 0; i < datos.length; i = i + 1) {
        copia[i] = datos[i];
    }
    
    // Trabajar con la copia
    int suma = 0;
    for (int i = 0; i < copia.length; i = i + 1) {
        suma = suma + copia[i];
    }
    return (double) suma / copia.length;
}

// Variable de módulo (simulando datos internos)
static int[] datosSecretos = {100, 200, 300};

// ❌ Mal: expone los datos internos
public static int[] obtenerDatosMal() {
    return datosSecretos;  // El llamador puede modificar nuestros datos
}

// ✅ Bien: retorna una copia
public static int[] obtenerDatosBien() {
    int[] copia = new int[datosSecretos.length];
    for (int i = 0; i < datosSecretos.length; i = i + 1) {
        copia[i] = datosSecretos[i];
    }
    return copia;  // El llamador solo puede modificar la copia
}

String s1 = "Hola";      // Busca "Hola" en el pool, no existe, lo crea
String s2 = "Hola";      // Busca "Hola" en el pool, ya existe, retorna la misma referencia
String s3 = new String("Hola");  // Fuerza creación de NUEVO objeto fuera del pool

System.out.println(s1 == s2);  // true (misma referencia del pool)
System.out.println(s1 == s3);  // false (s3 es objeto diferente, no está en el pool)
System.out.println(s1.equals(s3));  // true (mismo contenido)

String original = "Hola";

// ❌ ERROR COMÚN: llamar al método pero no guardar el resultado
original.toUpperCase();  // Esto CREA un nuevo String "HOLA" pero nadie lo guarda
System.out.println(original);  // Sigue imprimiendo "Hola"

// ✅ CORRECTO: guardar el resultado en una variable
String mayusculas = original.toUpperCase();  // Guardar el nuevo String
System.out.println(mayusculas);  // "HOLA"
System.out.println(original);    // Sigue siendo "Hola" (inmutable)

// ✅ También válido: reasignar a la misma variable
String texto = "  espacios  ";
texto = texto.trim();  // La variable 'texto' ahora apunta al nuevo String
System.out.println(texto);  // "espacios"

String texto = "  Hola Mundo  ";

// Información sobre el String
System.out.println(texto.length());        // 14 (incluye espacios)
System.out.println(texto.charAt(2));       // 'H' (índice 2, tercer carácter)
System.out.println(texto.isEmpty());       // false

// Transformaciones (todas retornan NUEVO String)
System.out.println(texto.trim());          // "Hola Mundo"
System.out.println(texto.toUpperCase());   // "  HOLA MUNDO  "
System.out.println(texto.substring(2, 6)); // "Hola"
System.out.println(texto.replace(' ', '-')); // "--Hola-Mundo--"

// Búsquedas
System.out.println(texto.contains("Mun")); // true
System.out.println(texto.indexOf("Mundo")); // 7
System.out.println(texto.indexOf("xyz"));  // -1 (no encontrado)
System.out.println(texto.startsWith("  H")); // true

// División
String csv = "manzana,banana,naranja";
String[] frutas = csv.split(",");
// frutas = ["manzana", "banana", "naranja"]

String entrada = "ADMIN";
String esperado = "admin";

// ❌ Mal: esto da false
if (entrada.equals(esperado)) { }

// ✅ Bien: ignora mayúsculas/minúsculas
if (entrada.equalsIgnoreCase(esperado)) { }

// ✅ También válido: convertir ambos al mismo caso
if (entrada.toLowerCase().equals(esperado.toLowerCase())) { }

String nombre = "Juan";
int edad = 25;

String mensaje = "Hola, " + nombre + ". Tenés " + edad + " años.";
// mensaje = "Hola, Juan. Tenés 25 años."

// Java convierte automáticamente los no-String a String

String resultado = "";
for (int i = 0; i < 1000; i = i + 1) {
    resultado = resultado + i + ",";
    // En cada iteración:
    // 1. Java crea un nuevo String temporal
    // 2. Copia todo el contenido anterior
    // 3. Agrega los nuevos caracteres
    // 4. El String viejo queda para el Garbage Collector
}
// Total: se crean ~1000 Strings temporales
// Complejidad: O(n²) porque cada iteración copia más caracteres

StringBuilder sb = new StringBuilder();  // Crear el builder

for (int i = 0; i < 1000; i = i + 1) {
    sb.append(i);     // Agregar al buffer interno
    sb.append(",");   // No crea objetos nuevos
}

String resultado = sb.toString();  // Convertir a String al final
// Total: 1 StringBuilder, 1 String final
// Complejidad: O(n)

StringBuilder sb = new StringBuilder();

// Construir texto
sb.append("Hola");
sb.append(" ");
sb.append("Mundo");
System.out.println(sb.toString());  // "Hola Mundo"

// Insertar en el medio
sb.insert(5, "Java ");
System.out.println(sb.toString());  // "Hola Java Mundo"

// Modificar un carácter
sb.setCharAt(0, 'h');
System.out.println(sb.toString());  // "hola Java Mundo"

// Eliminar un rango
sb.delete(5, 10);  // Elimina "Java "
System.out.println(sb.toString());  // "hola Mundo"

// Invertir
sb.reverse();
System.out.println(sb.toString());  // "odnuM aloh"