Java 17 y Java 21 son las dos versiones LTS de Java más usadas en producción, publicadas en septiembre de 2021 y 2023. Java 21 añade virtual threads para concurrencia masiva, record patterns y pattern matching para switch, además de colecciones secuenciadas. Ambas reciben soporte oficial durante años, pero para proyectos nuevos Java 21 es la apuesta recomendada.

Java 17 vs Java 21: novedades que debes conocer

Última actualización: agosto 2026

Contenido Rápido

• Java 17 y Java 21 son las dos versiones LTS más usadas en producción
• Java 21 finalizó virtual threads, record patterns y pattern matching para switch
• Las colecciones secuenciadas añaden getFirst(), getLast() y reversed()
• String templates quedaron en preview y se eliminaron en Java 23
• Oracle da soporte Premier hasta 2029 para Java 17 y hasta 2031 para Java 21
• Para proyectos nuevos, Java 21 es la recomendación en 2026

Si montas un proyecto nuevo o revisas la versión de Java de tu equipo, aparece la misma pregunta: ¿Java 17 o Java 21? Ambas son LTS y sirven para producción. La diferencia está en lo que Java 21 añadió y en cuánto te conviene adoptarlo.

Esta guía compara ambas con datos concretos: soporte, novedades y cuándo migrar. Los ejemplos son Java puro, sin frameworks. Para probarlos necesitas un JDK; si no lo tienes, empieza por instalar Java y vuelve.

Java 17 y Java 21: dos LTS y por qué importan

Java 17 se publicó en septiembre de 2021 y fue la primera LTS desde Java 11. Incluye novedades hoy habituales: records, sealed classes, text blocks, switch expressions y pattern matching para instanceof.

Java 21 llegó en septiembre de 2023 como la tercera LTS del ciclo (11, 17, 21). Cerró la brecha con el desarrollo moderno: virtual threads, record patterns, pattern matching para switch, colecciones secuenciadas y un ZGC generacional. También probó string templates, que se eliminaron en Java 23.

En producción, la etiqueta LTS define el calendario de soporte. Oracle da soporte Premier hasta 2029 para Java 17 y hasta 2031 para Java 21, según la hoja de ruta de soporte de Oracle. Las versiones sin LTS reciben actualizaciones solo seis meses; por eso el debate real es siempre entre LTS.

Tabla de comparación: Java 17 vs Java 21

Característica	Java 17	Java 21
Fecha de lanzamiento	Septiembre 2021	Septiembre 2023
Tipo de versión	LTS	LTS
Novedades principales	Records, sealed classes, text blocks, switch expressions	Virtual threads, record patterns, pattern matching para switch, colecciones secuenciadas
String templates	No existían	Preview en 21, eliminados en 23
Soporte Premier Oracle	Hasta septiembre 2029	Hasta septiembre 2031
Cuándo usarla	Proyectos legacy estables	Proyectos nuevos y cargas I/O-bound

La tabla resume lo esencial: Java 17 es la base estable y Java 21 suma cuatro novedades importantes. El soporte depende del proveedor: Temurin o Corretto ofrecen plazos parecidos, no idénticos, a los de Oracle.

Novedades de Java 21 explicadas con código

Java 21 no reescribe el lenguaje: casi todas sus novedades estuvieron en preview y aquí se finalizaron. El código que escribes con Java 17 compila igual en Java 21 sin tocar una línea. La base común incluye records y text blocks, presentes en ambas. Este record con un text block compila en las dos:

public record Punto(int x, int y) {

    public String descripcion() {
        return """
                Punto en (%d, %d)
                """.formatted(x, y);
    }

    public static void main(String[] args) {
        System.out.println(new Punto(3, 4).descripcion());
    }
}

Ejecuta estos ejemplos en el Java Playground de CodeJa: compila y ejecuta Java en el navegador sin instalar nada. Todos los fragmentos de esta guía son Java puro, así que caben en el playground sin configuración.

Virtual threads

La novedad estrella de Java 21 son los virtual threads, definidos en el JEP 444. Son hilos gestionados por la JVM, no por el sistema operativo: millones conviven sobre unos pocos hilos de plataforma y cada bloqueo libera el hilo subyacente. Para ti no cambia la API: sigues escribiendo Runnable, pero cada hilo cuesta mucho menos.

Esto hace de Java una opción fuerte para servicios I/O-bound, los que pasan el tiempo esperando a una base de datos o una API externa. Antes hacía falta reactividad o un pool enorme de hilos; ahora un hilo por petición vuelve a ser viable. El ejemplo lanza 100 tareas, cada una en su propio hilo ligero:

import java.util.concurrent.Executors;

public class VirtualThreads {

    public static void main(String[] args) throws InterruptedException {
        Thread hiloVirtual = Thread.ofVirtual()
                .name("tarea-ligera")
                .start(() -> System.out.println("Hola desde un virtual thread"));

        hiloVirtual.join();

        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 1; i <= 100; i++) {
                int tarea = i;
                executor.submit(() -> System.out.println("Tarea " + tarea));
            }
        }
    }
}

El try-with-resources cierra el executor y espera a que terminen todas las tareas. Con la API clásica, 100 hilos de plataforma consumen mucha más memoria.

Record patterns

Los record patterns, finalizados en Java 21 con el JEP 440, descomponen un record en un patrón instanceof. En vez de extraer los componentes a mano, escribes la forma del dato. El record Punto anterior se desestructura así:

public class RecordPatterns {

    public record Punto(int x, int y) {
    }

    public static String ubicacion(Object obj) {
        if (obj instanceof Punto(int x, int y)) {
            return "Punto en (%d, %d)".formatted(x, y);
        }
        return "No es un punto";
    }

    public static void main(String[] args) {
        System.out.println(ubicacion(new Punto(3, 4)));
        System.out.println(ubicacion("Hola"));
    }
}

Cuando el objeto es un Punto, x e y reciben sus componentes; si no lo es, el patrón no casa. Es el estilo de datos inmutables de los records que ya viste en programación funcional.

Pattern matching para switch

El pattern matching para switch, finalizado en Java 21 con el JEP 441, extiende la idea: cada case declara un patrón y la rama recibe el valor descompuesto. Combinado con records, sustituye las cadenas de if-else con instanceof:

public class SwitchPatterns {

    public record Circulo(double radio) {
    }

    public record Rectangulo(double ancho, double alto) {
    }

    public static String describir(Object obj) {
        return switch (obj) {
            case Circulo c -> "Círculo de radio %.2f".formatted(c.radio());
            case Rectangulo r -> "Rectángulo de %.1f por %.1f".formatted(r.ancho(), r.alto());
            default -> "Tipo desconocido";
        };
    }

    public static void main(String[] args) {
        System.out.println(describir(new Circulo(2.5)));
        System.out.println(describir(new Rectangulo(3.0, 4.0)));
    }
}

El switch maneja null y tipos desconocidos de forma explícita, y el compilador verifica la exhaustividad en tipos sealed. Si ya usas lambdas en Java 8, la sintaxis con flecha te resultará familiar: es la de los switch expressions de Java 14.

Colecciones secuenciadas

Las colecciones secuenciadas, finalizadas en Java 21 con el JEP 431, resuelven una carencia histórica: acceder al primer y al último elemento de forma uniforme. La interfaz SequencedCollection añade getFirst(), getLast() y reversed(), y la implementan List, Deque y SortedSet:

import java.util.ArrayList;
import java.util.SequencedCollection;

public class ColeccionesSecuenciadas {

    public static void main(String[] args) {
        SequencedCollection<String> tareas = new ArrayList<>();
        tareas.add("Primera");
        tareas.add("Segunda");
        tareas.add("Tercera");

        System.out.println("Primera: " + tareas.getFirst());
        System.out.println("Última: " + tareas.getLast());
        System.out.println("Invertida: " + tareas.reversed());
    }
}

Antes dependías de la implementación concreta: get(0) en listas, peekFirst() en colas, first() en TreeSet. Ahora el código contra la interfaz funciona en todas. Una mejora que se nota al trabajar con streams y colecciones a diario.

¿Vale la pena migrar de Java 17 a Java 21?

Migrar de Java 17 a Java 21 es un cambio de JDK, no de arquitectura. En la mayoría de los proyectos, compilar con Java 21 funciona sin tocar código: la API de Java 17 se mantiene casi intacta. El esfuerzo real está en el ecosistema, no en el lenguaje.

• Tu equipo ya usa Java 17: la migración es barata. Revisa flags de la JVM y dependencias, y el riesgo es bajo. Si vienes de Java 8 u 11, el salto es mayor.
• Cargas I/O-bound: aquí ganan los virtual threads. Si tus servicios esperan a bases de datos o APIs externas, Java 21 reduce la infraestructura. Para cargas CPU-bound no hay diferencia relevante.
• Dependencias y librerías: lo que puede romper la migración es una librería que use APIs internas del JDK o reflection. Comprueba que las tuyas soportan Java 21; en 2026 las principales ya lo hacen.
• Compatibilidad de frameworks: Spring Boot 3.2 y Jakarta EE 10 corren sobre Java 21. Si mantienes versiones antiguas, verifica antes de saltar.

Si adoptas Java 21, conviene formarse: los cursos de CodeJa practican estas novedades y la ruta de junior a senior las integra en un plan de crecimiento. Para ver hacia dónde va el lenguaje, repasa las novedades de Java 24.

Preguntas Frecuentes

¿Vale la pena migrar de Java 17 a Java 21?

Sí, en la mayoría de los casos. El código que compila con Java 17 lo hace casi siempre con Java 21 sin cambios. Es un cambio de JDK, no de arquitectura, y el beneficio principal está en los virtual threads para servicios I/O-bound.

¿Java 21 es LTS? ¿Hasta cuándo tiene soporte?

Sí, Java 21 es una versión LTS publicada en septiembre de 2023. Oracle ofrece soporte Premier hasta septiembre de 2031 y soporte extendido hasta 2036. Los distribuidores como Temurin o Corretto ofrecen calendarios similares.

¿Qué novedades importantes trae Java 21?

Las cuatro más destacadas son virtual threads, record patterns, pattern matching para switch y colecciones secuenciadas. A ellas se sumó una versión generacional de ZGC y previews como structured concurrency. String templates también quedaron en preview, pero se eliminaron en Java 23.

¿Java 17 sigue siendo una buena opción para proyectos nuevos?

Sí, sigue siendo válida y con soporte hasta 2029, sobre todo si tu equipo la domina. Para un proyecto nuevo, no hay una razón fuerte para elegir 17 cuando 21 ofrece las mismas APIs y más novedades.

¿Qué Java debo usar en 2026?

Java 21, por ser la LTS con mejor equilibrio entre soporte y novedades útiles para producción. Si ya estás en Java 17, migrar es barato; si empiezas desde cero, comienza en 21. Antes de decidir, revisa la LTS vigente y el calendario de tu proveedor.

Artículos Relacionados

• Instalar Java: guía para empezar
• Programación funcional en Java: guía completa
• Lambdas en Java 8: qué son y ejemplos
• Qué es un Java Stream y cómo funciona
• Novedades de Java 24