Persona p = new Persona();

Persona p1 = new Persona();
p1.nombre = "Ana";

p1 ---> [ Objeto Persona (nombre: Ana) ]

Dos variables pueden apuntar al mismo objeto:

Persona p2 = p1;
p2.nombre = "Luis";

p1 ---> [ Objeto Persona (nombre: Luis) ] <--- p2

Ambas referencias afectan al mismo objeto. Cualquier modificación hecha por medio de una referencia será visible también a través de la otra:

System.out.println(p1.nombre); // Luis
System.out.println(p2.nombre); // Luis

Para crear una copia independiente, se necesita una nueva instancia:

Persona p3 = new Persona();

// copia el valor del nombre, no la referencia
p3.setNombre(p1.getNombre());

if (p1 == p2) {
    System.out.println("Misma referencia");
}

Java maneja automáticamente la memoria.

p1 = null;

Si no hay más referencias a un objeto, el recolector puede liberar su memoria. No tenemos control directo sobre este proceso, pero podemos sugerirlo.

System.gc();

Java incluye clases listas para usar. Estudiaremos cada una junto con su paquete:

Representa una cadena de texto. Es inmutable: cada operación devuelve un nuevo String. Métodos más usados:

String nombre = "María López";

System.out.println(nombre.length());        // 11
System.out.println(nombre.toUpperCase());   // MARÍA LÓPEZ
System.out.println(nombre.charAt(0));       // M
System.out.println(nombre.substring(0, 5)); // María
System.out.println(nombre.indexOf("López")); // 6
System.out.println(nombre.replace("María", "Ana")); // Ana López

Ofrece funciones matemáticas mediante métodos estáticos: se usan con Math. sin crear objetos.

int maximo = Math.max(10, 20);      // 20
double raiz = Math.sqrt(144);       // 12.0
double potencia = Math.pow(2, 10);  // 1024.0
long redondeo = Math.round(3.7);    // 4
double area = Math.PI * Math.pow(5, 2); // círculo r=5

Genera valores aleatorios. A diferencia de Math, sí requiere crear un objeto e importarse desde java.util.

import java.util.Random;

Random rnd = new Random();
int numero  = rnd.nextInt(10);   // entero de 0 a 9
double dec  = rnd.nextDouble();  // decimal de 0.0 a 1.0
boolean bit = rnd.nextBoolean(); // true o false

import java.text.NumberFormat;

NumberFormat moneda = NumberFormat.getCurrencyInstance();
System.out.println(moneda.format(1234.5)); // $1,234.50

NumberFormat pct = NumberFormat.getPercentInstance();
System.out.println(pct.format(0.75));      // 75%

NumberFormat num = NumberFormat.getNumberInstance();
System.out.println(num.format(1000000));   // 1,000,000

El símbolo de moneda y los separadores dependen del Locale del sistema.

El patrón se arma con estos símbolos:

new DecimalFormat("00.0").format(7.5); // 07.5

new DecimalFormat("##.##").format(7.5); // 7.5

new DecimalFormat("0.00").format(3.5); // 3.50

new DecimalFormat("#,##0").format(1000000); // 1,000,000

new DecimalFormat("0.0%").format(0.85); // 85.0%

import java.text.DecimalFormat;

DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println(df.format(1234.5));   // 1,234.50

DecimalFormat df2 = new DecimalFormat("0.###");
System.out.println(df2.format(3.14159)); // 3.142

DecimalFormat df3 = new DecimalFormat("0.0%");
System.out.println(df3.format(0.85));    // 85.0%

Lee datos de entrada, típicamente desde el teclado (System.in).

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
System.out.print("Edad: ");
int edad = sc.nextInt();

Java distingue entre:

Cada tipo primitivo tiene una clase equivalente:

Integer edad = 25;
System.out.println(edad.toString());

Envolver un primitivo en un objeto nos da capacidades que el primitivo no tiene:

Java convierte automáticamente entre tipos primitivos y sus equivalentes en clases wrapper.

int numero = 20;
Integer edad = numero; // int → Integer

Integer altura = 180;
int h = altura; // Integer → int

int cantidad  = Integer.parseInt("42");       // "42"   → 42
double precio = Double.parseDouble("19.99");   // "19.99" → 19.99
boolean activo = Boolean.parseBoolean("true"); // "true" → true

int total = cantidad * 2; // ya podemos operar como número

El proceso inverso: pasar un número a String para mostrarlo o guardarlo.

int edad = 25;

String a = Integer.toString(edad); // "25"
String b = String.valueOf(edad);   // "25"
String c = "Edad: " + edad;        // "Edad: 25"

Cada wrapper trae valores límite y métodos estáticos listos para usar:

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648

int mayor = Integer.max(8, 3);    // 8
int menor = Integer.min(8, 3);    // 3
int comp  = Integer.compare(5, 9); // -1 (5 es menor)

Útil para validar lo que el usuario escribe, carácter por carácter:

char c = '7';

Character.isDigit(c);        // true  ¿es un dígito?
Character.isLetter('A');     // true  ¿es una letra?
Character.isWhitespace(' '); // true  ¿es un espacio?
Character.toUpperCase('a');  // 'A'   pasar a mayúscula

import java.util.ArrayList;

ArrayList<Integer> notas = new ArrayList<>();
notas.add(90);   // autoboxing: int → Integer
notas.add(85);

int suma = notas.get(0) + notas.get(1); // unboxing → 175

Tipo especial que permite definir un conjunto limitado de valores:

public enum Dia {
    LUNES, MARTES, MIERCOLES, JUEVES, VIERNES
}

Dia hoy = Dia.LUNES;

Se comportan como clases y se pueden comparar:

if (hoy == Dia.LUNES) {
    System.out.println("Inicio de semana");
}