Java 8, lanzado en marzo de 2014, introdujo varias características importantes que modernizaron el
lenguaje y la plataforma Java, mejorando la eficiencia, la funcionalidad y la programación funcional. A
continuación se detallan las principales características de Java 8:
1. Expresiones Lambda
Las expresiones lambda permiten tratar funcionalmente el código, facilitando la escritura de funciones
anónimas y la programación funcional.
Ejemplo:
java Copiar código
// Sin lambda Runnable runnable = new Runnable() { @Override public void run() {
System.out.println("Hello world"); } }; // Con lambda Runnable runnableLambda = () ->
System.out.println("Hello world");
2. Streams API
La API de Streams introduce una nueva manera de procesar datos de manera declarativa. Permite
operaciones como filtrado, mapeo, y reducción en colecciones de datos.
Ejemplo:
java Copiar código
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1"); myList.stream()
.filter(s -> s.startsWith("c")) .map(String::toUpperCase) .sorted()
.forEach(System.out::println);
3. Interfaz Funcional y @FunctionalInterface
Una interfaz funcional es una interfaz que contiene un solo método abstracto. Estas son ideales para
expresiones lambda y referencias a métodos.
Ejemplo:
java Copiar código
@FunctionalInterface public interface MyFunctionalInterface { void execute(); } // Uso
con lambda MyFunctionalInterface func = () -> System.out.println("Executing");
func.execute();
4. Métodos Predeterminados y Estáticos en Interfaces
Las interfaces ahora pueden tener métodos con implementación (default methods) y métodos
estáticos.
Ejemplo:
java Copiar código
public interface MyInterface { default void defaultMethod() { System.out.println("Default
method"); } static void staticMethod() { System.out.println("Static method"); } } class
MyClass implements MyInterface {} public class Main { public static void main(String[]
args) { MyClass obj = new MyClass(); obj.defaultMethod(); // Llama al método por defecto
MyInterface.staticMethod(); // Llama al método estático } }
5. Nueva API de Fecha y Hora (java.time)
Java 8 introduce una nueva API de fecha y hora que es inmutable y más amigable para el
desarrollador, basada en la librería Joda-Time.
Ejemplo:
java Copiar código
LocalDate today = LocalDate.now(); LocalDate birthday = LocalDate.of(1990, Month.APRIL,
25); Period age = Period.between(birthday, today); System.out.println("Age: " +
age.getYears());
6. Referencias a Métodos
Las referencias a métodos proporcionan una forma corta y clara de referirse a métodos y constructores
existentes.
Ejemplo:
java Copiar código
// Referencia a un método estático Function<String, Integer> parseInt =
Integer::parseInt; // Referencia a un método de instancia de un objeto particular String
str = "Hello"; Supplier<String> supplier = str::toUpperCase; // Referencia a un método de
instancia de un objeto arbitrario de un tipo particular Function<String, String>
toUpperCase = String::toUpperCase;
7. Opcional (java.util.Optional)
Optional es una clase contenedora que puede o no contener un valor no nulo. Se usa para evitar el
uso de null y evitar excepciones NullPointerException.
Ejemplo:
java Copiar código
Optional<String> optional = Optional.of("Hello");
optional.ifPresent(System.out::println); // Imprime "Hello" String value =
optional.orElse("Default"); System.out.println(value); // Imprime "Hello"
Optional<String> emptyOptional = Optional.empty(); String emptyValue =
emptyOptional.orElse("Default"); System.out.println(emptyValue); // Imprime "Default"
8. Mejoras en la Concurrencia
Java 8 introduce mejoras en la API de concurrencia, incluyendo la adición de la clase
CompletableFuture y mejoras en la clase ForkJoinPool.
Ejemplo:
java Copiar código
CompletableFuture.supplyAsync(() -> "Hello") .thenApply(result -> result + " World")
.thenAccept(System.out::println);
9. PermGen eliminado
El espacio de generación permanente (PermGen) ha sido eliminado y reemplazado por el Metaspace, lo
que mejora la gestión de memoria de las clases cargadas dinámicamente.
Resumen
Java 8 marcó un hito importante en la evolución del lenguaje Java, introduciendo características
funcionales, mejorando la API existente y ofreciendo nuevas herramientas para facilitar el desarrollo y
mejorar la eficiencia del código. Las principales características incluyen expresiones lambda, Streams
API, interfaces funcionales, métodos predeterminados y estáticos en interfaces, una nueva API de fecha
y hora, referencias a métodos, Optional, mejoras en la concurrencia y la eliminación de PermGen.
