En Java tenemos dos tipos de datos (o variables): primitivos y no primitivos (también llamados referencias).

Los tipos primitivos tienen sus valores literales almacenados en el Stack, memoria de almacenamiento temporal y de corto plazo, administrada por la Máquina Virtual Java (JVM). [lea más sobre los tipos de memoria aquí]

Las variables primitivas se dividen en cuatro grupos:

1. Tipos de enteros: utilizados para almacenar números enteros (sin parte decimal). Son: byte, corto, int, largo. El largo tiene la letra "L" o "l" al final del número, para diferenciarlo.

2. Tipos de punto flotante: : Se utiliza para almacenar números con parte decimal (números reales). Son: flotante, doble. El flotador tiene la letra "F" o "f" al final del número, para diferenciarlo.

3. Tipo de carácter: Se utiliza para almacenar caracteres individuales (como letras, dígitos o símbolos): char. Se inicializan con comillas simples '', en lugar de doble "".

4. Tipo booleano: Se utiliza para almacenar valores lógicos (verdadero o falso): bool

Consulte la siguiente tabla para conocer el rango de valores que admite cada tipo, además de sus valores "predeterminados":

En formato científico, E representa un exponente. Por ejemplo, 1,23E 10, es igual a 1,23 x 10^10

¿Qué es un valor predeterminado? Es el valor que tomará la variable si no ha sido inicializada. Sin embargo, para asumir este valor, debe ser global o constante (final).

public final boolean isTrue;

En esta línea de código, la variable "isTrue" no fue inicializada, pero el compilador no presentará un error, ya que considerará el valor predeterminado "falso" para la variable booleana.

Aquí, una advertencia importante: si el alcance de la variable es local, es decir, si ha sido declarada dentro de una función, los programadores nos veremos obligados a asignarle un valor. De lo contrario, habrá un error de compilación.

public void teste(){
        int i = 2;
        int j;

        if (i 



En este ejemplo, aunque sabemos que "2 


  
  
  Direcciones de memoria


El segundo tipo de datos en Java se llama referencia. Estas variables almacenan una referencia, es decir, la dirección de memoria de un objeto, en lugar de almacenar su valor directamente, como ocurre con los tipos primitivos. Este almacenamiento se produce en la memoria Heap.

Los tipos de referencia son clases, interfaces, enumeraciones y objetos, en general. 

Aquí, un apéndice. El String que utilizamos ampliamente en nuestros códigos es una clase, no un tipo primitivo. Tenga en cuenta que incluso el nombre está en mayúscula, al igual que la convención de nomenclatura para las clases en Java.

El String incluso tiene métodos, como length(), que devuelve el tamaño del texto almacenado en él, charAt(int index), que devuelve el índice de un carácter en el texto, o substring(int beginIndex, int endIndex), que devuelve un fragmento de una cadena.

Pero, si desea facilitar la manipulación de datos primitivos, Java también lo permite. Para ello cuenta con la clase Wrapper, que ya viene con una serie de métodos integrados para trabajar con los tipos básicos.

Los contenedores básicamente tienen el mismo nombre que la variable primitiva, sin embargo, con la primera letra en mayúscula: 

• Byte a byte
• Abreviatura para abreviar
• Entero a int
• De largo a largo
• Flotar a flotar
• Doble a doble
• Carácter a carácter
• Booleano a booleano

public class WrapperExample {
    public static void main(String[] args) {
        String numeroStr = "123";
        Integer num1 = Integer.parseInt(numeroStr);
        Integer num2 = 200;

        int resultadoComparacao = Integer.compare(num1, num2);

        if (resultadoComparacao  0) {
            System.out.println(num1   " é maior que "   num2);
        } else {
            System.out.println(num1   " é igual a "   num2);
        }
    }
}

En este código de ejemplo, el contenedor int se usa para convertir una cadena en un número (Integer.parse) y luego compararlo con otro número (Integer.compare).

Un String, sin embargo, tiene una particularidad que otras clases no tienen. Es inmutable.

Reflexionemos a través de este ejemplo básico:

public class Main {
  public static void main(String[] args) {

    String text1 = "Hello";
    String text2 = text1;

    System.out.println(text1); //output: Hello
    System.out.println(text2); //output: Hello

    text1 = "Weird";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: Hello

    text2 = "World";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: World

    TestClass test1 = new TestClass("propertyValue");
    TestClass test2 = test1;

    System.out.println(test1.getProperty()); //output: propertyValue
    System.out.println(test2.getProperty()); //output: propertyValue

    test2.setProperty("newValue");

    System.out.println(test1.getProperty()); //output: newValue
    System.out.println(test2.getProperty()); //output: newValue   
  }

}

En este caso, tenga en cuenta que, aunque la cadena "texto2" apunta a "texto1", los cambios en "texto2" no reflejaron cambios en "texto1". Ahora, cuando se cambió una propiedad del objeto "prueba2", que apuntaba a "prueba1", este cambio también se reflejó en "prueba1".

Oye, pero ¿las variables de referencia no almacenan direcciones de memoria, en lugar de valores literales? Sí. Lo guardan. Lo que pasa es que los desarrolladores del lenguaje Java tomaron la decisión de dejar las variables String inmutables. Esto significa que una vez establecido, el valor de un objeto String no puede ser cambiado indirectamente por otro objeto.

En el ejemplo, por lo tanto, no estamos cambiando el valor del objeto al que text1 hizo referencia anteriormente (ya que String es inmutable). En su lugar, estamos creando un nuevo objeto String con el valor "Extraño" y haciendo que text1 apunte a este nuevo objeto. Mientras que text2 seguirá apuntando al objeto "Hola" original y es por eso que mantiene el valor "Hola".

En resumen, asignar un nuevo valor a una cadena no modifica el valor del objeto existente, solo cambia la referencia a un nuevo objeto.

Los objetos de clases personalizadas, como TestClass, son mutables. Tanto las referencias de prueba1 como de prueba2 apuntan al mismo objeto, por lo que cambiar el estado de una de ellas se refleja en la otra.