Codemaker Computación por dentro

Computación por dentro Tema 3

La memoria por dentro

Aquí está la explicación de varias cosas raras de Java: por qué un array cambia al pasarlo a una función y un int no, por qué los String se comparan con equals o de dónde sale la NullPointerException.

Celdas con dirección#

La RAM es una fila enorme de celdas de 1 byte. Cada celda tiene un número, su dirección, igual que las casas de una calle.

Una variable es un nombre para unas celdas. Al declararla, Java reserva tantas celdas como ocupa su tipo; al asignarle un valor, lo escribe dentro:

La RAM es una fila de celdas numeradas. La variable int edad ocupa 4 celdas, char letra ocupa 2 y boolean aprobado ocupa 1

Java
int edad;        // reserva 4 celdas
edad = 16;       // escribe 16 en ellas
edad = 17;       // escribe 17 encima: el 16 se pierde

Las celdas son las mismas: un valor nuevo pisa al anterior.

La pila y el montón#

Un programa de Java usa dos zonas de la memoria:

ZonaQué guardaCómo funciona
Pila (stack)Las variables de cada método mientras se ejecutaAl llamar a un método se le da su sitio; al terminar, se borra
Montón (heap)Los objetos y los arrays: todo lo que se crea con newSiguen ahí mientras alguien los use

Los tipos básicos (int, double, char, boolean…) guardan su valor en la pila. Los objetos y los arrays están en el montón, y la variable solo guarda una flecha hacia ellos: una referencia.

Java
int edad = 16;
String nombre = "Ana";
int[] notas = {5, 7, 9};

En la pila, edad guarda 16; nombre y notas guardan flechas que apuntan al objeto Ana y al array 5, 7, 9, que están en el montón

Nota

En otros lenguajes, como C, estas flechas se llaman punteros y se pueden manejar a mano: sumarles, restarles, apuntar a cualquier celda. Java no te deja: sus referencias solo pueden apuntar a un objeto o a nada. Es menos libre, pero evita muchos fallos.

Copiar: el número o la flecha#

Como un int guarda el número y un array guarda una flecha, copiarlos no es lo mismo:

Copiar un int crea otro número independiente; copiar un array copia la flecha, y las dos variables apuntan al mismo array

Java
int a = 5;
int b = a;
b = 8;
System.out.println(a);            // a no ha cambiado

int[] x = {1, 2, 3};
int[] y = x;
y[0] = 100;
System.out.println(x[0]);         // x sí ha cambiado: es el mismo array
Salida
5
100

Lo mismo pasa al pasar algo a una función: el método recibe una copia. Si es un int, una copia del número; si es un array, una copia de la flecha, que apunta al mismo array:

Java
static void cambiar(int n, int[] notas) {
    n = 99;
    notas[0] = 99;
}
Java
int n = 5;
int[] notas = {5, 7, 9};
cambiar(n, notas);
System.out.println(n);
System.out.println(Arrays.toString(notas));
Salida
5
[99, 7, 9]

Consejo

Si quieres un array nuevo de verdad, que no comparta nada con el original, cópialo: int[] y = Arrays.copyOf(x, x.length);

Por qué == falla con los textos#

Con objetos, == no mira lo que hay dentro: mira si las dos flechas apuntan al mismo objeto. Para comparar el contenido está equals:

s1 y s2 apuntan a dos objetos distintos que dicen hola: s1 == s2 es false, s1.equals(s2) es true

Java
String s1 = "hola";
String s2 = new String("hola");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
Salida
false
true

Lo traicionero es que a veces == acierta: si escribes "hola" dos veces en el código, Java reutiliza el mismo objeto y == da true. Pero con un texto que escribe el usuario o que sale de un fichero, fallará. Los textos, siempre con equals.

null y el recolector de basura#

Una referencia null no apunta a nada y usarla da NullPointerException. Un objeto al que no apunta nadie lo borra el recolector de basura

Una referencia puede valer null: no apunta a ningún objeto. Si intentas usarla, no hay objeto al que preguntar, y Java para el programa:

Java
String nombre = null;
System.out.println(nombre.length());
Salida
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "nombre" is null

Y al revés: si un objeto se queda sin ninguna flecha que apunte a él, ya nadie puede usarlo. El recolector de basura (garbage collector) de Java lo encuentra y libera su memoria él solo. En C, en cambio, hay que liberarla a mano, y olvidarlo es uno de los fallos más típicos.

Consejo

En CodeStudio puedes ver todo esto en 3D: la pila, el montón, las celdas de cada variable y sus bits, mientras tu programa se ejecuta paso a paso.

Errores frecuentes#

Lo que pasaPor quéSolución
Cambio un array y también cambia otroLas dos variables son flechas al mismo arrayCopia el array con Arrays.copyOf
Una función cambia mi array, pero no mi intAl array le llega una copia de la flecha; al int, una copia del númeroSi quieres cambiar un int, devuelve el valor nuevo con return
Dos String iguales dan false con ==== compara las flechas, no el textoUsa equals
NullPointerExceptionUsas una variable que vale null: no apunta a ningún objetoMira qué variable dice el mensaje y dale un objeto antes de usarla
StackOverflowErrorUn método se llama a sí mismo sin parar y la pila se llenaRevisa que la recursión tenga un caso en el que termine