DEV Community: Jordi Ayala

Cómo escribir DTOs en Java

Jordi Ayala — Mon, 02 Jun 2025 13:00:00 +0000

Un DTO (Data Transfer Object) es un objeto que permite mover datos entre diferentes capas de una aplicación, por ejemplo, entre un cliente y un servidor. Dentro de Java existen diferentes formas de implementarlo, ya sea con alguna estructura propia del lenguaje o alguna librería externa, lo cual está condicionado por la versión de Java que se esté utilizando. Durante este post veremos tres formas de implementar un DTO: dos de ellas utilizando solo Java y la última con una librería externa.

Definición de DTO

Crear un DTO conlleva tener los siguientes elementos:

Propiedades.
Constructor vacío y/o constructor con parámetros.
Getters y setters.
toString().
equals().
hashCode().

Para los siguientes ejemplos utilizaremos una clase User con los siguientes atributos:

id (int).
name (String).
lastName (String).
username (String).
email (String).

Un DTO puede o no contener todos los elementos de un objeto normal, dependiendo de la necesidad del mismo.

POJO

Considerando todos los elementos anteriores, un DTO en su forma más básica y sin utilizar ninguna librería externa ni características de versiones nuevas de Java, se puede ver como un POJO (Plain Old Java Object).

import java.util.Objects;

/**
 * Data Transfer Object (DTO) for representing user information.
 */
public class UserDto {

    private int id;
    private String username;
    private String email;

    /**
     * Constructor to initialize a UserDto object with the given parameters.
     *
     * @param id       the unique identifier for the user
     * @param username the username of the user
     * @param email    the email address of the user
     */
    public UserDto(int id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    /**
     * Gets the unique identifier of the user.
     *
     * @return the user ID
     */
    public int getId() {
        return id;
    }

    /**
     * Sets the unique identifier of the user.
     *
     * @param id the user ID to set
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * Gets the username of the user.
     *
     * @return the username
     */
    public String getUsername() {
        return username;
    }

    /**
     * Sets the username of the user.
     *
     * @param username the username to set
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * Gets the email address of the user.
     *
     * @return the email address
     */
    public String getEmail() {
        return email;
    }

    /**
     * Sets the email address of the user.
     *
     * @param email the email address to set
     */
    public void setEmail(String email) {
        this.email = email;
    }

    /**
     * Returns a string representation of the UserDto object.
     *
     * @return a string containing the user's ID, username, and email
     */
    @Override
    public String toString() {
        return "UserDto{" + "id=" + id +
                ", username='" + username + '\'' +
                ", email='" + email + '\'' +
                '}';
    }

    /**
     * Compares this UserDto object to another object for equality.
     *
     * @param o the object to compare with
     * @return true if the objects are equal, false otherwise
     */
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof UserDto userDto)) return false;
        return getId() == userDto.getId() && Objects.equals(getUsername(), userDto.getUsername()) && Objects.equals(getEmail(), userDto.getEmail());
    }

    /**
     * Generates a hash code for the UserDto object based on its fields.
     *
     * @return the hash code
     */
    @Override
    public int hashCode() {
        return Objects.hash(getId(), getUsername(), getEmail());
    }
}

A pesar de que es un objeto muy sencillo, con solo 3 atributos, la cantidad de código que se tiene que escribir es considerable, incluso si se utiliza un IDE que genere el código automáticamente. Esta es la manera más básica/tradicional de crear un DTO, pero no es la única. A continuación veremos otras maneras de hacerlo.

Lombok

Lombok es una librería que permite reducir la cantidad de código que se tiene que escribir para crear un DTO, y en general para cualquier objeto, mediante el uso de anotaciones. Una ventaja es que nos permite reducir el boilerplate code. El código anterior se puede simplificar de la siguiente manera:

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserDtoLombok {

    private int id;
    private String username;
    private String email;

}

De esta forma, el código se reduce considerablemente, por lo que nos podemos concentrar en definir lo que realmente importa, que son los atributos del DTO. Solo es necesario utilizar las anotaciones correctas y Lombok realizará el resto. Una vez que se compila el código, Lombok generará el código para el constructor, getters, setters, toString(), equals() y hashCode() automáticamente.

Record

A partir de Java 14, se introdujo la característica de Record, que permite crear clases inmutables de una manera más sencilla. Un Record es una clase especial, muy similar a una clase normal de Java, pero con algunas diferencias clave, por ejemplo, la manera en que se declara. Considerando que es inmutable, resulta muy conveniente para utilizar como DTO.

public record UserRecord(int id, String username, String email) { }

Ahora solo es necesario definir los atributos y nada más. El compilador generará automáticamente el constructor, getters, toString(), equals() y hashCode(). De esta manera, resulta más sencillo y limpio crear un DTO, o incluso un objeto normal, sin la necesidad de escribir tanto código.

Uso

Una vez vistas las maneras en que se puede crear un DTO, veamos cómo se puede utilizar.

public class Main {

    public static void main(String[] args) {
        User user = new User(1, "John", "Doe", "jdoe", "johndoe@gmail.com");
        UserDto userDto = new UserDto(user.getId(), user.getUsername(), user.getEmail());
        UserDtoLombok userDtoLombok = new UserDtoLombok(user.getId(), user.getUsername(), user.getEmail());
        UserRecord userRecord = new UserRecord(user.getId(), user.getUsername(), user.getEmail());
    }

}

Partiendo de un objeto "más completo", podemos obtener solo los datos que se requieren para el DTO, y así evitar enviar información innecesaria. El objeto User sirve como base para los demás objetos, es decir, es el objeto completo que contiene todos los atributos, mientras que los demás objetos son solo una representación de los atributos que se requieren. La manera de utilizar cualquier representación es similar, con la excepción de que un Record no tiene setters, ya que es inmutable.

Conclusión

En este post hemos visto tres maneras de crear un DTO en Java, cada una con sus ventajas y desventajas. En general, utilizar versiones más recientes de Java es recomendable, ya que pueden tener características que faciliten ciertas tareas, como en este caso el uso de Record.

Si te interesa saber más sobre Lombok o los records en general, puedes consultar los siguientes enlaces:

Tips para escribir mejor código en Java

Jordi Ayala — Mon, 26 May 2025 16:00:15 +0000

Cada uno de los siguientes tips/trucos por sí solos pueden parecer insignificantes, pero en conjunto permiten tener un código más fácil de leer, más mantenible y menos propenso a errores, a la vez que hacen uso de características modernas de Java. En cada uno de los ejemplos se muestra una versión "mala" y una versión "buena" del código, donde la segunda es la recomendada.

1. try-with-resources

En lugar de tener que preocuparse por cerrar recursos manualmente, ya sea comprobando si han sido abiertos o utilizando un bloque finally, podemos utilizar un bloque try-with-resources que se encarga de cerrar automáticamente los recursos una vez que ya no se están utilizando. Esto es especialmente útil para manejar archivos, conexiones de red, bases de datos, etc.

BufferedReader br = null;

try {
    br = new BufferedReader(new FileReader("data.txt"));
    String line;

    while ((line = br.readLine()) != null) System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (br != null) try {
        br.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    String line;
    while ((line = br.readLine()) != null) System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
}

2. StringBuilder

Dado que un String es inmutable, cuando se concatena utilizando el operador + se crean múltiples objetos String en memoria, lo que puede ser ineficiente. En su lugar, podemos utilizar un StringBuilder, que es mutable y permite concatenar cadenas de manera más eficiente. Incluso el propio IDE puede llegar a realizar esta recomendación de manera automática.

String res = "";

for (int i = 0; i < 10000; i++) {
    res += i;
}

System.out.println(res);

StringBuilder res = new StringBuilder();

for (int i = 0; i < 10000; i++) {
    res.append(i);
}

System.out.println(res);

3. Early Return

En lugar de anidar múltiples bloques if y else, podemos utilizar un retorno anticipado para simplificar el flujo del código. Esto mejora la legibilidad y mantenibilidad del código.

private void processOrder(Order o) {
    if (o != null) {
        if (o.isValid()) {
            if (o.hasValidItems()) {
                // process order
            } else {
                // handle invalid items
            }
        } else {
            // handle invalid order
        }
    } else {
        // handle null order
    }
}

private void processOrder(Order o) {
    if (o == null) {
        // handle null order
        return;
    }

    if (!o.isValid()) {
        // handle invalid order
        return;
    }

    if (!o.hasValidItems()) {
        // handle order with invalid items
        return;
    }

    // Process order
}

4. Enums

Los enums proveen seguridad de tipos, permiten crear un código más autodocumentado y evitan el uso de constantes mágicas, incluso permiten agregar métodos y atributos a los mismos. En lugar de utilizar constantes enteras o cadenas de texto, podemos utilizar enums para representar un conjunto fijo de valores.

class Status {
    public static final int ACTIVE = 1;
    public static final int INACTIVE = 0;
}

public void process(int status) {
    if (status == Status.ACTIVE) {
        // do something
    }
}

public enum Status {
    ACTIVE,
    INACTIVE
}

public void process(Status status) {
    if (status == Status.ACTIVE) {
        // do something
    }
}

5. Optional

El uso de Optional permite evitar las posibles comprobaciones respecto de null, las excepciones NullPointerException y el uso de bloques if-else, lo que mejora la legibilidad y mantenibilidad del código. En lugar de devolver null para indicar la ausencia de un valor, podemos utilizar Optional para representar un valor que puede o no estar presente.

public static String getNormalizedName(Person p) {
    if (p != null && p.getName() != null) {
        return p.getName().toUpperCase();
    }

    return null;
}

public static String getNormalizedName(Person p) {
    return Optional.ofNullable(p)
            .map(Person::getName)
            .map(String::toUpperCase)
            .orElse("UNKNOWN");
}

6. Lambdas y Referencias de Métodos

Utilizar lambdas y referencias de métodos permite escribir código más conciso y legible, especialmente al trabajar con colecciones y la API de Streams. De esta manera se pueden eliminar clases anónimas, bucles innecesarios y código verboso.

List<String> names = Arrays.asList("John", "Mary", "Peter", "Paul", "Anna");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

List<String> names = Arrays.asList("John", "Mary", "Peter", "Paul", "Anna");

names.sort(String::compareTo);

7. Static Factory Methods

En ocasiones puede resultar factible usar métodos de fábrica estáticos en lugar de constructores, ya que permiten crear instancias de una clase de manera más legible y flexible. Esto es especialmente útil cuando se trabaja con clases inmutables o cuando se desea proporcionar diferentes formas de crear instancias.

public class Car {

    public Car (String model, int year, String color) {
        // logic
    }

}

public static void main(String[] args) {
    var car = new Car("Fiat", 2020, "red");
}

public class Car {

    private String model;
    private int year;
    private String color;

    private Car (String model, int year, String color) {
        this.model = model;
        this.year = year;
        this.color = color;
    }

    public static Car of(String model, int year, String color) {
        // Extra validation or logic
        return new Car(model, year, color);
    }

}

public static void main(String[] args) {
    var car = Car.of("Toyota", 2020, "Red");
}

8. Logging

En lugar de utilizar System.out.println para imprimir mensajes de depuración o información, es recomendable utilizar un framework de logging como Log4j, SLF4J o java.util.logging. Esto permite un mejor control sobre los niveles de logging, la configuración y la salida de los mensajes. Incluso algunos frameworks, como SLF4J, permiten un logging parametrizable, o el uso de Supplier para evitar la creación de cadenas innecesarias.

System.out.println("Attempting to read last fetch date");

LOGGER.log(Level.INFO, () -> "Attempting to read last fetch date");

9. Objects.requireNonNull

Objects.requireNonNull es un método estático que permite verificar si un objeto es null y lanzar una NullPointerException con un mensaje personalizado. Esto es útil para validar argumentos en métodos y constructores, evitando la necesidad de escribir bloques if adicionales.

public class Person {

    private String name;

    public void setName(String name) {
        if (name == null) {
            throw new IllegalArgumentException("Name cannot be null");
        }

        this.name = name;
    }

}

import java.util.*;

public class Person {

    private String name;

    public void setName(String name) {
        this.name = Objects.requireNonNull(name, "Name cannot be null");
    }

}

10. computeIfAbsent en Map

El método computeIfAbsent de la interfaz Map permite calcular un valor y agregarlo al mapa solo si la clave no está presente. Esto es útil para evitar comprobaciones adicionales e inicializar valores de manera más concisa.

String str = "hello";
Map<String, List<String>> map = new HashMap<>();

if (!map.containsKey("key")) {
    map.put("key", new ArrayList<>());
}

map.get("key").add(str);

String str = "hello";
Map<String, List<String>> map = new HashMap<>();
map.computeIfAbsent("key", k -> new ArrayList<>()).add(str);

11. merge en Map

El método merge de la interfaz Map permite combinar valores de manera más concisa y eficiente. Esto es útil para evitar comprobaciones adicionales y simplificar la lógica de combinación.

String str = "hello";
Map<Character, Integer> map = new HashMap<>();

for (char c : str.toCharArray()) {
    if (!map.containsKey(c)) {
        map.put(c, 1);
    } else {
        map.put(c, map.get(c) + 1);
    }
}

String str = "hello";
Map<Character, Integer> map = new HashMap<>();

for (char c : str.toCharArray()) {
    map.merge(c, 1, Integer::sum);
}

12. Records

Los records son una característica relativamente nueva que permite crear clases inmutables de manera más concisa. Esto es útil para representar datos sin necesidad de escribir código adicional para constructores, métodos equals, hashCode y toString, es decir, evitar el típico boilerplate de Java. Pueden resultar muy útiles para representar objetos de valor o DTOs (Data Transfer Objects), y también pueden ser utilizados con Pattern Matching.

public class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public record Person(String name, int age) {}

Conclusión

Estos son solo algunos de los muchos tips y trucos que pueden ayudarte a escribir código más limpio y eficiente en Java. A continuación puedes encontrar enlaces a diferentes post donde se ven a profundidad algunos de estos temas.

Convertir Data Sources a Streams en Java

Jordi Ayala — Mon, 19 May 2025 13:00:00 +0000

En publicaciones anteriores de esta serie de tutoriales, analizamos la conversión de bucles con estilo imperativo a un estilo funcional. En este post, veremos cómo ver un data source desde una perspectiva funcional, como un Stream o flujo de datos y cómo convertir la iteración usando la API Stream en Java.

Ya hemos visto como usar los métodos filter() y map() para filtrar y transformar datos, respectivamente, y cómo usar estas operaciones en medio de un pipeline de operaciones. Podemos usar los métodos range() y rangeClosed() para crear un flujo de valores en un rango de números determinado. Esto funciona bien cuando queremos iterar sobre un rango conocido de valores, pero a menudo, podemos requerir trabajar con datos que provienen de fuentes externas, por ejemplo, un archivo de texto. Si podemos trabajar con un recurso externo como un flujo (stream), entonces podemos aplicar fácilmente operaciones funcionales. En este post veremos un ejemplo que ilustra esta idea.

Estilo imperativo a funcional

Supongamos que queremos iterar sobre las líneas de un archivo, y a su vez contar la cantidad de líneas donde aparece una determinada palabra. A continuación, se muestra el código que realiza esta tarea de forma imperativa:

Path path = Paths.get("data.txt");
String targetWord = "lorem";

try (Reader r = new FileReader(path.toFile());
     BufferedReader br = new BufferedReader(r)) {
    String line;
    int count = 0;

    while ((line = br.readLine()) != null) {
        if (line.contains(targetWord)) {
            count++;
        }
    }

    System.out.printf("Found %d lines with the word %s%n", count, targetWord);

} catch (IOException e) {
    e.printStackTrace();
}

En este ejemplo, utilizamos la variable path para hacer referencia a un archivo de texto llamado data.txt, y targetWord es la palabra que queremos buscar en cada línea del archivo, en caso de querer utilizar otro archivo y palabra a buscar, simplemente debemos cambiar el valor de estas variables.

Este ejemplo consta de dos partes principales. Utilizamos BufferedReader para leer el contenido del archivo que nos interesa consultar. Luego, en el bucle while, verificamos cada línea para ver si contiene la palabra deseada y, si es así, incrementamos el valor de la variable de conteo count para indicar que hemos encontrado una línea que contiene la palabra.

Examinemos las dos partes, comenzado por la segunda. Si observamos de cerca el bucle, a partir de post anteriores, podemos reconocer que la presencia de un condicional if es una señal de que podemos usar la operación filter() si podemos escribir el código como una secuencia funcional. Una vez que filtramos las líneas que contiene la palabra deseada, podemos contar la cantidad de líneas, utilizando el método count() de la API Stream.

Pasemos a la primera parte. Los datos, es decir, las líneas de texto, proviene del archivo cuya ruta se proporciona en la variable path. Estamos leyendo los datos utilizando el método readLine() de BufferedReader e iterando sobre cada línea de texto. Entonces puede surgir la siguiente pregunta, ¿Es posible obtener el contenido de un archivo como un flujo de datos en Java?

Afortunadamente, la respuesta es que sí. Se han agregado características al JDK que permiten trabajar con archivos como un flujo de datos (stream). Una forma sencilla de convertir el contenido de un archivo en un flujo de datos es utilizando el método lines() de la clase Files que forma parte del paquete java.nio.file. Ahora podemos refactorizar el código anterior para que sea más funcional.

Path path = Paths.get("data.txt");
String targetWord = "lorem";

try (Stream<String> stream = Files.lines(path)) {
    var count = stream.filter(line -> line.contains(targetWord)).count();
    System.out.printf("Found %d lines with the word %s%n", count, targetWord);

} catch (IOException e) {
    e.printStackTrace();
}

El método lines() no solo proporciona un flujo de datos sobre el contenido de un archivo, sino que también elimina gran parte de los problemas que implica leer las líneas de un archivo. En lugar del iterador externo, donde obteníamos una línea a la vez, el stream permite utilizar un iterador interno, de forma que podemos centrarnos en qué hacer con cada línea de texto a medida que aparece en el flujo de datos.

En el código refactorizado, el flujo de datos se cierra automáticamente al final del bloque try-with-resources, por lo que no es necesario cerrarlo explícitamente. El método filter() se utiliza para filtrar las líneas que contienen la palabra deseada, y el método count() se utiliza para contar la cantidad de líneas que cumplen con el criterio de filtrado.

Siempre que se trabaje con una colección de datos de un recurso externo, nos podemos preguntar si existe una manera para obtener un stream del contenido del recurso. Es probable que exista una función dentro del JDK o incluso una biblioteca de terceros. Una vez que obtenemos un flujo de datos, podemos usar operadores funcionales como filter(), map(), etc., para iterar y realizar operaciones sobre los datos.

En esta serie de publicaciones cubrimos las siguientes conversiones del estilo imperativo al funcional:

Convertir elementos usando map en Java

Jordi Ayala — Mon, 12 May 2025 15:00:00 +0000

En el post anterior analizamos la conversión de bucles con condicionales de un estilo imperativo a uno funcional. En este post veremos cómo convertir una iteración que transforma datos a un estilo completamente funcional. Además, también refactorizaremos el código que combina la transformación de datos con el código que filtra a partir de una condición antes de realizar cualquier transformación.

Siempre que transformamos datos dentro de un bucle, podemos usar el método map() de Stream

Estilo imperativo a funcional

Consideremos el siguiente ejemplo donde se itera una colección y se realiza una transformación de sus elementos.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

for (String name : names) {
    System.out.println(name.toUpperCase());
}

En cada paso de la iteración, la variable name se vincula a un nuevo valor. A medida que la iteración avanza de un elemento al siguiente de la colección, cada nombre se transforma a mayúsculas utilizando el método toUpperCase() y se imprime el valor resultante. Ya hemos visto cómo convertir un foreach a un estilo funcional usando el iterador interno de stream(). Si aplicamos esto, el código resultaría algo difícil de manejar, con la lambda pasada al forEach() realizando tanto la transformación como la impresión, de la siguiente manera:

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.forEach(name -> System.out.println(name.toUpperCase()));

Aunque el código anterior producirá los mismos resultados que el código de estilo imperativo, la lambda pasada al método forEach() no es coherente, es difícil de leer y modificar. Antes de seguir refactorizando este código, volvamos al de estilo imperativo para realizar una modificación.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

for (String name : names) {
    String nameInUpperCase = name.toUpperCase();
    System.out.println(nameInUpperCase);
}

En este caso, se ha introducido una variable nameInUpperCase que almacena el resultado de la transformación. De post anteriores, sabemos que un for se puede convertir en un stream() y que la impresión de los valores se puede realizar usando forEach(). Ahora solo nos queda la transformación. Dichas transformaciones se pueden realizar utilizando el operador map() de Stream.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.stream()
        .map(name -> name.toUpperCase())
        .forEach(nameInUpperCase -> System.out.println(nameInUpperCase));

La operación map() transforma los datos en un valor diferente de acuerdo con la función invocada desde dentro de la expresión lambda que se le pasa. En este ejemplo, cada nombre se transforma a su valor en mayúsculas. El valor transformado se imprime de acuerdo a la expresión lambda que se le pasa a forEach(). El código resultante es más coherente, fácil de leer y modificar.

Podemos hacer que el código sea un poco más conciso utilizando referencias de métodos en lugar de expresiones lambda.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.stream()
        .map(String::toUpperCase)
        .forEach(System.out::println);

Usar el método map() para transformar datos mientras se itera sobre una colección de datos.

Filtrar y transformar

Supongamos que, en medio de la iteración, queremos filtrar algunos valores de la colección en función de alguna condición y aplicar una transformación solo a esos elementos. Por ejemplo, ¿Qué pasa si queremos transformar e imprimir solo los nombres que tengan una longitud igual a 4? En el estilo imperativo podríamos hacer algo como esto:

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

for (String name : names) {
    if (name.length() == 4) {
        System.out.println(name.toUpperCase());
    }
}

Ya sabemos que un condicional if se puede refactorizar usando el método filter(). De esta manera, podemos realizar la transformación, utilizando el método filter() antes de la operación map().

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.stream()
        .filter(name -> name.length() == 4)
        .map(String::toUpperCase)
        .forEach(System.out::println);

El método filter() descarta los datos que no se desean y pasa solo los valores que cumplen con la condición específicada. El método map() transforma los valores que pasan la condición en este caso, para que se impriman usando forEach().

En cualquier lugar donde veamos una transformación de datos dentro de un bucle for, podemos utilizar el método map() para realizarlo con un estilo funcional. Además, si dentro del bucle se tiene un condicional para filtrar datos antes de realizar la transformación, podemos usar la API stream() llamando al método filter() antes de la operación map().

Convertir un forEach con if a un Stream con filter en Java

Jordi Ayala — Mon, 05 May 2025 13:00:00 +0000

En el post anterior vimos cómo convertir un bucle for con incremento distinto de 1, y un bucle for infinito a un estilo completamente funcional utilizando el método iterate() de IntStream. En este post veremos como convertir un bucle foreach de un estilo imperativo a un estilo funcional, además de cómo filtrar elementos de acuerdo a una condición.

En Java 5 se introdujo la sintaxis de foreach, la cual se utiliza para iterar sobre colecciones de elementos. Por ejemplo, para iterar una colección de cadenas que representan nombres, podemos escribir for(String name: names){}. En segundo plano, él foreach se convierte, a nivel de código de bytes, para utilizar un Iterator, mientras que el iterator nos dice que hay un elemento, busca el siguiente elemento para procesarlo. En otras palabras, él foreach es una sintaxis concisa y agradable para la iteración con un bucle while sobre los elementos proporcionados por un Iterator. Podemos convertir un foreach a un estilo funcional con bastante facilidad.

Estilo imperativo a funcional

Consideremos el siguiente ejemplo donde se itera una colección de nombres usando un foreach.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

for (String name : names) {
    System.out.println(name);
}

En cada paso de la iteración, la variable name se vincula a un nuevo valor, a medida que la iteración avanza de un elemento al siguiente en la colección. La conversión del estilo imperativo foreach al estilo funcional es un uso directo del método iterador interno del forEach. Se denomina iterador interno porque el avance al siguiente elemento se maneja internamente y de forma automática en lugar de que se haga de forma externa o explícitamente.

Refactorizamos el bucle anterior a un estilo funcional.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.forEach(name -> System.out.println(name));

Podemos modificar el código anterior para que sea aún más conciso usando una referencia de método.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.forEach(System.out::println);

Es bastante sencillo, el bucle foreach se convirtió en una llamada al método forEach() de la colección. En cada paso de la iteración, la lambda proporcionada al método como argumento se invoca con el siguiente elemento de la colección.

A continuación, veremos una ligera variación de este ejemplo, usando stream() y forEach().

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.stream().forEach(name -> System.out.println(name));

El método forEach() está disponible tanto en Collection<T> como en Stream<T>. Los métodos como filter(), que usaremos a continuación, están disponibles solo en Stream<T> y no en Collection<T>. Esto se realiza de esta manera por diseño para brindar eficiencia cuando múltiples operaciones intermedias pueden preceder a la operación terminal como forEach(), findFirst(), collect(), etc.

Filtrar elementos con if

Supongamos que, en medio de la iteración, queremos filtrar o elegir algunos valores de la colección en función de alguna condición. Por ejemplo, ¿Qué pasa si queremos imprimir solo los nombres cuya longitud sea igual a 4? Con un estilo imperativo, podríamos hacerlo de la siguiente manera.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

for(String name: names) {
    if(name.length() == 4) {
        System.out.println(name);
    }
}

Usando un estilo funcional, el método filter() de Stream es el reemplazo directo a un condicional if. Este método permite filtrar elementos de la secuencia de acuerdo con una condición dada. La condición se proporciona como una lambda que toma un elemento y devuelve un valor booleano. Si el predicado se evalúa como true para un elemento, se incluye en la secuencia resultante; de lo contrario, se excluye.

List<String> names = Arrays.asList("John", "Jane", "Robert", "Rachel");

names.stream()
        .filter(name -> name.length() == 4)
        .forEach(name -> System.out.println(name));

El método filter() actúa como una compuerta, se abre para dejar pasar algunos elementos y se cierra para rechazar o descartar algunos otros a medida que avanza la iteración sobre la colección.

En cualquier lugar que nos encontremos un bucle foreach, podemos usar el método forEach() directamente sobre la colección. Si el cuerpo del bucle tiene un condicional para filtrar elementos, podemos usar el método filter() de Stream para lograr el mismo efecto.

Bucle for a IntStream con iterate en Java

Jordi Ayala — Mon, 28 Apr 2025 13:00:00 +0000

En el post anterior analizamos la conversión de un simple bucle for a un IntStream, pasando de un estilo imperativo a uno funcional. Ahora veremos cómo abordar bucles que son un poco más complejos, específicamente aquellos cuando tenemos que pasar por encima de algunos valores en un rango.

Al iterar sobre un rango de valores uno a la vez, el método range de IntStream resulta útil para implementarlo. Este método devuelve un flujo que generará un valor a la vez para el rango de valores especificado. A primera vista, para omitir algunos valores, podemos pensar en utilizar el método filter() en el flujo (Stream). Sin embargo, existe una solución más simple, el método iterate() de IntStream.

Del estilo imperativo al funcional

Consideremos el siguiente bucle que nos permite saltar algunos valores en un rango:

for(int i = 0; i < 15; i += 3) {
    System.out.println(i);
}

El valor de la variable i que actúa como índice comienza en 0 y se incrementa de 3 en 3 a medida que la iteración avanza. Cuando tenemos un bucle similar a este, donde la iteración no es sobre cada valor de un rango, sino que se saltan algunos valores, podemos considerar el método iterate() de IntStream para implementarlo.

Antes de refactorizar el código, veamos más de cerca el bucle for y la posible lógica para implementar el mismo comportamiento utilizando lambdas.

for(int i = 0; i < 15; i = i + 3) // imperativo
for(seed, i -> i < 15, i -> i + 3) // funcional

El primer argumento que se pasa al bucle for es el valor inicial o seed para la iteración y puede permanecer como esta. El segundo argumento es un predicado que indica que el valor de la variable i, no debe superar el valor de 15. Esto lo podemos reemplazar a un estilo funcional con un IntPredicate. El tercer argumento incrementa el valor de la variable i o índice y eso, en el estilo funcional, es simplemente un IntUnaryOperator. IntStream tiene el método estático iterate() que representa la definición anterior: iterate(int seed, IntPredicate hasNext, IntUnaryOperator next).

Refactoricemos el bucle for a un IntStream utilizando el método iterate().

IntStream.iterate(0, i -> i < 15, i -> i + 3)
        .forEach(System.out::println);

De esta forma, los ; se convierten en ,, usamos dos lambdas, una para el predicado y otra para el operador de incremento.

Iteración sin límites con break

Además de iterar por un rango de valores, a menudo podemos utilizar un bucle sin límites, lo que genera un poco más de complejidad. Consideremos el siguiente bucle con un estilo imperativo, que no tiene límites respecto hasta donde iterar, y utiliza un condicional if para salir del bucle con break.

for (int i = 0;; i+= 3) {
    if (i > 20) break;
    System.out.println(i);
}

Ahora no hay condición de terminación en la declaración del bucle, por lo que no tiene límites, tal y como indican los ;; en la declaración. Sin embargo, dentro del bucle tenemos un break para salir del bucle en caso de que el valor de i sea mayor que 20.

En un estilo funcional, podemos omitir el segundo argumento del método iterate(), él IntPredicate específicamente, para convertir la iteración en un flujo infinito. El equivalente a un break es el método takeWhile(). Este método terminará el iterador interno del flujo, si el predicado de tipo IntPredicate se evalúa como false. Por lo tanto, podemos refactorizar el bucle for a un IntStream de la siguiente manera:

IntStream.iterate(0, i -> i + 3)
        .takeWhile(i -> i <= 20)
        .forEach(System.out::println);

El método iterate() tiene una sobrecarga, donde solo se pasa el valor inicial y el operador de incremento, es decir, una donde no se pasa él IntPredicate. Esta versión sin predicado se utiliza para crear un flujo infinito que genera valores a partir del valor inicial. El IntUnaryOperator que se pasa como segundo argumento determina cómo se incrementa el valor de seed. Por lo tanto, en el ejemplo anterior el flujo generará los valores 0, 3, 6, 9, 12, 15, .... Como queremos limitar la iteración para que el índice no supere el valor de 20 usando el método takeWhile(). El predicado que se le pasa al método takeWhile() indica si la iteración puede continuar siempre y cuando el valor actual sea menor o igual a 20.

En general, cuando tengamos un bucle for con un incremento en un rango de valores (distinto a 1), podemos usar el método iterate() con tres argumentos, en caso de que tenga una condición de terminación interna con un break, podemos usar iterate() con dos argumentos y takeWhile() para limitar la iteración.

Cómo refactorizar bucles for a IntStream en Java

Jordi Ayala — Mon, 21 Apr 2025 13:00:00 +0000

Introducción

Las versiones anteriores de Java admitían el paradigma orientado a objetos combinado con un estilo imperativo de programación. A partir de Java 8, se introdujo el estilo funcional de programación al código. Ambos estilos de programación tienen sus propias ventajas y desventajas, e incluso se pueden combinar dentro del mismo código.

El estilo imperativo es donde decimos qué hacer y también cómo hacerlo. Mientras que el estilo funcional es declarativo por naturaleza, donde decimos qué hacer y delegamos el cómo o los detalles de implementación a la API. El código con un estilo imperativo puede ser más fácil de escribir, ya que la mayoría de nosotros estamos muy familiarizados con él. Sin embargo, el código se vuelve verboso, complejo y en ocasiones difícil de leer y mantener. Por su parte el estilo funcional puede ser difícil al principio, principalmente porque no es tan extenso su uso y enseñanza, pero en general, es más fácil de leer, comprender y modificar. Con la práctica, el estilo funcional se vuelve más fácil de entender y escribir.

Este es el primer post de una serie, donde analizaremos una serie de ejemplos de código donde se usa un estilo imperativo, y lo refactorizaremos para usar un estilo funcional equivalente.

Simple for loop

Comencemos con el tradicional bucle for en el que realizamos una acción de acuerdo al valor de un índice en un rango determinado.

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

En este bucle, la esencia es el rango de valores de i que va de 0 a 4. Podemos clasificar como ruido a la propia sintaxis y a la operación de incremento de i. Para mantener la esencia o propósito del bucle y eliminar el ruido, podemos usar un estilo funcional con IntStream.

IntStream.range(0, 5)
        .forEach(i -> System.out.println(i));

El código anterior es la forma en la que podemos escribir el bucle for con bastante facilidad. La clave está en la sentencia "un índice sobre un rango". El método range de IntStream crea un rango de valores enteros donde el primer argumento es el valor inicial y el segundo argumento es el valor final. Considerar que el valor final no está incluido en el rango. El método forEach sirve para iterar sobre cada elemento del rango y realizar una acción, en este caso, imprimir el valor de i.

Podemos escribir este código de una manera más concisa, eliminando la variable i y usando el método forEach con una referencia de método.

IntStream.range(0, 5)
        .forEach(System.out::println);

De esta manera el estilo funcional se vuelve más conciso, más fácil de leer y la intención es más clara en esta versión.

En caso de que el bucle for se ejecute hasta incluir el valor final, tal y como se muestra a continuación:

for (int i = 0; i <= 5; i++) {
    System.out.println(i);
}

Podemos usar el método rangeClosed de IntStream para crear un rango de valores enteros que incluya el valor final.

IntStream.rangeClosed(0, 5)
        .forEach(System.out::println);

Tanto si se utiliza el método range como el método rangeClosed, se obtiene un flujo de valores int (IntStream) sobre los cuales podemos iterar usando el método forEach.

En los ejemplos anteriores donde se usa un estilo funcional, el iterador interno nos quita de encima la carga de la iteración. El propio flujo se encarga de recorrer el rango de valores, uno a la vez, y de esta manera solo tenemos que centrarnos en lo que se debe hacer con cada elemento, a medida que se va obteniendo dentro del método forEach. En los ejemplos anteriores solamente se imprime el valor proporcionado, pero se puede realizar cualquier operación, por ejemplo, guardar información en una base de datos, enviar información a un servicio web, etc.

A diferencia del iterador externo que nos proporciona el bucle for, el código que utiliza el iterador interno es más conciso, tiene menos ruido, evita la necesidad de mutar explícitamente la variable de índice, y es más fácil de leer y modificar.

En cualquier lugar que se encuentre un bucle for se puede utilizar el método range o rangeClosed de IntStream para iterar desde el valor inicial hasta el valor final, ya sea que el valor final esté incluido o no. De esta manera, se puede refactorizar el código de un estilo imperativo a un estilo funcional, asegurándose de verificar que el código funcione tal y como se espera, y que no haya efectos secundarios no deseados, en el mejor de los casos usando pruebas unitarias.

Pattern Matching con Records en Java

Jordi Ayala — Mon, 14 Apr 2025 13:00:00 +0000

Un record es un tipo especial de clase inmutable que se utiliza habitualmente como un DTO (Data Transfer Object) para almacenar datos y transferirlos entre diferentes partes de una aplicación. Si te interesa saber más sobre records y pattern matching en Java puedes consultar los siguientes enlaces:

Un record pattern es un tipo especial de patrón que fue introducido formalmente a partir de la versión 21 de Java. Un record se construye a partir de los componentes (fields) que se declaran en su definición. En el siguiente ejemplo, el record Point tiene dos componentes x e y:

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

Los componentes o atributos del record permiten aplicar un nuevo concepto dentro del pattern matching, la deconstrucción de un record o record deconstruction. Sabemos que al utilizar el pattern matching con instanceof en caso de que el objeto sea una instancia de lo que estamos comparando, podemos declarar una variable y asignarle el valor del objeto automáticamente. En el caso de los records, podemos hacer lo mismo.

Point o = new Point(0, 1);
if (o instanceof Point p) {
    System.out.println(p.x());
    System.out.println(p.y());
}

Podemos llevar este principio un paso más allá utilizando la deconstrucción del record en el mismo instanceof:

Point o = new Point(0, 1);
if (o instanceof Point(int x, int y)) {
    System.out.println(x);
    System.out.println(y);
}

El matched target o lo que se busca hacer coincidir sigue siendo la referencia a o. Lo que corresponde con un record pattern del tipo Point(int x, int y). En este caso se declaran dos variables o pattern variables: x e y respectivamente. Si o es una instancia de Point, entonces estas dos variables son creadas y se inicializan con los valores de x e y del propio record de forma automática.

Un patrón de record se construye utilizando el nombre del record, Point en este caso, y un patrón de tipo por cada atributo o componente que tenga el record. Por lo tanto, cuando se define o instanceof Point(int x, int y), int x e int y son patrones de tipo, que se utilizan para hacer coincidir el primer y segundo componente del record Point. Considerar que en este caso, se define un patrón de tipo utilizando tipos primitivos.

Nota. El nombre de las variables que se declaran en el patrón de tipo no tiene por qué coincidir con los nombres de los componentes del record. Lo único a considerar es que el tipo de la variable debe coincidir con el tipo del componente del record y el número de variables debe coincidir con el número de componentes del record, es decir, se sigue un orden respecto a los atributos y como están declarados en el record.

Un record pattern se construye utilizando el constructor canónico del record, es decir, el constructor que es generado automáticamente por el compilador. Incluso si se crean otros constructores distintos al canónico, el patrón del record siempre utilizará la sintaxis del constructor canónico. Por lo tanto, el siguiente código no compilará:

public record Point(int x, int y) {
    public Point(int x) {
        this(x, 0);
    }
}

Point o = new Point(0, 1);
// This doesn't compile
if (o instanceof Point(int x)) {}

Tal y como se mencionó anteriormente, el patrón de record se construye utilizando el constructor canónico del record. Por lo que es importante que al realizar la deconstrucción de un record, se utilicen las variables que se han declarado en el patrón de tipo.

Inferencia de tipos en record patterns

El patrón de record también admite la inferencia de tipos. El tipo de cada uno de los atributos o componentes que se utiliza al escribir el patrón se puede inferir usando var. Como el matching de cada atributo es en realidad un patrón de tipos, se puede hacer matching de un tipo que sea una extensión del tipo real del atributo, en caso contrario se obtendrá un error de compilación.

Point o = new Point(0, 1);
if (o instanceof Point(var x, var y)) {
    System.out.println(x);
    System.out.println(y);
}

En este caso, var x e var y son patrones de tipo que se utilizan para hacer coincidir el primer y segundo componente del record Point. La inferencia de tipos se realiza automáticamente, por lo que no es necesario especificar el tipo de las variables explícitamente.

Usar con switch expressions

Podemos utilizar la deconstrucción de un record en un switch expression. Consideremos el siguiente record Box con un único atributo o de tipo Object:

public record Box(Object o) { }

Box o = new Box("Hello");

switch (o) {
    case Box(String s) -> System.out.println("Length: " + s.length());
    case Box(Integer i) -> System.out.println("Value: " + i);
    default -> System.out.println("Box contains something else");
}

En este caso, el switch expression verifica que o sea del tipo Box, y posteriormente verifica si el atributo es de un tipo en particular. Si o es una instancia de Box, entonces se verifica si el atributo es de tipo String o Integer. En caso de que o sea una instancia de Box y el atributo sea de tipo String, se imprime la longitud de la cadena. Si el atributo es de tipo Integer, se imprime el valor del entero. En caso contrario, se imprime un mensaje indicando que el Box contiene algo distinto.

La comprobación de tipos también verifica que el tipo del atributo coincida con el tipo del patrón de tipo. Si el tipo del atributo no coincide con el tipo del patrón de tipo, se obtendrá un error de compilación. Consideremos el siguiente ejemplo:

public record Box(CharSequence o) { }

switch (o) {
    case Box(String s) -> System.out.println("Length: " + s.length());
    // Does not compile
    case Box(Integer i) -> System.out.println("Value: " + i);
    default -> System.out.println("Box contains something else");
}

Boxing y unboxing

Actualmente, los patrones de record no soportan boxing y unboxing. Por lo tanto, no se pueden utilizar tipos primitivos en los patrones de record cuando los atributos del record son de un tipo de referencia. Consideremos el siguiente ejemplo:

public record Point(Integer x, Integer y) { }

Point o = new Point(0, 1);
// Does not compile
if (o instanceof Point(int x, int y)) { }

Nota. Puede que en futuras versiones de Java se añada soporte para boxing y unboxing en los patrones de record, al menos en la versión 21 LTS no está soportado aún.

Nested record patterns

Los patrones de record soportan el anidamiento de patrones. Es decir, se pueden utilizar patrones de record dentro de otros patrones de record. La inferencia de tipos también se aplica a los patrones de record anidados. Consideremos los siguientes dos records Point y Circle:

public record Point(double x, double y) { }

public record Circle(Point center, double radius) { }

Circle o = new Circle(new Point(0, 0), 1);

if (o instanceof Circle(Point(var x, var y), var r)) {
    System.out.println("Circle with center at (" + x + ", " + y + ") and radius " + r);
}

Al momento de realizar la deconstrucción anidada de un record, se debe tener en cuenta que el orden de los patrones de tipo debe coincidir con el orden de los componentes (atributos) del record. En este caso, el patrón de record Circle(Point(var x, var y), var r) se utiliza para hacer coincidir:

El primer patrón de tipo Point(var x, var y), que es un record que a su vez tiene dos componentes x e y.
El segundo patrón de tipo var r, que se utiliza para hacer coincidir el segundo componente del record Circle de tipo double.

En caso de que no se necesite deconstruir un componente del record que a su vez sea un record, se puede utilizar un patrón de tipo que no deconstruya el record anidado. Consideremos el siguiente ejemplo:

Circle o = new Circle(new Point(0, 0), 1);

if (o instanceof Circle(Point p, var r)) {
    System.out.println("Circle with center at (" + p.x() + ", " + p.y() + ") and radius " + r);
}

Pasa lo mismo si se utiliza un switch expression con patrones de record anidados:

Circle o = new Circle(new Point(0, 0), 1);

switch (o) {
    case Circle(Point(var x, var y), var r) -> System.out.println("Circle");
    default -> System.out.println("Unknown");
}

Unnamed variables

En los patrones de record, se pueden utilizar variables sin nombre o unnamed variables para ignorar los valores de los componentes del record que no se utilizarán posteriormente. Las variables sin nombre se representan con un guion bajo _. Considerar que esta característica está disponible a partir de la versión 22 de Java. Tomemos como ejemplo los records Point y Circle:

Circle o = new Circle(new Point(0, 0), 1);

if (o instanceof Circle(Point(var _, var _), var r)) {
    System.out.println("Circle with radius " + r);
}

O incluso podemos evitar el uso de var _ y colocar directamente _:

Circle o = new Circle(new Point(0, 0), 1);

if (o instanceof Circle(Point(_, _), var r)) {
    System.out.println("Circle with radius " + r);
}

En este caso, el patrón de record Circle(Point(_, _), var r) se utiliza para hacer coincidir el record Circle y se ignoran los valores de los componentes x e y del record Point. Por lo que, no se declaran variables para estos componentes y tampoco es posible acceder a ellos posteriormente.

Ejemplo

Ahora que ya hemos visto como funciona el pattern matching con records y algunas características que podemos utilizar a la par, como la deconstrucción de un record, la inferencia de tipos, el uso de unnamed variables y el anidamiento de patrones de record, vamos a ver un ejemplo completo que englobe todas estas características. Consideremos la siguiente estructura de records que implementan la interfaz Figura:

public interface Figura { }

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

public record Cuadrado(double lado) implements Figura { }

public record Triangulo(double base, double altura) implements Figura { }

Consideremos el siguiente método calcularArea que calcula el área de una figura f que implementa la interfaz Figura. En principio se verifica si f es una instancia de Rectangulo, Cuadrado o Triangulo y se calcula el área correspondiente usando instanceof.

public static double calcularArea(Figura f) {
    if (f instanceof Rectangulo r) {
        return r.ancho * r.alto;
    } else if (f instanceof Cuadrado c) {
        return c.lado * c.lado;
    } else if (f instanceof Triangulo t) {
        return t.base * t.altura / 2;
    } else {
        throw new IllegalArgumentException("Figura desconocida");
    }
}

Mejoremos el método calcularArea usando la deconstrucción de un record, y de esta forma evitar acceder a cada uno de los atributos desde el objeto como tal.

public static double calcularArea(Figura f) {
    if (f instanceof Rectangulo(double ancho, double alto)) {
        return ancho * alto;
    } else if (f instanceof Cuadrado(double lado)) {
        return lado * lado;
    } else if (f instanceof Triangulo(double base, double altura)) {
        return base * altura / 2;
    } else {
        throw new IllegalArgumentException("Figura desconocida");
    }
}

En lugar de declarar el tipo específico de cada atributo del record, podemos utilizar la inferencia de tipos para simplificar el código.

public static double calcularArea(Figura f) {
    if (f instanceof Rectangulo(var ancho, var alto)) {
        return ancho * alto;
    } else if (f instanceof Cuadrado(var lado)) {
        return lado * lado;
    } else if (f instanceof Triangulo(var base, var altura)) {
        return base * altura / 2;
    } else {
        throw new IllegalArgumentException("Figura desconocida");
    }
}

Ahora podemos mejorar aún más el método calcularArea utilizando un switch expression en lugar de un if-else y retornar el área de la figura correspondiente directamente, considerando que este debe ser exhaustivo respecto a los tipos.

public static double calcularArea(Figura f) {
    return switch (f) {
        case Rectangulo(var ancho, var alto) -> ancho * alto;
        case Cuadrado(var lado) -> lado * lado;
        case Triangulo(var base, var altura) -> base * altura / 2;
        default -> throw new IllegalArgumentException("Figura desconocida");
    };
}

Como una nota adicional, podemos evitar declarar un caso por default si utilizamos un sealed interface para la interfaz Figura, de este modo se garantizan implícitamente todos los subtipos posibles de Figura.

public sealed interface Figura { }

public sealed interface Figura permits Rectangulo, Cuadrado, Triangulo { }

Agreguemos dos nuevos records que implementan la interfaz Figura:

public record Circulo(Punto p, double radio) implements Figura { }

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

Ahora podemos modificar el método calcularArea para que soporte el cálculo del área de un círculo, además de la deconstrucción de un record anidado y el uso de unnamed variables, ya que no necesitamos acceder a las coordenadas del punto para calcular el área del círculo.

public static double calcularArea(Figura f) {
    return switch (f) {
        case Rectangulo(var ancho, var alto) -> ancho * alto;
        case Cuadrado(var lado) -> lado * lado;
        case Triangulo(var base, var altura) -> base * altura / 2;
        case Circulo(Punto(_, _), var radio) -> Math.PI * radio * radio;
        default -> throw new IllegalArgumentException("Figura no soportada");
    };
}

Conclusión

El pattern matching con records es una característica muy interesante y poderosa que se ha introducido en versiones recientes, y no solo permite mejorar la forma en que se escribe y estructura el código, sino que también permite un nuevo enfoque de programación orientada a datos dentro de Java en conjunto con características más modernas como los records, sealed classes, y el propio pattern matching.

Pattern Matching en Java

Jordi Ayala — Mon, 07 Apr 2025 13:00:00 +0000

Introducción

Si el tema de pattern matching te resulta nuevo, puede que lo relaciones con el uso de expresiones regulares. Las expresiones regulares son una forma de pattern matching que se utiliza para analizar cadenas de texto, por lo que es un buen punto de partida para entender el pattern matching en Java. Consideremos el siguiente código:

public static void main(String[] args) {
    String str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. " +
            "Nullam ex ligula, imperdiet semper tortor dictum, condimentum pulvinar eros. " +
            "In sed ligula sed tellus vehicula accumsan eget vel mauris. " +
            "Nam ut purus vel sem fermentum dictum ut sodales nulla. " +
            "Aenean et pretium massa. " +
            "Donec ultricies scelerisque massa. " +
            "Vivamus id bibendum eros, ut ullamcorper dolor.";

    Pattern pattern = Pattern.compile("\\btellus\\b");
    Matcher matcher = pattern.matcher(str);

    while (matcher.find()) {
        String group = matcher.group();
        int start = matcher.start();
        int end = matcher.end();
        System.out.println("Se ha encontrado la palabra " + group + " en la posición " + start + " y acaba en la posición " + end);
    }
}

Tenemos la cadena de texto str que es analizada con la expresión regular \\btellus\\b. Esta expresión comienza y termina con \b. Este carácter tiene un significado especial dentro de las expresiones regulares, ya que indica el inicio o el final de una palabra. Para este caso en particular, estamos buscando la palabra tellus en la cadena de texto. Si ejecutamos el código, obtendremos la siguiente salida:

Se ha encontrado la palabra tellus en la posición 152 y acaba en la posición 158

Este resultado nos indica que hay una única ocurrencia de la palabra tellus en la cadena de texto, y que esta comienza en la posición 152 y acaba en la posición 158. El pattern matching en las expresiones regulares funciona de la siguiente manera:

Coincide con un patrón dado; en este caso, la palabra tellus.
Después de encontrar el patrón, se puede obtener información adicional sobre la coincidencia, como la posición de inicio y fin de la coincidencia.

Hay tres conceptos que se deben tener en cuenta a lo largo de este post, y que son fundamentales en el pattern matching:

Lo que se necesita hacer coincidir; esto se llama matched target. En el ejemplo anterior, es la cadena de texto str.
Con qué se hace la comparación; esto se llama pattern. En el ejemplo anterior, es la expresión regular \\btellus\\b.
El resultado de la comparación; esto se llama match result. En el ejemplo anterior, es el índice de inicio y fin de la coincidencia.

¿Qué es el pattern matching?

El pattern matching en Java es una característica que simplifica y mejora la legibilidad del código al realizar verificaciones de tipos y desestructuraciones en objetos. Se introdujo gradualmente a partir de la versión 16.

El pattern matching permite escribir código más conciso al combinar:

Verificación de tipos (instanceof).
Asignación de una variable con un tipo específico si la verificación de tipo es exitosa.

instanceof

El operador instanceof se utiliza para verificar si un objeto es una instancia de una clase, interfaz o subclase. Si la verificación es exitosa, se puede hacer un casting del objeto a la clase o interfaz correspondiente. Consideremos las siguientes clases, donde Animal es la clase base y, Perro y Gato son subclases de Animal:

static class Animal {
    void hacerSonido() {
        System.out.println("Hace un sonido");
    }
}

static class Perro extends Animal {
    void hacerSonido() {
        System.out.println("Ladra");
    }
}

static class Gato extends Animal {
    void hacerSonido() {
        System.out.println("Maulla");
    }
}

Ahora podemos crear un método que reciba un objeto del tipo Object y verifique si es una instancia de Perro o Gato:

public static void comprobar(Object o) {
    if (o instanceof Perro) {
        System.out.println("Es un perro");
    } else if (o instanceof Gato) {
        System.out.println("Es un gato");
    } else {
        System.out.println("Es un animal");
    }
}

Para comprobar el funcionamiento del método y el operador instanceof, podemos hacer lo siguiente:

Perro perro = new Perro();
comprobar(perro);

Obtenemos como salida Es un perro. Ahora podemos utilizar esta implementación para realizar un casting del objeto a la clase correspondiente y llamar al método hacerSonido:

public static void comprobar(Object o) {
    if (o instanceof Perro) {
        Perro perro = (Perro) o;
        perro.hacerSonido();
    } else if (o instanceof Gato) {
        Gato gato = (Gato) o;
        gato.hacerSonido();
    } else {
        System.out.println("Es un animal");
    }
}

Esto funciona tal y como se espera, pero que pasaría si agregamos una comprobación al principio del método para verificar si el objeto es una instancia de Animal:

public static void comprobar(Object o) {
    if (o instanceof Animal) {
        System.out.println("Es un animal");
    } else if (o instanceof Perro) {
        Perro perro = (Perro) o;
        perro.hacerSonido();
    } else if (o instanceof Gato) {
        Gato gato = (Gato) o;
        gato.hacerSonido();
    } else {
        System.out.println("No es un animal");
    }
}

En este caso a pesar de que sabemos que el objeto es una instancia de Perro, la comprobación de Animal se ejecuta primero, y, por lo tanto, la salida será Es un animal. Tiene sentido, ya que Perro es una subclase de Animal. Por lo que si queremos realizar este tipo de comprobaciones, debemos considerar los casos más específicos primero, y los más generales al final.

public static void comprobar(Object o) {
    if (o instanceof Perro) {
        Perro perro = (Perro) o;
        perro.hacerSonido();
    } else if (o instanceof Gato) {
        Gato gato = (Gato) o;
        gato.hacerSonido();
    } else if (o instanceof Animal) {
        System.out.println("Es un animal");
    } else {
        System.out.println("No es un animal");
    }
}

Pattern Matching para instanceof

Hay varias maneras de extender el pattern matching, la primera se denomina Pattern matching for instanceof. Esta característica permite combinar la verificación de tipos y la asignación de una variable con un tipo específico si la verificación de tipo es exitosa. Consideremos el siguiente ejemplo:

public static void print(Object o) {
    if (o instanceof String s) System.out.println("This is a String of length " + s.length());
    else System.out.println("This is not a String");
}

Comencemos describiendo los tres elementos clave del pattern matching:

Matched target: Es cualquier objeto de cualquier tipo. Es el operador de la izquierda de instanceof, en este caso o.
Pattern: Es un tipo seguido de la variable que se asignará si la verificación de tipo es exitosa. Es el operador a la derecha de instanceof, en este caso String s. El tipo puede ser una clase, clase abstracta o una interfaz.
Match result: El resultado de la coincidencia es una nueva referencia al objeto que se asigna a la variable s. Este solamente se crea si el matched target coincide con el pattern. La variable tiene el tipo correspondiente al pattern, en este caso String. La variable s se puede llamar pattern variable del pattern. Algunos patrones pueden tener más de una variable.

En el ejemplo anterior, la variable o es el elemento que se necesita hacer coincidir, el matched target. El pattern es la declaración String, y el resultado de la coincidencia es la variable s. Si el objeto o es una instancia de String, la variable s se asigna con el objeto o. Si el objeto o no es una instancia de String, la variable s no se crea y el bloque else se ejecuta.

El patrón String s se llama type pattern, porque verifica el tipo del matched target. Dado que String implementa la interfaz CharSequence, podemos utilizar el patrón CharSequence s en lugar de String s:

public static void print(Object o) {
    if (o instanceof CharSequence s) System.out.println("This is a CharSequence of length " + s.length());
    else System.out.println("This is not a CharSequence");
}

public static void main(String[] args) {
    print("Hello"); // This is a String of length 5
    print(5); // This is not a String
    print('c'); // This is not a String
}

Usar la variable del patrón (pattern variable)

Podemos utilizar la variable s en cualquier parte que tenga sentido. El propio bloque if es el primer lugar donde se puede utilizar esta variable. El siguiente método verifica si el objeto es una instancia de String y, posteriormente si no es una cadena vacía. Vemos que la variable s se utiliza en la expresión booleana justo después del operador &&, esto tiene sentido porque la expresión booleana es evaluada solamente si la primera parte es true, es decir, si el objeto es una instancia de String se crea la variable s y se evalúa la expresión booleana.

public void print(Object o) {
    if (o instanceof String s && !s.isEmpty()) {
        int length = s.length();
        System.out.println("This object is a non-empty string of length " + length);
    } else {
        System.out.println("This object is not a string.");
    }
}

Hay casos en los que el código comprueba el tipo real de una variable, y si no es el tipo esperado, se salta el resto del código. Por ejemplo:

public void print(Object o) {
    if (!(o instanceof String)) {
        return;
    }
    String s = (String)o;
    // do something with s
}

Podemos escribir este código de otra forma aprovechando el pattern matching para instanceof:

public void print(Object o) {
    if (!(o instanceof String s)) {
        return;
    }

    System.out.println("This is a String of length " + s.length());
}

La variable s esta disponible fuera del bloque if siempre y cuando el objeto o sea una instancia de String. Si el objeto o no es una instancia de String, la variable s no se crea y el bloque return se ejecuta.

En ocasiones el propio compilador nos indica que el código fallará al utilizar el pattern matching para instanceof. Por ejemplo, el siguiente código no compila:

Double pi = Math.PI;
if (pi instanceof String s) {
    // this will never be true!
}

El compilador sabe que la clase String es del tipo final, por lo que no hay manera de que pi sea una instancia de String.

Código más limpio con Pattern Matching for instanceof

Hay muchos lugares donde el uso del pattern matching para instanceof puede hacer que el código sea más limpio y legible. Por ejemplo, tenemos la clase Point que tiene dos atributos x e y, y el método equals() que compara dos objetos de tipo Point:

public class Point {
    private int x;
    private int y;

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Point)) {
            return false;
        }
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }
}

Esta es una manera clásica de escribir el método equals(), incluso puede ser generada por el propio IDE. Podemos reescribir este método utilizando el pattern matching para instanceof, lo que hace que el código sea más limpio y legible:

public boolean equals(Object o) {
    return o instanceof Point point &&
            x == point.x &&
            y == point.y;
}

Pattern Matching para switch

El pattern matching se puede utilizar con switch statements o switch expressions. Esto nos permite hacer coincidir un matched target con varios patrones a la vez. Hasta ahora los patrones (patterns) son patrones de tipo, al igual que en el pattern matching para instanceof. Para este caso el matched target es el valor que se evalúa en él switch. Existen varios patrones en este escenario, cada caso del switch es por sí mismo un patrón que sigue la sintaxis descrita en la sección anterior. Consideremos el siguiente código:

Object o = 21;
String formatted = null;
if (o instanceof Integer i) {
    formatted = String.format("int %d", i);
} else if (o instanceof Long l) {
    formatted = String.format("long %d", l);
} else if (o instanceof Double d) {
    formatted = String.format("double %f", d);
} else {
    formatted = String.format("Object %s", o.toString());
}

Podemos ver que contiene tres tipos de patrones (type patterns), uno por cada if. El pattern matching con switch nos permite simplificar este código:

Object o = 21;
String formatter = switch(o) {
    case Integer i -> String.format("int %d", i);
    case Long l -> String.format("long %d", l);
    case Double d -> String.format("double %f", d);
    default -> String.format("Object %s", o.toString());
};

El pattern matching con switch no solo hace que el código sea más legible, sino que también lo hace más eficiente. La evaluación de una declaración if-else es proporcional a la cantidad de casos o ramificaciones que tiene, duplicar la cantidad de ramificaciones duplicaría el tiempo de evaluación. La evaluación de un switch no depende de la cantidad de casos. De esta forma podemos decir que, la complejidad de la declaración if es O(n), mientras que la complejidad de un switch es O(1).

Que un switch acepte el pattern matching por sí mismo no es una extensión propia del pattern matching, sino una nueva característica del switch, que acepta un patrón como caso.

Los casos deben ser exhaustivos en caso de utilizar un switch expression, es decir, deben cubrir todos los posibles valores del matched target, o simplemente agregar un caso default.

Guarded Patterns

En el caso del pattern matching for instanceof sabemos que la variable del patrón solo se crea si el objeto coincide con el patrón y puede ser utilizada en una expresión booleana inmediatamente después del operador &&.

Object object = "Hello";
if (object instanceof String s && !s.isEmpty()) {
    int length = s.length();
    System.out.println("This object is a non-empty string of length " + length);
}

Esto funciona bien en una sentencia if, porque el argumento de la sentencia es de tipo booleano. En una expresión switch, no podemos hacer esto, por lo tanto, no podemos escribir lo siguiente:

Object object = "Hello";
String formatter = switch(o) {
    // This doesn't work
    case String s && !s.isEmpty() -> String.format("Non-empty string %s", s);
        case Object o -> String.format("Object %s", o.toString());
};

El pattern matching para switch se ha ampliado para permitir que se agregue una expresión booleana después del patrón de tipo. Esta expresión se denomina guard. Un guarded pattern es un patrón seguido de una expresión booleana, que se evalúa si el objeto coincide con el patrón. Para esto se utiliza la cláusula when seguida de la expresión booleana. Consideremos el siguiente ejemplo:

public static void main(String[] args) {
    Object o = "Hello";
    String formatter = switch(o) {
        case String s when !s.isEmpty() -> String.format("Non-empty string %s", s);
        default -> String.format("Object %s", o.toString());
    };

    System.out.println(formatter); // Non-empty string Hello
}

Esta etiqueta de caso extendida se denomina guarded case label. La expresión String s when !s.isEmpty() es un tipo de esta etiqueta, que está formada por un patrón de tipo y una expresión booleana.

Conclusiones

El pattern matching es una característica muy interesante que actualmente se puede utilizar usando la palabra clave instanceof, switch expressions y extended for loop. Soporta dos tipos de patrones, patrones de tipo (type patterns) y patrones de registro (record patterns). Con respecto al pattern matching aplicado a records, es un tema que se trata en el siguiente post. El pattern matching aún tiene características que se están desarrollando y que se espera que estén disponibles en futuras versiones de Java.

Clases anidadas en Java

Jordi Ayala — Mon, 31 Mar 2025 15:08:29 +0000

En Java podemos definir una clase dentro de otra clase, a este tipo de clases se les denomina clases anidadas o nested classes. Las clases anidadas se utilizan para agrupar clases que tienen una relación lógica entre sí, de tal forma que se facilite la lectura y mantenimiento del código.

class OuterClass {
    // Cuerpo de la clase
    class InnerClass {
        // Cuerpo de la clase interna
    }
}

Las clases anidadas se dividen en dos categorías: no estáticas y estáticas.

Las clases anidadas no estáticas (non-static nested classes) también se conocen como inner classes.
Las clases anidadas que se declaran como estáticas se conocen como static nested classes.

class OuterClass {
    // Cuerpo de la clase
    class InnerClass {
        // Cuerpo de la clase interna
    }

    static class StaticNestedClass {
        // Cuerpo de la clase anidada estática
    }
}

Una clase anidada es un miembro de la clase que la contiene. Las inner class tiene acceso a otros miembros de la clase que las contiene, incluso si están declarados como private. Por otra parte, las clases anidadas estáticas no tiene acceso a otros miembros de la clase que las contiene. Como miembros de la clase OuterClass, las clases anidadas pueden ser declaradas como private, public, protected o default, considerando que la OuterClass solo puede ser declarada como public o default, no tiene sentido declararla como private o protected.

¿Por qué usar nested classes?

Entre las razones para utilizar este tipo de clases se encuentran las siguientes:

Es una forma de agrupar lógicamente las clases que solo se utilizan es un lugar. Si una clase es útil para otra clase, entonces es lógico que estén anidadas en esa clase y mantenerlas juntas. De esta forma, anidar estas helper classes hace que el paquete sea más limpio y fácil de entender.
Aumenta la encapsulación: Consideremos dos clases de nivel superior, A y B, en las que B necesita acceder a miembros de A que, de otro modo, se declararían privados. Al ocultar la clase B dentro de la clase A, los miembros de A pueden declararse privados y B puede acceder a ellos. Además, la propia clase B puede ocultarse del mundo exterior usando private como nivel de acceso.
Permiten tener un código más legible y fácil de mantener. Anidar clases pequeñas dentro de clases má grandes sitúa el código má cerca de donde se utiliza, considerando que todo dependerá de la lógica de negocio que se esté implementando.

Inner classes

Al igual que ocurren con los métodos y atributos de instancia, una inner class está asociada a una instancia de la clase que la contiene, por lo que, tiene acceso directo a los métodos y atributos de ese objeto. Además, al estar asociada a una instancia, no puede definir ningún miembro estático por sí misma.

Los objetos que son instancias de una inner class existen dentro de una instancia de la clase que la contiene. Por ejemplo, consideremos las siguientes clases:

public class OuterClass {
    class InnerClass {

    }
}

Una instancia de InnerClass solo puede existir dentro de una instancia de OuterClass y tiene acceso directo a los métodos y atributos de su instancia adjunta. Para crear una instancia de InnerClass, primero debemos crear una instancia de OuterClass y, a continuación, generar una instancia de InnerClass utilizando la instancia de OuterClass.

OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();

Existen dos tipos adicionales de inner classes. Podemos declarar una inner class dentro del cuerpo de un método, este tipo se denomina local classes. También se puede declarar una inner class dentro del cuerpo de un método sin darle un nombre a la clase, este tipo se denomina anonymous classes.

Se pueden utilizar los mismos modificadores para las inner classes que para cualquier otro miembro de la clase externa. Por ejemplo, se puede declarar una inner class como private, public, protected o default (package-private).

La serialización de inner classes, incluidas clases locales y anónimas, es problemática y no es aconsejable.

Inner Class Ejemplo

Imaginemos que tenemos un sistema de facturación. La clase principal Invoice representa una factura, y la inner class TaxCalculator se encarga de calcular impuestos para los productos de la factura.

public class Invoice {

    private String customerName;
    private double subtotal;

    public Invoice(String customerName, double subtotal) {
        this.customerName = customerName;
        this.subtotal = subtotal;
    }

    public double calculateTotal() {
        TaxCalculator taxCalculator = new TaxCalculator();
        double tax = taxCalculator.calculateTax(subtotal);
        return subtotal + tax;
    }

    public void printInvoice() {
        System.out.println("Customer: " + customerName);
        System.out.println("Subtotal: $" + subtotal);
        System.out.println("Total (including tax): $" + calculateTotal());
    }

    private class TaxCalculator {
        private static final double TAX_RATE = 0.16;

        public double calculateTax(double amount) {
            return amount * TAX_RATE;
        }
    }

    public static void main(String[] args) {
        Invoice invoice = new Invoice("Alice Johnson", 100.0);
        invoice.printInvoice();
    }
}

Analicemos el código anterior a detalle.

Clase principal Invoice:
- Representa una factura con los atributos customerName y subtotal.
- Contiene métodos públicos para calcular el total (calculateTotal) e imprimir la factura (printInvoice).
Inner Class TaxCalculator:
- Se declara como private, ya que solo es útil dentro del contexto de la clase que la contiene Invoice.
- Tiene una constante estática TAX_RATE y un método para calcular el impuesto (calculateTax).
Método main:
- Crea una instancia de Invoice.
- Llamanos al método printInvoice, que a su vez llama al método calculateTotal de la inner class TaxCalculator.

Al ejecutar el código obtenemos la siguiente salida.

Customer: Alice Johnson
Subtotal: $100.0
Total (including tax): $116.0

Static nested classes

Al igual que los métodos y atributos de clases, una clase estática anidada está asociada a su clase externa. Y al igual que los métodos estáticos de una clase, no puede referirse directamente a variables de instancia o métodos definidos en la clase que la contiene, solo puede utilizarlos a través de una referencia a un objeto.

Una clase estática anidada interactúa con los miembros de instancia de su clase externa como cualquier otra clase de nivel superior. En efecto, una clase estática anidada es conductualmente una clase de nivel superior que ha sido anidada en otra clase de nivel superior por conveniencia.

public class OuterClass {
    static class StaticNestedClass {

    }
}

Una clase estática anidada se puede instanciar de la misma manera que una clase de nivel superior, sin necesidad de una instancia de la clase que la contiene.

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

import dev.asjordi.OuterClass.StaticNestedClass;

public class Main {
    public static void main(String[] args) {
        StaticNestedClass nestedObject = new StaticNestedClass();
    }
}

Inner Class y Nested Static Class Ejemplo

El siguiente ejemplo, OuterClass, junto con Main, demuestra a qué miembros de clase de OuterClass pueden acceder una clase interna (InnerClass), una clase estática anidada (StaticNestedClass) y una clase de nivel superior (Main):

public class OuterClass {

    String outerField = "Outer field";
    static String staticOuterField = "Static outer field";

    class InnerClass {
        void accessMembers() {
            System.out.println(outerField);
            System.out.println(staticOuterField);
        }
    }

    static class StaticNestedClass {
        void accessMembers(OuterClass outer) {
            // Non-static field 'outerField' cannot be referenced from a static context
            // System.out.println(outerField);
            System.out.println(outer.outerField);
            System.out.println(staticOuterField);
        }
    }

    public static void main(String[] args) {
        System.out.println("Inner class:");
        System.out.println("------------");
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.accessMembers();

        System.out.println("\nStatic nested class:");
        System.out.println("--------------------");
        StaticNestedClass staticNestedClass = new StaticNestedClass();
        staticNestedClass.accessMembers(outerClass);

        System.out.println("\nTop-level class:");
        System.out.println("--------------------");
        Main topLevelObject = new Main();
        topLevelObject.accessMembers(outerClass);
    }
}

public class Main {
    void accessMembers(OuterClass outer) {
        // Non-static field 'outerField' cannot be referenced from a static context
        // System.out.println(OuterClass.outerField);
        System.out.println(outer.outerField);
        System.out.println(OuterClass.staticOuterField);
    }
}

Inner class:
------------
Outer field
Static outer field

Static nested class:
--------------------
Outer field
Static outer field

Top-level class:
--------------------
Outer field
Static outer field

Se puede notar que la clase StaticNestedClass no puede acceder directamente a los miembros de instancia de OuterClass, pero puede acceder a los miembros estáticos de OuterClass. Para poder acceder a los miembros de instancia de OuterClass, se debe pasar una instancia de OuterClass como argumento al método accessMembers. Por otro lado, la clase InnerClass puede acceder a los miembros de instancia y estáticos de OuterClass.

Similarmente, la clase Main no puede acceder directamente a los miembros de instancia de OuterClass, pero puede acceder a los miembros estáticos de OuterClass.

Shadowing

Si una declaración de un tipo (como una variable o parámetro) en un determinado ámbito (como una inner class o un método) tiene el mismo nombre que otra declaración del ámbito que la rodea, la declaración oculta la declaración del ámbito que la rodea. De esta forma, no se puede hacer referencia a una declaración que está sombreada (shadowed declaration) solo por su nombre. Consideremos el siguiente ejemplo:

public class ShadowTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            System.out.println("x = " + x);
            System.out.println("this.x = " + this.x);
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
        }
    }

    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

x = 23
this.x = 1
ShadowTest.this.x = 0

En el ejemplo se definen tres variables con el nombre x: el atributo de la clase ShadowTest, el atributo de la clase FirstLevel y el parámetro del método methodInFirstLevel. La variable x definida como parámetro del método methodInFirstLevel() oculta la variable de la inner class FirstLevel. Por lo que, cuando se utiliza x dentro del método, esta se refiere al parámetro. Para hacer referencia al atributo de la inner class, se debe usar la palabra clave this, que representa el ámbito que la rodea.

Para hacer referencia a variables de un ámbito mayor, se puede realizar utilizando el nombre de la clase a la que pertenecen, seguido de un punto y el nombre de la variable.

Local classes

Las clases locales son clases que se definen en un bloque, que es un grupo de cero o más sentencias entre llaves {}. Normalmente, las clases locales se definen en el cuerpo de un método.

Declaración

Se puede definir una clase local dentro de cualquier bloque, por ejemplo, podemos definir una clase local en el cuerpo de un método.

public class LocalClassExample {

    static String regularExpression = "[^0-9]";

    public static void validatePhoneNumber(String phoneNumber1, String phoneNumber2) {

        final int numberLength = 10;

        class PhoneNumber {

            String formattedPhoneNumber = "";

            PhoneNumber(String phoneNumber){
                String currentNumber = phoneNumber.replaceAll(regularExpression, "");
                if (currentNumber.length() == numberLength) formattedPhoneNumber = currentNumber;
                else formattedPhoneNumber = "";
            }

            public String getNumber() {
                return formattedPhoneNumber;
            }
        }

        PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
        PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);

        if (myNumber1.getNumber().isEmpty()) System.out.println("First number is invalid");
        else System.out.println("First number is " + myNumber1.getNumber());
        if (myNumber2.getNumber().isEmpty())System.out.println("Second number is invalid");
        else System.out.println("Second number is " + myNumber2.getNumber());
    }

    public static void main(String... args) {
        validatePhoneNumber("123-456-7890", "456-7890");
    }
}

El ejemplo valida un número de teléfono eliminando primero todos los caracteres del número excepto los dígitos del 0 al 9. Después comprueba si contiene exactamente diez dígitos y, si es así, lo almacena. Si no, almacena una cadena vacía. La clase PhoneNumber es una clase local que se define en el método validatePhoneNumber. Al final se obtiene como resultado lo siguiente:

First number is 1234567890
Second number is invalid

Acceder a los miembros de la clase que la contiene

Una clase local tiene acceso a los miembros de la clase que la contiene. En el ejemplo anterior, el constructor PhoneNumber() accede al atributo LocalClassExample.regularExpression.

Además, una clase local tiene acceso a variables locales. Sin embargo, una clase local solo puede acceder a las variables locales del tipo final. Cuando una clase local accede a una variable local o parámetro del bloque que la encierra, captura esa variable o parámetro. Por ejemplo, el constructor PhoneNumber() puede acceder a la variable local numberLength porque está declarada como final.

Sin embargo, a partir de Java 8, una clase local puede acceder a variables locales y parámetros del bloque que la contienen que sean finales o efectivamente finales. Una variable o parámetro cuyo valor no se cambia nunca después de inicializarse es efectivamente final.

Por ejemplo, supongamos que la variable numberLength no está declarada como final, y dentro del constructor PhoneNumber() se le asigna otro valor, por ejemplo 7. Debido a esta sentencia de asignación, la variable numberLength ya no es efectivamente final. Como resultado, el compilador genera un mensaje de error similar a Variable 'numberLength' is accessed from within inner class, needs to be final or effectively final.

PhoneNumber(String phoneNumber) {
    numberLength = 7;
    String currentNumber = phoneNumber.replaceAll(
        regularExpression, "");
    if (currentNumber.length() == numberLength)
        formattedPhoneNumber = currentNumber;
    else
        formattedPhoneNumber = null;
}

A partir de Java 8, si se declara la clase local en un método, esta puede acceder a los parámetros del método. Por ejemplo, se puede definir el siguiente método en la clase local PhoneNumber:

public void printOriginalNumbers() {
    System.out.println("Original numbers are " + phoneNumber1 +" and " + phoneNumber2);
}

El método printOriginalNumbers() accede a los parámetros phoneNumber1 y phoneNumber2 del método validatePhoneNumber().

Las declaraciones de un tipo (por ejemplo, una variable) en una clase local ocultan cualquier declaración del tipo que se encuentre en el bloque que la contiene.

Una cosa interesante es que podemos declarar una interfaz dentro de un método, y a su vez declarar una clase local que la implemente.

public void greetInEnglish() {

    interface HelloThere {
        void greet(String name);
    }

    class EnglishHelloThere implements HelloThere {
        public void greet(String name) {
            System.out.println("Hello " + name);
        }
    }

    HelloThere myGreeting = new EnglishHelloThere();
    myGreeting.greet("John Doe");
}

Una clase local puede contener declaraciones de métodos estáticos.

public void sayGoodbyeInEnglish() {
    class EnglishGoodbye {
        public static void sayGoodbye() {
            System.out.println("Bye bye");
        }
    }
    EnglishGoodbye.sayGoodbye();
}

Una clase local puede tener miembros estáticos, ya sea del tipo final o no. Aunque en la mayoría de ocasiones tiene sentido que este tipo de miembros sean final.

public void sayGoodbyeInEnglish() {
    class EnglishGoodbye {
        public static final String farewell = "Bye bye";
        public void sayGoodbye() {
            System.out.println(farewell);
        }
    }
    EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();
    myEnglishGoodbye.sayGoodbye();
}

Clases anónimas

Una clase anónima es una clase que no tiene nombre, y que permite declarar o instanciar implementaciones de clases o interfaces al mismo tiempo sin la necesidad de utilizar un archivo adicional. Por lo que, este tipo de clases son de un solo uso y no se pueden reutilizar en otro lugar. Mientras que las clases locales son declaraciones de clase, las clases anónimas son expresiones, lo que significa que la clase se define en otra expresión, y esto produce como resultado un único objeto que se puede almacenar en una variable.

Para má información puedes consultar el siguiente post Clases anónimas en Java.

Conclusiones

En definitiva las clases anidadas y sus diferentes tipos representan una herramienta que nos permite estructurar y organizar el código de manera lógica y cohesiva, sin dejar de lado la encapsulación de funcionalidades que solo son relevantes dentro de un contexto específico. Además, facilitan el acceso a los miembros de la clase que las contiene, simplificando la interacción entre clases. Sin embargo, su uso debe ser considerado, ya que un diseño excesivamente anidado puedo complicar la mantenibilidad del código.

Switch Expression en Java

Jordi Ayala — Mon, 24 Mar 2025 13:00:00 +0000

La palabra clave switch representa una estructura de control de flujo que permite evaluar una expresión y ejecutar un bloque de código dependiendo del valor de la expresión. En ocasiones, puede ser una alternativa a una serie de instrucciones if-else anidadas, aunque también es el origen de muchos errores de programación si no se maneja correctamente.

A partir de la versión 14 de Java se introdujo una sintaxis más conveniente llamada switch expression, motivada por los siguientes aspectos:

La estructura switch por defecto es del tipo fall-through (caída), lo que significa que si no se incluye una instrucción break, la ejecución continúa con la siguiente instrucción, y es una causa común de errores.
El bloque switch es tratado como un bloque de código, lo cual puede ser un impedimento en la definición de variables.
La estructura switch es una sentencia, lo que significa que no puede ser utilizada en una expresión, ni asignar su valor a una variable, o retornar un valor.

Ambas sintaxis son válidas en Java, tanto la de switch statement (tradicional) como la de switch expression. Consideremos el siguiente ejemplo con la estructura tradicional, donde de acuerdo a la cadena de texto que representa un día de la semana, se determina la longitud de la cadena y se asigna a una variable:

String day = "MONDAY";
int length = 0;

switch (day) {
    case "MONDAY":
    case "FRIDAY":
    case "SUNDAY":
        length = 6;
        break;
    case "TUESDAY":
        length = 7;
        break;
    case "THURSDAY":
    case "SATURDAY":
        length = 8;
        break;
    case "WEDNESDAY":
        length = 9;
        break;
    default:
        length = -1;
        break;
}

System.out.println("Length of " + day + " is " + length);

Usando la estructura switch expression, el código anterior se simplifica de la siguiente manera:

String day = "MONDAY";
int length = 0;

switch (day) {
    case "MONDAY", "FRIDAY", "SUNDAY" -> length = 6;
    case "TUESDAY" -> length = 7;
    case "THURSDAY", "SATURDAY" -> length = 8;
    case "WEDNESDAY" -> length = 9;
    default -> length = 0;
};

System.out.println("Length of " + day + " is " + length);

Aprovechando la estructura de switch expression, se puede simplificar aún más el código, eliminando la necesidad de declarar la variable length antes del switch, y asignando el valor directamente a la variable en la expresión switch:

String day = "MONDAY";
int length = switch (day) {
    case "MONDAY", "FRIDAY", "SUNDAY" -> 6;
    case "TUESDAY" -> 7;
    case "THURSDAY", "SATURDAY" -> 8;
    case "WEDNESDAY" -> 9;
    default -> -1;
};

System.out.println("Length of " + day + " is " + length);

Con switch expression ahora se utiliza la sintaxis case VALUE -> EXPRESSION; en lugar de case VALUE: STATEMENTS; break;. De esta forma, solo el código que se encuentra después de la flecha -> es ejecutado en caso de que el valor coincida con lo que se está evaluando, y no es necesario incluir la instrucción break.

Para evaluar múltiples valores en un solo caso, basta con separarlos por comas, tal y como se muestra en el ejemplo anterior.

El código a la derecha de -> puede ser una sola expresión, un bloque o una sentencia throw, dado que es un bloque como tal, se pueden definir variables para el bloque en particular y no afectarán a las variables definidas fuera del switch.

Generar un valor

La sentencia switch al utilizarse como expresión, permite retornar un valor y asignarlo a una variable. Consideremos otro ejemplo para este caso.

int quarter = 0;

String quarterLabel = switch (quarter) {
    case 0 -> "Q1 - Winter";
    case 1 -> "Q2 - Spring";
    case 2 -> "Q3 - Summer";
    case 3 -> "Q3 - Summer";
    default -> "Unknown quarter";
};

En este caso, a la variable quarterLabel se le asigna el valor que retorna la expresión switch, que es una cadena de texto que representa el cuarto del año. En caso de que el valor de quarter no coincida con ninguno de los casos, se asigna el valor por defecto "Unknown quarter".

Si solamente existe una expresión o línea de código en el bloque, el valor producido por la expresión es retornado automáticamente, de lo contrario la sintaxis es un poco diferente y se necesita utilizar un bloque de código {}.

Tradicionalmente, se utiliza la palabra clave return para denotar el valor que se desea retornar en un bloque de código, pero al trabajar con switch expression se vuelve ambigua y genera un error de compilación. Consideremos el siguiente ejemplo para ilustrar este caso (no compila):

public String convertToLabel(int quarter) {
    String quarterLabel = switch (quarter) {
        case 0  -> {
            System.out.println("Q1 - Winter");
            return "Q1 - Winter";
        }
        default -> "Unknown quarter";
    };
    return quarterLabel;
}

El bloque de código para el caso 0 necesita retornar un valor, se realiza utiliza return, pero al observar el código podemos notar que existen dos declaraciones de retorno, una en el bloque de código y otra en el método. Aquí es donde radica la ambigüedad: uno puede preguntarse cuál es la semántica del primer retorno. ¿Significa que el programa sale del método con este valor? ¿O sale de la sentencia switch? Esto da lugar a un código poco legible y propenso a errores.

Para resolver este problema se ha creado una nueva sintaxis, la palabra clave yield, que se utiliza para retornar un valor en cualquier bloque de código de un switch. El ejemplo anterior se puede reescribir de la siguiente manera:

public String convertToLabel(int quarter) {
    String quarterLabel = switch (quarter) {
        case 0  -> {
            System.out.println("Q1 - Winter");
            yield "Q1 - Winter";
        }
        default -> "Unknown quarter";
    };
    return quarterLabel;
}

Default case

Los casos por defecto permiten que el código gestione los casos en los que el valor del switch no coincide con ninguno de los casos definidos. Los casos de un switch expression deben ser exhaustivos, es decir, deben cubrir todos los posibles valores de la expresión. Al usar un switch tradicional, el caso por defecto es opcional, por lo que, si la evaluación no coincide con ninguno de los casos, el switch no hará nada silenciosamente, esto es un escenario propenso a errores difíciles de depurar, algo que se puede evitar con un caso por defecto.

En la mayoría de los casos, la exhaustividad se puede conseguir con un caso por defecto en ambas sintaxis. Esta gestión es una característica del switch expression que resulta útil al utilizar estructuras más complejas. Consideremos el siguiente ejemplo:

String color = "red";

String colorType = switch (color) {
    case "red", "blue", "green" -> "Primary color";
    case "yellow", "cyan", "magenta" -> "Secondary color";
    default -> "Unknown color";
};

Usar switch expression con : (colon)

Un switch expression puede usar la sintaxis tradicional con case VALUE: en lugar de case VALUE -> EXPRESSION;, es decir, usar dos puntos en lugar de la flecha. Para este caso se aplica la semántica "fall through" (caída), por lo que es necesario devolver un valor en cada caso usando la palabra clave yield. Consideremos el siguiente ejemplo:

int quarter = 10;

String quarterLabel = switch (quarter) {
    case 0: yield "Q1 - Winter";
    case 1: yield "Q2 - Spring";
    case 2: yield "Q3 - Summer";
    case 3: yield "Q3 - Summer";
    default:
        System.out.println("Unknown quarter");
        yield "Unknown quarter";
};

Retornar el valor de un switch expression

Al igual que podemos asignar el valor que retorna un switch expression a una variable, podemos retornarlo directamente en un método. Consideremos el siguiente ejemplo:

public String convertToLabel(int quarter) {
    return switch (quarter) {
        case 0 -> "Q1 - Winter";
        case 1 -> "Q2 - Spring";
        case 2 -> "Q3 - Summer";
        case 3 -> "Q3 - Summer";
        default -> "Unknown quarter";
    };
}

Usar switch expression sin asignar a una variable

Para los casos donde no se necesita retornar, ni asignar un valor a una variable, se puede usar tanto la sintaxis tradicional como la de switch expression. Consideremos el siguiente ejemplo:

int quarter = 0;

switch (quarter) {
    case 0 -> System.out.println("Q1 - Winter");
    case 1 -> System.out.println("Q2 - Spring");
    case 2 -> System.out.println("Q3 - Summer");
    case 3 -> System.out.println("Q3 - Summer");
    default -> System.out.println("Unknown quarter");
}

En este caso, se evalúa el valor de quarter y se imprime en consola el cuarto del año correspondiente. Este también es un caso válido para usar un switch expression, independientemente de que su función principal pueda considerarse la de asignar un valor a una variable.

Manejar valores nulos

En Java, los valores nulos pueden ser una fuente de errores, por lo que es importante manejarlos adecuadamente. A partir de la versión 17 se introdujo la capacidad de manejar valores nulos dentro de un switch expression, aspecto que inicialmente generaba un NullPointerException al intentar evaluar un valor nulo. Consideremos el siguiente ejemplo:

String input = null;

String result = switch (input) {
    case "hola" -> "Saludaste en español";
    case "hello" -> "Saludaste en inglés";
    case null -> "No escribiste nada";
    default -> "No saludaste";
};

System.out.println(result); // No saludaste

El switch expression evalúa el valor de input, si el valor es null se ejecuta el caso null, pero en el caso de que no existan coincidencias y no se proporcione un caso para null, y el valor de input sea null, se lanzará un NullPointerException, independientemente de si se proporciona un caso por defecto o no. Para evitar este error, se puede utilizar un caso null explícito, como se muestra en el ejemplo anterior. Esta situación no es aplicable al trabajar con valores primitivos, ya que estos no pueden ser nulos.

Conclusiones

El switch expression es una nueva característica que permite simplificar y ampliar la funcionalidad de la estructura tradicional de switch, permitiendo asignar el valor que retorna a una variable, retornarlo directamente en un método, o simplemente imprimirlo en consola. La nueva sintaxis es más concisa y legible, y evita errores comunes como la falta de la instrucción break en los casos, o la ambigüedad en la gestión de valores de retorno.

Ambas sintaxis son válidas en Java, y la elección de una u otra dependerá de las necesidades del problema a resolver. En general, se recomienda utilizar switch expression en lugar de la estructura tradicional, además de que resulta particularmente útil al trabajar con pattern matching en Java.

Referencias de métodos en Java

Jordi Ayala — Mon, 17 Mar 2025 13:00:00 +0000

Una expresión lambda no es más que la implementación del único método abstracto (SAM) de una interfaz funcional, también se les conoce a estas como métodos o funciones anónimas, en general son eso, dado que, no tienen un nombre, se pueden utilizar en cualquier parte del código y guardarse en un campo o variable, así como pasarse como argumento de un método o constructor e incluso ser devueltas por un método como tal.

En ocasiones, el único propósito de una expresión lambda es invocar un método específico en alguna parte del código, por ejemplo, un Consumer<String> que solo imprime por consola el valor que recibe.

Consumer<String> printer = s ->  System.out.println(s);

Escrito de esta manera, la expresión lambda solo es una referencia al método println(), en este tipo de casos, es donde las referencias de métodos toman sentido.

Una referencia de método permite simplificar el uso de expresiones lambda al referirse directamente a un método existente en lugar de escribir explícitamente la lógica, de esta forma, el código anterior puede escribirse de la siguiente manera.

Consumer<String> printer = System.out::println;

Existen 4 formas en Java de utilizar las referencias de métodos:

Referencia a un método estático
Referencia a un método de instancia de un objeto específico
Referencia a un método de instancia de un objeto arbitrario de un tipo específico
Referencia a un constructor

El ejemplo anterior equivale a una referencia a un método de instancia de un objeto arbitrario de un tipo específico. Es probable que el propio IDE nos recomiende utilizar una referencia de método en una expresión lambda de manera automática.

Referencia a un método estático

Se utiliza para referirse a métodos estáticos de una clase y su sintaxís es Clase::metodoEstatico. Por ejemplo, el método parseInt de la clase Integer nos permite convertir una cadena en un entero, recibe un parámetro y retorna un valor entero, considerando esto, podemos escribir una expresión lambda del tipo Function<String, Integer> para envolver este comportamiento.

Function<String, Integer> parseInt = s -> Integer.parseInt(s);

Podemos ver que esta expresión incluye lógica de más, y no deja de ser una referencia directa al método parseInt, por lo que, puede escribirse como una referencia de método.

Function<String, Integer> parseInt = Integer::parseInt;

Una referencia a un método estático puede tomar más de un argumento, por ejemplo, al utilizar el método max() de la clase Math.

IntBinaryOperator max = (a, b) -> Math.max(a, b);

La expresión lambda nuevamente hace referencia a un método estático, por lo que se puede escribir de la siguiente manera usando una referencia de método.

IntBinaryOperator max = Math::max;

Referencia a un método de instancia de un objeto específico

Se usa cuando se tiene una instancia específica de un objeto y se quiere llamar a uno de sus métodos, su sintaxis es objeto::metodoDeInstancia. Supongamos que tenemos la siguiente cadena de caracteres.

String cadena = "hola mundo";

Sí queremos usar un método propio del objeto, por ejemplo, un Supplier<Integer> que nos devuelva la longitud de la cadena llamando al método length(), podemos escribir una expresión lambda de la siguiente manera.

Supplier<Integer> len = () -> cadena.length();

Nuevamente, solo se está haciendo referencia a un método que pertenece a la instancia del objeto, por lo que se puede simplificar de la siguiente manera.

Supplier<Integer> len = cadena::length;

En caso de que el método acepte parámetros, por ejemplo, contains(), solo es cuestión de definir la expresión adecuada, este método acepta un parámetro de tipo String y devuelve un valor booleano, por lo que podemos utilizar un Predicate<String>.

Predicate<String> contiene = (str) -> cadena.contains(str);

El método contains() es propio de la instancia cadena, por lo que podemos simplificar la expresión de la siguiente manera.

Predicate<String> contiene = cadena::contains;

Referencia a un método de instancia de un objeto arbitrario de un tipo particular

Se usa cuando no se tiene una instancia específica, pero se está trabajando con un tipo de clase y se quiere llamar a un método de instancia en objetos de ese tipo, su sintaxis es Clase::metodoDeInstancia.

Cuando utilizamos este tipo de referencias es necesario considerar que, como se está tomando la referencia a partir de la clase y no es algo estático, no existe una instancia como tal a la cúal le pertenezca, por lo que, es necesario pasar una instancia como parámetro extra, independientemente de los parámetros que requiera el método que se esté usando. Consideremos el método length() de la clase String.

Function<String, Integer> len = (str) -> str.length();
Function<String, Integer> lenString = String::length;

Ambas formas de escribir la expresión son equivalentes, ya que no se está llamando a un método estático o propio de una instancia, es necesario especificar el tipo al que pertenece, en este caso un String. Para utilizar la expresión solo es necesario pasar como parámetro una instancia de ese tipo.

Function<String, Integer> lenString = String::length;
String cadena = "hola mundo";
System.out.println(lenString.apply(cadena));
// 10

Pasa lo mismo en caso de que el método necesite parámetros, por ejemplo, repeat() que necesita un parámetro del tipo int que indica el número de veces que se repetirá la cadena que será devuelta, por lo que, la expresión necesitará 3 parámetros, uno para el tipo de la instancia, otro para el parámetro que recibe como tal el método, y por último para el tipo que devuelve.

BiFunction<String, Integer, String> repetir = (str, n) -> str.repeat(n);
BiFunction<String, Integer, String> repetirString = String::repeat;

Ahora podemos utilizar nuestra expresión para comprobar que efectivamente se repite la cadena.

BiFunction<String, Integer, String> repetirString = String::repeat;
String cadena = "Java";
System.out.println(repetirString.apply(cadena, 2));
// JavaJava

Referencia a un constructor

Se usa para crear objetos llamando a un constructor, su sintaxis es Clase::new. Dependiendo si el constructor recibe parámetros o no, se debe definir el tipo de expresión lambda que se utilizará. Por ejemplo, si se tiene un Supplier<Random> que devuelve una instancia de Random se puede escribir de la siguiente manera.

Supplier<Random> newRandom = () -> new Random();

De nuevo, lo único que realiza la expresión es invocar a otro método, en este caso un constructor sin parámetros, por lo que podemos usar una referencia de método.

Supplier<Random> newRandom = Random::new;

En caso de que el constructor acepte parámetros, solo es necesario modificar el tipo de expresión lambda considerando los parámetros que recibe y el tipo que devuelve.

Function<Long, Random> newRandom = Random::new;

Ejemplos

A manera de ejemplo, vamos a considerar algunos casos donde se utilicen las referencias de métodos en combinación con otras características de Java. Para lo cúal vamos a considerar el siguiente record del tipo Person que contiene dos atributos, name y lastName.

record Person(String name, String lastName) {}

Si tenemos un List<Person> y queremos obtener una lista que contenga solo el name de cada uno de los objetos, podemos usar una referencia de método de instancia de un objeto arbitrario de un tipo particular dentro de un Stream usando map, donde cada elemento será la instancia de la cúal se obtendrá el atributo, para posteriormente almacenarlo en una nueva lista.

public class Main {

    record Person(String name, String lastName) {}

    public static void main(String[] args) {
        List<Person> persons = Arrays.asList(
                new Person("John", "Doe"),
                new Person("Jane", "Doe"),
                new Person("Bob", "Lee")
        );

        var names = persons.stream()
                .map(Person::name)
                .collect(Collectors.toList());

        System.out.println(names);
        // Output: [John, Jane, Bob]
    }
}

Si queremos una expresión lambda que nos devuelva una instancia del record Person, considerando que necesitamos pasar dos parámetros, podemos realizarlo de la siguiente manera usando una referencia a un constructor.

import java.util.function.BiFunction;

public class Main {

    record Person(String name, String lastName) {}

    public static void main(String[] args) {
        BiFunction<String, String, Person> personFactory = Person::new;
        var person = personFactory.apply("John", "Doe");
        System.out.println(person);
        // Output: Person[name=John, lastName=Doe]
    }
}

En caso de que necesitemos obtener el atributo name de un objeto específico en mayúsculas podemos usar una referencia a un método de instancia de un objeto específico.

import java.util.function.Supplier;

public class Main {

    record Person(String name, String lastName) {}

    public static void main(String[] args) {
        var john = new Person("John", "Doe");
        Supplier<String> toUpperCase = john.name::toUpperCase;
        System.out.println(toUpperCase.get());
        // Output: JOHN
    }
}

Supongamos que tenemos un método estático que nos permite obtener las iniciales de un objeto Person de la forma X.Y, donde X representa la primera letra del atributo name y Y del atributo lastName respectivamente, podemos utilizar una referencia a un método estático para lograrlo.

import java.util.function.Function;

public class Main {

    record Person(String name, String lastName) {}

    public static String getInitials(Person person) {
        return person.name().charAt(0) + "." + person.lastName().charAt(0) + ".";
    }

    public static void main(String[] args) {
        var john = new Person("John", "Doe");
        Function<Person, String> initials = Main::getInitials;

        System.out.println(initials.apply(john));
        // Output: J.D.
    }
}

Conclusiones

Las referencias de métodos son una forma de simplificar el uso de expresiones lambda al referirse directamente a un método existente en lugar de escribir explícitamente la lógica, resultando en un código más limpio y fácil de leer. Considerando que existen 4 formas de utilizarlas de acuerdo al tipo de operación a realizar, y su completa integración con la API Stream de Java, se convierten en una herramienta poderosa para trabajar con colecciones de datos.

Si quieres saber más al respecto, puedes consultar los posts existentes en el blog respecto a expresiones lambda y Streams en el siguiente enlace.