Tipos de datos primitivos

En Java, los tipos de datos primitivos son valores básicos predefinidos por el lenguaje que almacenan datos simples. Estos tipos no son objetos y se almacenan directamente en la memoria asignada a la variable.

Java ofrece ocho tipos de datos primitivos:

Tipos enteros:

• byte: Ocupa 8 bits en memoria y almacena valores en el rango de -128 a 127.
• short: Ocupa 16 bits en memoria con un rango de -32,768 a 32,767.
• int: Ocupa 32 bits y es el tipo entero más utilizado. Su rango es de -2,147,483,648 a 2,147,483,647.
• long: Ocupa 64 bits para valores enteros muy grandes. Se debe añadir el sufijo 'L' al final del valor.

Tipos de punto flotante:

• float: Representa números decimales de precisión simple (32 bits). Requiere el sufijo 'f' al final del valor.
• double: Representa números decimales de precisión doble (64 bits). Es el tipo predeterminado para decimales.

Tipo carácter:

• char: Representa un único carácter Unicode de 16 bits. Se escribe entre comillas simples ('').

Tipo booleano:

• boolean: Almacena valores de verdad: true o false. Es el tipo más simple.

A continuación se muestra cómo declarar e inicializar variables de cada tipo:

byte edad = 25;
short poblacion = 30000;
int distancia = 1500000;
long numeroGrande = 9223372036854775807L;

float precio = 19.99f;
double pi = 3.14159265359;

char letra = 'A';
char simbolo = '\u00A9'; // Copyright ©

boolean activo = true;

Los tipos primitivos tienen valores predeterminados cuando se declaran como variables de instancia:

• Tipos numéricos: 0 (o 0.0 para flotantes)
• char: '\u0000' (carácter nulo)
• boolean: false

Las variables locales (dentro de métodos) no tienen valores predeterminados y deben inicializarse antes de usarse.

Los literales numéricos pueden escribirse en diferentes sistemas:

int decimal = 100;         // Base 10 (estándar)
int octal = 0144;          // Base 8 (prefijo 0)
int hexadecimal = 0x64;    // Base 16 (prefijo 0x)
int binario = 0b1100100;   // Base 2 (prefijo 0b)

Para mejorar la legibilidad de números grandes, se puede usar el carácter de guion baja o subrayado (_) como separador visual:

int millon = 1_000_000;
long numeroTarjeta = 1234_5678_9012_3456L;
double valorPi = 3.14159_26535_89793;

Es importante tener en cuenta los límites de cada tipo. Exceder estos límites puede provocar un desbordamiento (overflow) que hace que el valor vuelva a comenzar desde el extremo opuesto del rango, lo que suele causar errores difíciles de detectar:

byte pequeño = 127;
pequeño++;  // Ahora pequeño vale -128 (desbordamiento)

Los tipos primitivos son muy eficientes pero tienen limitaciones como no poder contener valores nulos y carecer de métodos propios. Para estas situaciones, Java proporciona las clases envoltorio (wrapper classes).

Tipos de datos de referencia (no primitivos) y bloques de texto String

Los tipos de datos de referencia en Java son aquellos que derivan de clases y almacenan referencias (direcciones de memoria) a objetos en lugar de valores directos.

A diferencia de los tipos primitivos, los tipos de referencia se almacenan en el heap (montículo) de memoria, mientras que las referencias a estos objetos se almacenan en la pila (stack).

Las principales categorías de tipos de referencia incluyen:

• Clases: Definiciones personalizadas o predefinidas que encapsulan datos y comportamientos.
• Interfaces: Contratos que especifican comportamientos que las clases pueden implementar.
• Arrays: Colecciones de elementos del mismo tipo con tamaño fijo.
• Enumeraciones (enum): Conjuntos fijos de constantes nombradas.
• Records (Java 16+): Clases inmutables orientadas a almacenar datos de manera concisa.

La creación de objetos de tipos de referencia normalmente requiere el operador new:

Date fecha = new Date();
ArrayList<String> lista = new ArrayList<>();
StringBuilder constructor = new StringBuilder("Hola");

El valor predeterminado para cualquier variable de referencia no inicializada es null, que representa la ausencia de referencia a un objeto. Intentar acceder a métodos o propiedades de una referencia null generará una NullPointerException:

String mensaje;  // Por defecto es null
int longitud = mensaje.length();  // Esto causaría NullPointerException

La clase String representa secuencias de caracteres inmutables (que no pueden modificarse después de su creación):

String nombre = "Ana";  // Creación mediante literal
String apellido = new String("García");  // Creación mediante constructor (menos común)

Una característica única de String es que, aunque es un tipo de referencia, se puede crear sin usar explícitamente el operador new. Los literales de cadena (texto entre comillas dobles) se almacenan en un área especial llamada String Pool, que permite la reutilización de cadenas idénticas para optimizar la memoria.

La concatenación de cadenas se puede realizar con el operador +:

String nombreCompleto = nombre + " " + apellido;  // "Ana García"

Dado que los objetos String son inmutables, cualquier operación que parezca modificar una cadena en realidad crea un nuevo objeto String:

String saludo = "Hola";
saludo = saludo + " mundo";  // Crea un nuevo objeto String "Hola mundo"

Para operaciones que requieren múltiples modificaciones de cadenas, es más eficiente utilizar StringBuilder (no sincronizado) o StringBuffer (sincronizado para entornos multi-hilo):

StringBuilder sb = new StringBuilder();
sb.append("Hola").append(" ").append("mundo");
String resultado = sb.toString();  // "Hola mundo"

Desde Java 15, se introdujeron los bloques de texto (text blocks), que facilitan la escritura de cadenas multilínea:

String html = """
              <html>
                <body>
                  <h1>Título</h1>
                  <p>Párrafo con "comillas" y múltiples
                  líneas sin necesidad de caracteres de escape.</p>
                </body>
              </html>
              """;

Los bloques de texto preservan el formato pero eliminan el sangrado común, facilitando la inclusión de HTML, JSON, SQL y otros formatos en el código.

Para cadenas con formato, Java ofrece varias opciones:

// Método tradicional
String mensaje = String.format("Hola, %s. Tienes %d años.", "Juan", 25);

// Método más moderno (Java 15+)
String mensaje2 = "Hola, %s. Tienes %d años.".formatted("Ana", 30);

Otro tipo de referencia importante son los arrays, que permiten almacenar múltiples valores del mismo tipo:

// Declaración y creación
int[] numeros = new int[5];
String[] nombres = new String[3];

// Inicialización en la declaración
int[] primos = {2, 3, 5, 7, 11};
String[] dias = {"Lunes", "Martes", "Miércoles"};

// Acceso a elementos
numeros[0] = 10;
String primerDia = dias[0];

Java también proporciona clases envoltorio (wrapper classes) para cada tipo primitivo, permitiendo tratarlos como objetos cuando sea necesario:

• Boolean para boolean
• Byte para byte
• Short para short
• Integer para int
• Long para long
• Float para float
• Double para double
• Character para char

Estas clases incluyen métodos y permiten usar tipos primitivos en contextos que requieren objetos:

Integer numero = 42;  // Autoboxing: conversión automática de int a Integer
int valor = numero;   // Unboxing: conversión automática de Integer a int

// Métodos de las clases envoltorio
int maximo = Integer.MAX_VALUE;
String binario = Integer.toBinaryString(42);
int parseado = Integer.parseInt("123");
Double infinito = Double.POSITIVE_INFINITY;

Con la comparación de objetos, a diferencia de los primitivos, la comparación de tipos de referencia con == compara las referencias (direcciones de memoria), no el contenido:

String a = "hola";
String b = "hola";
String c = new String("hola");

System.out.println(a == b);  // true (misma referencia en el String Pool)
System.out.println(a == c);  // false (diferentes objetos aunque contengan lo mismo)
System.out.println(a.equals(c));  // true (compara el contenido)

Para comparar objetos por su contenido, se debe usar el método equals(), que cada clase puede implementar según su lógica específica.

Las colecciones son otro tipo de referencia en Java, proporcionando estructuras de datos dinámicas como listas, conjuntos y mapas:

List<String> ciudades = new ArrayList<>();
ciudades.add("Madrid");
ciudades.add("Barcelona");

Map<String, Integer> edades = new HashMap<>();
edades.put("Ana", 25);
edades.put("Carlos", 32);

Conversión entre tipos de datos

En Java, la conversión de tipos (también conocida como casting) permite transformar un valor de un tipo de dato a otro y es fundamental para la interoperabilidad entre diferentes tipos de datos.

Java proporciona dos mecanismos principales de conversión: implícita (automática) y explícita (manual).

La conversión implícita ocurre automáticamente cuando se asigna un valor de un tipo a una variable de otro tipo, siempre que no exista riesgo de pérdida de información. Generalmente, esto sucede al convertir de un tipo más pequeño a uno más grande:

byte numeroByte = 25;
int numeroEntero = numeroByte;  // Conversión implícita de byte a int

char caracter = 'A';
int codigoAscii = caracter;     // Conversión implícita de char a int

int entero = 100;
long enteroLargo = entero;      // Conversión implícita de int a long

float decimal = 3.14f;
double decimalDoble = decimal;  // Conversión implícita de float a double

La jerarquía de conversión implícita para tipos numéricos es: byte → short → int → long → float → double

La conversión explícita (casting) es necesaria cuando existe riesgo de pérdida de información, como al convertir de un tipo más grande a uno más pequeño. Se realiza colocando el tipo de destino entre paréntesis:

double numeroGrande = 9.78;
int numeroEntero = (int) numeroGrande;  // Conversión explícita, se pierde la parte decimal
// numeroEntero tendrá el valor 9

int valorEntero = 130;
byte valorByte = (byte) valorEntero;    // Puede producir resultados inesperados
// valorByte será -126 por desbordamiento (overflow)

long numeroLargo = 1234567890L;
int numeroEntero2 = (int) numeroLargo;  // Posible pérdida de información

Las conversiones entre primitivos y objetos se realizan mediante los mecanismos de autoboxing (primitivo a wrapper) y unboxing (wrapper a primitivo):

// Autoboxing
int primitivo = 42;
Integer objeto = primitivo;  // Java crea un objeto Integer automáticamente

// Unboxing
Double valorObjeto = 3.14;
double valorPrimitivo = valorObjeto;  // Java extrae el valor primitivo

Las conversiones entre String y otros tipos son muy comunes en aplicaciones que procesan entradas de usuario:

// De String a tipos primitivos
String textoNumero = "123";
int numero = Integer.parseInt(textoNumero);
double decimal = Double.parseDouble("45.67");
boolean flagTexto = Boolean.parseBoolean("true");

// De tipos primitivos a String
String desdeEntero = String.valueOf(42);
String desdeDouble = Double.toString(3.14);
String desdeBoolean = Boolean.toString(false);

// Alternativa usando concatenación
String otroTexto = 100 + "";  // Funciona pero es menos eficiente

Para conversiones con manejo de errores, se recomienda usar bloques try-catch para capturar posibles excepciones:

String entrada = "abc";
try {
    int valor = Integer.parseInt(entrada);
    System.out.println("Valor convertido: " + valor);
} catch (NumberFormatException e) {
    System.out.println("No se pudo convertir a número: " + e.getMessage());
}

La conversión entre diferentes sistemas numéricos se realiza mediante métodos específicos:

// Convertir desde otras bases a decimal
String binario = "1010";
int decimalDesdeBinario = Integer.parseInt(binario, 2);  // 10

String octal = "52";
int decimalDesdeOctal = Integer.parseInt(octal, 8);      // 42

String hexadecimal = "2F";
int decimalDesdeHex = Integer.parseInt(hexadecimal, 16); // 47

// Convertir desde decimal a otras bases
String aBinario = Integer.toBinaryString(10);     // "1010"
String aOctal = Integer.toOctalString(42);        // "52"
String aHexadecimal = Integer.toHexString(47);    // "2f"

La conversión entre caracteres y números se realiza de forma directa, ya que los caracteres en Java se almacenan internamente como valores numéricos Unicode:

char letra = 'A';
int valorNumerico = letra;        // 65 (código Unicode para 'A')

int codigo = 66;
char caracter = (char) codigo;    // 'B'

// Conversión explícita para códigos Unicode mayores
int unicodeEmoji = 0x1F60A;       // Código para emoji sonriente
char[] chars = Character.toChars(unicodeEmoji);
String emoji = new String(chars);

Para convertir entre cadenas y arreglos de caracteres:

String palabra = "Hola";
char[] letras = palabra.toCharArray();  // ['H', 'o', 'l', 'a']

char[] caracteres = {'J', 'a', 'v', 'a'};
String nuevaPalabra = new String(caracteres);  // "Java"

La conversión entre tipos de referencia relacionados se realiza mediante upcasting (de una subclase a su superclase) o downcasting (de una superclase a su subclase):

// Upcasting (implícito)
ArrayList<String> arrayList = new ArrayList<>();
List<String> lista = arrayList;  // ArrayList es una implementación de List

// Downcasting (explícito)
Object objeto = "Hola mundo";
String texto = (String) objeto;  // Requiere casting explícito

// Verificación segura antes de downcasting
if (objeto instanceof String) {
    String textoSeguro = (String) objeto;
}

// Pattern matching para instanceof (Java 16+)
if (objeto instanceof String texto2) {
    // texto2 ya está convertido y listo para usar
    System.out.println(texto2.toUpperCase());
}

La conversión entre tipos de datos en operaciones mixtas sigue reglas de promoción automática. Cuando se realiza una operación entre diferentes tipos, Java promueve automáticamente los operandos al tipo más grande:

int entero = 5;
double decimal = 2.5;
double resultado = entero * decimal;  // entero se promueve a double

byte b1 = 10;
byte b2 = 20;
int suma = b1 + b2;  // Los bytes se promueven a int en operaciones aritméticas

En cálculos científicos o financieros que requieren alta precisión, se puede usar la clase BigDecimal para evitar errores de redondeo:

BigDecimal num1 = new BigDecimal("0.1");
BigDecimal num2 = new BigDecimal("0.2");
BigDecimal suma = num1.add(num2);  // Exactamente 0.3