Java: El Gigante Empresarial

Java es uno de los lenguajes de programación más establecidos e influyentes del mundo. Lanzado por Sun Microsystems en 1995, Java se convirtió en sinónimo de desarrollo empresarial robusto, con su filosofía “Write Once, Run Anywhere” y la poderosa Java Virtual Machine (JVM).

¿Por qué Java? Java alimenta miles de millones de dispositivos, desde servidores empresariales hasta smartphones Android. Frameworks como Spring Boot han hecho el desarrollo moderno con Java más productivo que nunca.

Características Modernas (Java 17+)

1. Records - Clases de datos inmutables concisas
2. Sealed Classes - Jerarquías de tipos controladas
3. Pattern Matching - Switch expressions expresivas
4. Text Blocks - Strings multilínea
5. Virtual Threads - Concurrencia ligera y escalable
6. Var Keyword - Inferencia de tipo local

Fundamentos

Tipos y Variables

// Tipos primitivos
String nombre = "María";
int edad = 25;
double altura = 1.68;
boolean activo = true;
char inicial = 'M';
long poblacion = 8_000_000_000L;

// Inferencia de tipo (Java 10+)
var email = "[email protected]";
var lista = new ArrayList<Integer>();

// Arrays
int[] numeros = {1, 2, 3, 4, 5};

// Collections
List<String> frutas = new ArrayList<>();
frutas.add("manzana");
frutas.add("banana");

Map<String, Integer> usuarios = new HashMap<>();
usuarios.put("alice", 25);
usuarios.put("bob", 30);

Set<String> tags = new HashSet<>(Set.of("java", "spring", "backend"));

Clases y Objetos

import java.time.LocalDateTime;

public class Usuario {
    private final int id;
    private String nombre;
    private final String email;
    private final LocalDateTime creadoEn;
    
    public Usuario(int id, String nombre, String email) {
        this.id = id;
        this.nombre = nombre;
        this.email = email;
        this.creadoEn = LocalDateTime.now();
    }
    
    public int getId() { return id; }
    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }
    public String getEmail() { return email; }
    
    public String saludar() {
        return String.format("¡Hola, %s!", nombre);
    }
}

// Record (Java 14+)
public record Producto(String nombre, double precio, int cantidad) {
    public Producto {
        if (precio < 0) throw new IllegalArgumentException("Precio debe ser positivo");
    }
    
    public double valorTotal() {
        return precio * cantidad;
    }
}

Streams y Lambdas

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamsEjemplo {
    public void demostrar() {
        var productos = List.of(
            new Producto("Laptop", 3500, 2),
            new Producto("Mouse", 150, 10),
            new Producto("Teclado", 300, 5),
            new Producto("Monitor", 1200, 3)
        );
        
        // Filtrar y ordenar
        var caros = productos.stream()
            .filter(p -> p.precio() > 500)
            .sorted((a, b) -> Double.compare(b.precio(), a.precio()))
            .toList();
        
        // Map para transformar
        var nombres = productos.stream()
            .map(Producto::nombre)
            .collect(Collectors.toList());
        
        // Reduce para agregar
        var total = productos.stream()
            .mapToDouble(Producto::valorTotal)
            .sum();
        
        // Agrupación
        Map<String, List<Producto>> porCategoria = productos.stream()
            .collect(Collectors.groupingBy(p -> 
                p.precio() > 1000 ? "Premium" : "Standard"
            ));
    }
}

Pattern Matching (Java 21+)

public String describir(Object obj) {
    return switch (obj) {
        case null -> "Nulo";
        case String s when s.isEmpty() -> "String vacío";
        case String s -> "String: " + s;
        case Integer i when i > 0 -> "Entero positivo: " + i;
        case Integer i -> "Entero: " + i;
        case List<?> list -> "Lista con %d elementos".formatted(list.size());
        default -> "Objeto: " + obj.getClass().getSimpleName();
    };
}

Virtual Threads (Java 21+)

import java.util.concurrent.*;
import java.time.Duration;

public class VirtualThreadsEjemplo {
    public void demostrarVirtualThreads() throws Exception {
        Thread.startVirtualThread(() -> {
            System.out.println("¡Hola desde virtual thread!");
        });
        
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = new ArrayList<>();
            
            for (int i = 0; i < 10_000; i++) {
                final int id = i;
                futures.add(executor.submit(() -> {
                    Thread.sleep(Duration.ofMillis(100));
                    return "Resultado " + id;
                }));
            }
            
            for (var future : futures) {
                System.out.println(future.get());
            }
        }
    }
}

Herramientas Esenciales

Herramienta	Propósito
Maven	Gestión de dependencias y build
Gradle	Build moderno y flexible
Spring Boot	Framework para aplicaciones
JUnit 5	Tests unitarios
IntelliJ IDEA	IDE más popular

Lista de Verificación de Aprendizaje

• Dominar OOP y colecciones
• Aprender Streams y lambdas
• Estudiar generics avanzados
• Explorar características de Java 17+
• Practicar con Spring Boot
• Entender JPA/Hibernate
• Construir una API REST

Recursos Esenciales

• Java Documentation
• Baeldung
• Spring Guides
• JetBrains Academy

Cita

“Java sigue siendo uno de los lenguajes más robustos y confiables para sistemas empresariales.” - Josh Long

---

¡Java es la elección correcta para sistemas que necesitan robustez, escalabilidad y mantenibilidad a largo plazo!