Java

Tutorial Java: Filtrado y búsqueda

Aprende a usar filter(), findFirst(), findAny(), anyMatch(), allMatch() y noneMatch() en Java Streams para filtrar y buscar datos eficientemente.

Aprende Java y certifícate

filter()

El método filter() es una de las operaciones intermedias más utilizadas en la API de Streams de Java. Esta operación permite seleccionar elementos de un stream que cumplan con una determinada condición, creando un nuevo stream que contiene únicamente los elementos que satisfacen dicho criterio.

La operación filter recibe como parámetro un Predicate, que es una función que evalúa cada elemento y devuelve un valor booleano. Solo los elementos para los que el predicado devuelve true pasarán al stream resultante.

Sintaxis básica

Stream<T> filter(Predicate<? super T> predicate)

El método filter devuelve un nuevo stream con los elementos que cumplen la condición especificada, manteniendo el orden de los elementos originales.

Ejemplos prácticos

Filtrado de números

Uno de los casos más comunes es filtrar números según ciertas condiciones matemáticas:

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

public class FiltradoNumeros {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Filtrar números pares
        List<Integer> pares = numeros.stream()
                                     .filter(n -> n % 2 == 0)
                                     .collect(Collectors.toList());
        
        System.out.println("Números pares: " + pares);
        
        // Filtrar números mayores que 5
        List<Integer> mayoresQueCinco = numeros.stream()
                                              .filter(n -> n > 5)
                                              .collect(Collectors.toList());
        
        System.out.println("Números mayores que 5: " + mayoresQueCinco);
    }
}

En este ejemplo, primero filtramos los números pares utilizando el predicado n -> n % 2 == 0, y luego filtramos los números mayores que 5 con el predicado n -> n > 5.

Filtrado de cadenas

El filtrado también es muy útil para trabajar con colecciones de cadenas:

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

public class FiltradoCadenas {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("Ana", "Juan", "Pedro", "María", "José", "Lucía");
        
        // Filtrar nombres que empiezan con 'J'
        List<String> nombresConJ = nombres.stream()
                                         .filter(nombre -> nombre.startsWith("J"))
                                         .collect(Collectors.toList());
        
        System.out.println("Nombres que empiezan con J: " + nombresConJ);
        
        // Filtrar nombres con longitud mayor a 4 caracteres
        List<String> nombresLargos = nombres.stream()
                                          .filter(nombre -> nombre.length() > 4)
                                          .collect(Collectors.toList());
        
        System.out.println("Nombres con más de 4 caracteres: " + nombresLargos);
    }
}

Aquí filtramos nombres que comienzan con la letra 'J' y nombres que tienen más de 4 caracteres.

Filtrado de objetos complejos

El verdadero poder de filter() se aprecia cuando trabajamos con colecciones de objetos complejos:

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

class Producto {
    private String nombre;
    private double precio;
    private String categoria;
    
    public Producto(String nombre, double precio, String categoria) {
        this.nombre = nombre;
        this.precio = precio;
        this.categoria = categoria;
    }
    
    public String getNombre() { return nombre; }
    public double getPrecio() { return precio; }
    public String getCategoria() { return categoria; }
    
    @Override
    public String toString() {
        return nombre + " (" + precio + "€)";
    }
}

public class FiltradoProductos {
    public static void main(String[] args) {
        List<Producto> productos = Arrays.asList(
            new Producto("Laptop", 999.99, "Electrónica"),
            new Producto("Smartphone", 699.99, "Electrónica"),
            new Producto("Libro", 19.99, "Libros"),
            new Producto("Auriculares", 89.99, "Electrónica"),
            new Producto("Camiseta", 24.99, "Ropa")
        );
        
        // Filtrar productos de electrónica
        List<Producto> electronicos = productos.stream()
                                             .filter(p -> p.getCategoria().equals("Electrónica"))
                                             .collect(Collectors.toList());
        
        System.out.println("Productos electrónicos: " + electronicos);
        
        // Filtrar productos con precio menor a 100€
        List<Producto> productosEconomicos = productos.stream()
                                                    .filter(p -> p.getPrecio() < 100)
                                                    .collect(Collectors.toList());
        
        System.out.println("Productos económicos: " + productosEconomicos);
    }
}

En este ejemplo, filtramos productos por categoría y por precio, demostrando cómo filter() puede trabajar con propiedades de objetos complejos.

Encadenamiento de filtros

Una característica poderosa de las operaciones de Stream es que podemos encadenar múltiples operaciones filter():

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

public class FiltrosEncadenados {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 18, 20);
        
        // Filtrar números que son pares Y mayores que 5 Y menores que 15
        List<Integer> resultado = numeros.stream()
                                        .filter(n -> n % 2 == 0)      // Pares
                                        .filter(n -> n > 5)           // Mayores que 5
                                        .filter(n -> n < 15)          // Menores que 15
                                        .collect(Collectors.toList());
        
        System.out.println("Números pares entre 5 y 15: " + resultado);
    }
}

Cada operación filter() crea un nuevo stream, lo que permite encadenar múltiples condiciones de filtrado de manera clara y legible.

Uso de métodos referenciados con filter()

También podemos utilizar referencias a métodos con filter() para hacer el código más conciso:

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class FiltradoConReferencias {
    
    // Método estático que actúa como predicado
    public static boolean esPrimo(int numero) {
        if (numero <= 1) return false;
        if (numero <= 3) return true;
        if (numero % 2 == 0 || numero % 3 == 0) return false;
        
        for (int i = 5; i * i <= numero; i += 6) {
            if (numero % i == 0 || numero % (i + 2) == 0) return false;
        }
        return true;
    }
    
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
        
        // Usando referencia a método
        List<Integer> primos = numeros.stream()
                                     .filter(FiltradoConReferencias::esPrimo)
                                     .collect(Collectors.toList());
        
        System.out.println("Números primos: " + primos);
        
        // Predicado como variable
        Predicate<String> empiezaConA = s -> s.startsWith("A");
        
        List<String> nombres = Arrays.asList("Ana", "Juan", "Alberto", "María", "Antonio");
        List<String> nombresConA = nombres.stream()
                                         .filter(empiezaConA)
                                         .collect(Collectors.toList());
        
        System.out.println("Nombres que empiezan con A: " + nombresConA);
    }
}

En este ejemplo, utilizamos una referencia al método esPrimo y también definimos un predicado como variable para mayor reutilización.

Rendimiento y consideraciones

El método filter() es una operación perezosa (lazy), lo que significa que no se ejecuta hasta que se encuentra una operación terminal como collect(), forEach() o count(). Esto permite optimizaciones internas y evita procesamiento innecesario.

Cuando trabajamos con grandes volúmenes de datos, es recomendable colocar las operaciones filter() que eliminen más elementos al principio de la cadena, para reducir la cantidad de elementos que procesan las operaciones posteriores.

// Más eficiente (si la mayoría no son pares)
stream.filter(n -> n % 2 == 0)      // Elimina aproximadamente la mitad
      .filter(n -> n > 1000)        // Procesa solo los pares
      .forEach(System.out::println);

// Menos eficiente
stream.filter(n -> n > 1000)        // Procesa todos los elementos
      .filter(n -> n % 2 == 0)      // Procesa solo los mayores que 1000
      .forEach(System.out::println);

El método filter() es una herramienta fundamental para trabajar con streams en Java, permitiendo seleccionar subconjuntos de elementos de manera declarativa y expresiva, lo que resulta en código más limpio y mantenible.

findFirst() y findAny()

Después de filtrar elementos en un Stream, a menudo necesitamos recuperar un único elemento que cumpla con nuestros criterios en lugar de toda la colección. Para esto, Java Stream API proporciona los métodos findFirst() y findAny(), que nos permiten obtener elementos individuales de manera eficiente.

Ambos métodos son operaciones terminales que devuelven un objeto Optional<T>, el cual puede contener un valor o estar vacío si ningún elemento cumple con las condiciones establecidas.

Método findFirst()

El método findFirst() devuelve un Optional que contiene el primer elemento del Stream que cumple con las condiciones previas (si existen operaciones como filter() en la cadena). Su firma es:

Optional<T> findFirst()

Este método es especialmente útil cuando necesitamos obtener exactamente el primer elemento que cumpla con ciertos criterios:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class EjemploFindFirst {
    public static void main(String[] args) {
        List<String> frutas = Arrays.asList("manzana", "plátano", "naranja", "mandarina", "pera");
        
        // Encontrar la primera fruta que empiece con 'm'
        Optional<String> primeraFrutaConM = frutas.stream()
                                                 .filter(f -> f.startsWith("m"))
                                                 .findFirst();
        
        primeraFrutaConM.ifPresent(fruta -> System.out.println("Primera fruta con 'm': " + fruta));
    }
}

En este ejemplo, findFirst() devuelve "manzana" porque es el primer elemento que comienza con la letra 'm'.

Método findAny()

El método findAny() devuelve un Optional que contiene cualquier elemento del Stream que cumpla con las condiciones previas. Su firma es:

Optional<T> findAny()

A diferencia de findFirst(), este método no garantiza qué elemento específico será devuelto si hay varios que cumplen con los criterios:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class EjemploFindAny {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(4, 9, 16, 25, 36, 49, 64, 81, 100);
        
        // Encontrar cualquier número par
        Optional<Integer> cualquierPar = numeros.stream()
                                              .filter(n -> n % 2 == 0)
                                              .findAny();
        
        cualquierPar.ifPresent(n -> System.out.println("Número par encontrado: " + n));
    }
}

En este caso, findAny() podría devolver 4, 16, 36, 64 o 100, ya que todos son pares. La elección específica puede variar entre ejecuciones.

Diferencias clave y cuándo usar cada uno

La principal diferencia entre estos métodos radica en su comportamiento y rendimiento:

  • findFirst(): Garantiza devolver el primer elemento según el orden del Stream. Es determinista.
  • findAny(): No garantiza qué elemento específico devolverá. Es no determinista.

Esta diferencia es especialmente relevante en Streams paralelos:

import java.util.Arrays;
import java.util.Optional;

public class FindParalelo {
    public static void main(String[] args) {
        int[] numeros = new int[1000];
        for (int i = 0; i < numeros.length; i++) {
            numeros[i] = i;
        }
        
        // Stream paralelo con findFirst()
        Optional<Integer> primerDivisiblePor50 = Arrays.stream(numeros)
                                                     .parallel()
                                                     .filter(n -> n % 50 == 0 && n > 0)
                                                     .boxed()
                                                     .findFirst();
        
        // Stream paralelo con findAny()
        Optional<Integer> cualquierDivisiblePor50 = Arrays.stream(numeros)
                                                        .parallel()
                                                        .filter(n -> n % 50 == 0 && n > 0)
                                                        .boxed()
                                                        .findAny();
        
        System.out.println("Primer divisible por 50: " + primerDivisiblePor50.orElse(-1));
        System.out.println("Cualquier divisible por 50: " + cualquierDivisiblePor50.orElse(-1));
    }
}

En este ejemplo con Streams paralelos:

  • findFirst() siempre devolverá 50 (el primer número divisible por 50).
  • findAny() podría devolver cualquier número divisible por 50 (50, 100, 150, etc.).

Uso con Optional

Ambos métodos devuelven un Optional, lo que nos permite manejar elegantemente los casos donde no se encuentra ningún elemento:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class FindConOptional {
    public static void main(String[] args) {
        List<String> lenguajes = Arrays.asList("Java", "Python", "JavaScript", "C#", "Go");
        
        // Buscar un lenguaje que empiece con 'R'
        Optional<String> lenguajeR = lenguajes.stream()
                                            .filter(l -> l.startsWith("R"))
                                            .findFirst();
        
        // Diferentes formas de manejar el Optional
        
        // 1. Usando ifPresent
        lenguajeR.ifPresent(l -> System.out.println("Lenguaje encontrado: " + l));
        
        // 2. Usando orElse para proporcionar un valor por defecto
        String resultado = lenguajeR.orElse("No se encontró ningún lenguaje con R");
        System.out.println(resultado);
        
        // 3. Lanzando una excepción si no hay valor
        try {
            String lenguajeObligatorio = lenguajeR.orElseThrow(() -> 
                new IllegalStateException("Debe existir un lenguaje que empiece con R"));
        } catch (IllegalStateException e) {
            System.out.println("Excepción: " + e.getMessage());
        }
    }
}

Casos de uso prácticos

Validación de datos

Podemos usar estos métodos para verificar rápidamente si existe al menos un elemento que cumpla cierta condición:

import java.util.List;
import java.util.Optional;

public class ValidacionDatos {
    public static boolean existeUsuarioAdmin(List<Usuario> usuarios) {
        return usuarios.stream()
                      .filter(Usuario::esAdministrador)
                      .findAny()
                      .isPresent();
    }
    
    // Clase de ejemplo
    static class Usuario {
        private String nombre;
        private String rol;
        
        public Usuario(String nombre, String rol) {
            this.nombre = nombre;
            this.rol = rol;
        }
        
        public boolean esAdministrador() {
            return "ADMIN".equals(rol);
        }
    }
}

Búsqueda eficiente

Cuando solo necesitamos un elemento que cumpla ciertos criterios, estos métodos son más eficientes que recolectar todos los elementos filtrados:

import java.util.List;
import java.util.Optional;

public class BusquedaEficiente {
    public static Optional<Producto> buscarProductoPorCodigo(List<Producto> inventario, String codigo) {
        return inventario.stream()
                        .filter(p -> p.getCodigo().equals(codigo))
                        .findFirst();
    }
    
    // Clase de ejemplo
    static class Producto {
        private String codigo;
        private String nombre;
        
        public Producto(String codigo, String nombre) {
            this.codigo = codigo;
            this.nombre = nombre;
        }
        
        public String getCodigo() {
            return codigo;
        }
        
        public String getNombre() {
            return nombre;
        }
    }
}

Combinación con otras operaciones de Stream

Estos métodos son especialmente útiles cuando se combinan con otras operaciones como filter(), map() o sorted():

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

public class CombinacionOperaciones {
    public static void main(String[] args) {
        List<Empleado> empleados = Arrays.asList(
            new Empleado("Ana", "Desarrollo", 45000),
            new Empleado("Carlos", "Marketing", 38000),
            new Empleado("Beatriz", "Desarrollo", 52000),
            new Empleado("David", "Ventas", 48000),
            new Empleado("Elena", "Desarrollo", 60000)
        );
        
        // Encontrar el empleado de desarrollo con mayor salario
        Optional<Empleado> topDesarrollador = empleados.stream()
                                                     .filter(e -> "Desarrollo".equals(e.getDepartamento()))
                                                     .sorted(Comparator.comparing(Empleado::getSalario).reversed())
                                                     .findFirst();
        
        topDesarrollador.ifPresent(e -> 
            System.out.println("Top desarrollador: " + e.getNombre() + " - " + e.getSalario() + "€"));
    }
    
    // Clase de ejemplo
    static class Empleado {
        private String nombre;
        private String departamento;
        private double salario;
        
        public Empleado(String nombre, String departamento, double salario) {
            this.nombre = nombre;
            this.departamento = departamento;
            this.salario = salario;
        }
        
        public String getNombre() { return nombre; }
        public String getDepartamento() { return departamento; }
        public double getSalario() { return salario; }
    }
}

En este ejemplo, combinamos filter(), sorted() y findFirst() para encontrar al empleado de desarrollo con el salario más alto.

Consideraciones de rendimiento

  • findAny() puede tener mejor rendimiento en Streams paralelos, ya que no necesita coordinar entre hilos para determinar cuál es el "primer" elemento.
  • findFirst() requiere más coordinación en Streams paralelos para garantizar que se devuelva el primer elemento según el orden del Stream.
// Cuando el orden no importa y se usa paralelismo, findAny() es más eficiente
Optional<Integer> resultado = numeros.parallelStream()
                                   .filter(n -> n > 1000 && esPrimo(n))
                                   .findAny();

Los métodos findFirst() y findAny() son herramientas esenciales en la programación funcional con Java, permitiéndonos obtener elementos individuales de manera eficiente y expresiva, especialmente cuando solo necesitamos un elemento que cumpla con nuestros criterios en lugar de toda la colección.

anyMatch(), allMatch(), noneMatch()

Los métodos anyMatch(), allMatch() y noneMatch() son operaciones terminales de la API Stream de Java que permiten verificar condiciones sobre los elementos de un stream. Estos métodos evalúan si los elementos cumplen con un determinado predicado y devuelven un resultado booleano, lo que los hace ideales para validaciones y comprobaciones rápidas.

A diferencia de filter() que selecciona elementos, o findFirst()/findAny() que recuperan elementos individuales, estos métodos de coincidencia están diseñados para responder preguntas del tipo "¿existe algún elemento que...?", "¿todos los elementos cumplen...?" o "¿ningún elemento cumple...?".

Método anyMatch()

El método anyMatch() verifica si al menos un elemento del stream cumple con el predicado especificado. Su firma es:

boolean anyMatch(Predicate<? super T> predicate)

Este método devuelve:

  • true si encuentra al menos un elemento que cumple la condición
  • false si ningún elemento cumple la condición o el stream está vacío
import java.util.Arrays;
import java.util.List;

public class EjemploAnyMatch {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(2, 4, 6, 8, 9, 10);
        
        // Verificar si hay algún número impar
        boolean hayImpar = numeros.stream()
                                 .anyMatch(n -> n % 2 != 0);
        
        System.out.println("¿Hay algún número impar? " + hayImpar);
        
        // Verificar si hay algún número mayor que 10
        boolean hayMayorQue10 = numeros.stream()
                                      .anyMatch(n -> n > 10);
        
        System.out.println("¿Hay algún número mayor que 10? " + hayMayorQue10);
    }
}

En este ejemplo, anyMatch() devuelve true para la primera condición porque el número 9 es impar, y false para la segunda porque ningún número es mayor que 10.

Método allMatch()

El método allMatch() verifica si todos los elementos del stream cumplen con el predicado especificado. Su firma es:

boolean allMatch(Predicate<? super T> predicate)

Este método devuelve:

  • true si todos los elementos cumplen la condición o el stream está vacío
  • false si al menos un elemento no cumple la condición
import java.util.Arrays;
import java.util.List;

public class EjemploAllMatch {
    public static void main(String[] args) {
        List<String> palabras = Arrays.asList("Java", "JavaScript", "Kotlin", "Python");
        
        // Verificar si todas las palabras tienen al menos 4 letras
        boolean todasLargas = palabras.stream()
                                     .allMatch(p -> p.length() >= 4);
        
        System.out.println("¿Todas las palabras tienen al menos 4 letras? " + todasLargas);
        
        // Verificar si todas las palabras contienen la letra 'a'
        boolean todasContienenA = palabras.stream()
                                         .allMatch(p -> p.toLowerCase().contains("a"));
        
        System.out.println("¿Todas las palabras contienen la letra 'a'? " + todasContienenA);
    }
}

En este ejemplo, allMatch() devuelve true para ambas condiciones porque todas las palabras tienen al menos 4 letras y todas contienen la letra 'a'.

Método noneMatch()

El método noneMatch() verifica si ningún elemento del stream cumple con el predicado especificado. Su firma es:

boolean noneMatch(Predicate<? super T> predicate)

Este método devuelve:

  • true si ningún elemento cumple la condición o el stream está vacío
  • false si al menos un elemento cumple la condición
import java.util.Arrays;
import java.util.List;

public class EjemploNoneMatch {
    public static void main(String[] args) {
        List<Integer> edades = Arrays.asList(25, 30, 45, 28, 32);
        
        // Verificar si ninguna edad es menor de edad
        boolean ningunMenor = edades.stream()
                                   .noneMatch(edad -> edad < 18);
        
        System.out.println("¿Ninguna persona es menor de edad? " + ningunMenor);
        
        // Verificar si ninguna edad es mayor de 50
        boolean ningunMayorDe50 = edades.stream()
                                       .noneMatch(edad -> edad > 50);
        
        System.out.println("¿Ninguna persona es mayor de 50 años? " + ningunMayorDe50);
    }
}

En este ejemplo, noneMatch() devuelve true para ambas condiciones porque ninguna edad es menor de 18 años y ninguna es mayor de 50 años.

Comportamiento con streams vacíos

Es importante entender cómo se comportan estos métodos con streams vacíos:

  • anyMatch() devuelve false para un stream vacío (no hay elementos que cumplan la condición)
  • allMatch() devuelve true para un stream vacío (todos los elementos -que no hay- cumplen la condición)
  • noneMatch() devuelve true para un stream vacío (ningún elemento -que no hay- cumple la condición)
import java.util.ArrayList;
import java.util.List;

public class StreamVacio {
    public static void main(String[] args) {
        List<String> listaVacia = new ArrayList<>();
        
        boolean anyMatchVacio = listaVacia.stream().anyMatch(s -> s.isEmpty());
        boolean allMatchVacio = listaVacia.stream().allMatch(s -> s.isEmpty());
        boolean noneMatchVacio = listaVacia.stream().noneMatch(s -> s.isEmpty());
        
        System.out.println("anyMatch en stream vacío: " + anyMatchVacio);
        System.out.println("allMatch en stream vacío: " + allMatchVacio);
        System.out.println("noneMatch en stream vacío: " + noneMatchVacio);
    }
}

Casos de uso prácticos

Validación de datos

Estos métodos son ideales para validar conjuntos de datos:

import java.util.List;

public class ValidacionDatos {
    public static boolean esListaValida(List<Producto> productos) {
        // Verificar que todos los productos tengan precio positivo
        boolean preciosValidos = productos.stream()
                                         .allMatch(p -> p.getPrecio() > 0);
        
        // Verificar que ningún producto tenga nombre vacío
        boolean nombresValidos = productos.stream()
                                         .noneMatch(p -> p.getNombre() == null || p.getNombre().isEmpty());
        
        return preciosValidos && nombresValidos;
    }
    
    static class Producto {
        private String nombre;
        private double precio;
        
        public Producto(String nombre, double precio) {
            this.nombre = nombre;
            this.precio = precio;
        }
        
        public String getNombre() { return nombre; }
        public double getPrecio() { return precio; }
    }
}

Búsqueda eficiente

Estos métodos son más eficientes que filter().findAny() cuando solo necesitamos saber si existe algún elemento que cumpla una condición:

import java.util.List;

public class BusquedaEficiente {
    public static boolean existeProductoAgotado(List<Producto> inventario) {
        // Más eficiente que: inventario.stream().filter(p -> p.getStock() == 0).findAny().isPresent()
        return inventario.stream().anyMatch(p -> p.getStock() == 0);
    }
    
    static class Producto {
        private String nombre;
        private int stock;
        
        public Producto(String nombre, int stock) {
            this.nombre = nombre;
            this.stock = stock;
        }
        
        public int getStock() { return stock; }
    }
}

Verificación de reglas de negocio

Estos métodos son útiles para verificar si un conjunto de datos cumple con ciertas reglas de negocio:

import java.util.List;

public class ReglasNegocio {
    public static boolean esEquipoCompleto(List<Empleado> equipo) {
        // Verificar que el equipo tenga al menos un líder
        boolean tieneUnLider = equipo.stream()
                                    .anyMatch(Empleado::esLider);
        
        // Verificar que todos los miembros tengan las habilidades requeridas
        boolean todosCapacitados = equipo.stream()
                                        .allMatch(e -> e.tieneHabilidadesRequeridas());
        
        return tieneUnLider && todosCapacitados;
    }
    
    static class Empleado {
        private String nombre;
        private boolean lider;
        private List<String> habilidades;
        
        public boolean esLider() { return lider; }
        
        public boolean tieneHabilidadesRequeridas() {
            // Lógica para verificar habilidades
            return !habilidades.isEmpty();
        }
    }
}

Combinación con otras operaciones

Estos métodos se pueden combinar con otras operaciones de Stream para crear validaciones más complejas:

import java.util.Arrays;
import java.util.List;

public class CombinacionOperaciones {
    public static void main(String[] args) {
        List<Estudiante> estudiantes = Arrays.asList(
            new Estudiante("Ana", Arrays.asList(8.5, 9.0, 7.8, 8.2)),
            new Estudiante("Carlos", Arrays.asList(6.5, 7.0, 6.8, 7.2)),
            new Estudiante("Beatriz", Arrays.asList(9.5, 9.8, 9.3, 9.7))
        );
        
        // Verificar si todos los estudiantes tienen al menos una nota sobresaliente (>9)
        boolean todosConSobresaliente = estudiantes.stream()
                                                  .allMatch(e -> e.getNotas().stream()
                                                                .anyMatch(nota -> nota > 9));
        
        System.out.println("¿Todos tienen al menos una nota sobresaliente? " + todosConSobresaliente);
        
        // Verificar si algún estudiante tiene todas sus notas aprobadas (>=5)
        boolean algunoTodoAprobado = estudiantes.stream()
                                              .anyMatch(e -> e.getNotas().stream()
                                                            .allMatch(nota -> nota >= 5));
        
        System.out.println("¿Algún estudiante tiene todas las notas aprobadas? " + algunoTodoAprobado);
    }
    
    static class Estudiante {
        private String nombre;
        private List<Double> notas;
        
        public Estudiante(String nombre, List<Double> notas) {
            this.nombre = nombre;
            this.notas = notas;
        }
        
        public List<Double> getNotas() { return notas; }
    }
}

Cortocircuito y evaluación perezosa

Una característica importante de estos métodos es que implementan evaluación de cortocircuito:

  • anyMatch() deja de procesar elementos tan pronto como encuentra uno que cumple la condición
  • allMatch() deja de procesar elementos tan pronto como encuentra uno que no cumple la condición
  • noneMatch() deja de procesar elementos tan pronto como encuentra uno que cumple la condición

Esto los hace muy eficientes para trabajar con streams grandes o incluso infinitos:

import java.util.stream.Stream;

public class Cortocircuito {
    public static void main(String[] args) {
        // Stream infinito de números
        Stream<Integer> infiniteStream = Stream.iterate(1, n -> n + 1);
        
        // Verificar si hay algún número mayor que 100
        boolean hayMayorQue100 = infiniteStream
                                .peek(n -> System.out.println("Evaluando: " + n))
                                .anyMatch(n -> n > 100);
        
        System.out.println("¿Hay algún número mayor que 100? " + hayMayorQue100);
        // Solo evaluará los primeros 100 números gracias al cortocircuito
    }
}

Comparación entre los tres métodos

Para entender mejor las diferencias, podemos ver estos métodos como operadores lógicos aplicados a todos los elementos:

  • anyMatch(predicado) → ¿Existe al menos un elemento que cumpla el predicado? (operador OR)
  • allMatch(predicado) → ¿Todos los elementos cumplen el predicado? (operador AND)
  • noneMatch(predicado) → ¿Ningún elemento cumple el predicado? (operador NOT ANY)

De hecho, existe una relación lógica entre noneMatch() y anyMatch():

// Estas dos expresiones son equivalentes
boolean resultado1 = stream.noneMatch(predicado);
boolean resultado2 = !stream.anyMatch(predicado);

Los métodos anyMatch(), allMatch() y noneMatch() son herramientas fundamentales para realizar validaciones y comprobaciones sobre colecciones de datos en Java. Su naturaleza de cortocircuito los hace eficientes incluso con grandes volúmenes de datos, y su expresividad permite escribir código más claro y declarativo para verificar condiciones sobre conjuntos de elementos.

CONSTRUYE TU CARRERA EN IA Y PROGRAMACIÓN SOFTWARE

Accede a +1000 lecciones y cursos con certificado. Mejora tu portfolio con certificados de superación para tu CV.

30 % DE DESCUENTO

Plan mensual

19.00 /mes

13.30 € /mes

Precio normal mensual: 19 €
63 % DE DESCUENTO

Plan anual

10.00 /mes

7.00 € /mes

Ahorras 144 € al año
Precio normal anual: 120 €
Aprende Java online

Ejercicios de esta lección Filtrado y búsqueda

Evalúa tus conocimientos de esta lección Filtrado y búsqueda con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Streams: match

Test

Gestión de errores y excepciones

Código

CRUD en Java de modelo Customer sobre un ArrayList

Proyecto

Clases abstractas

Test

Listas

Código

Métodos de la clase String

Código

Streams: reduce()

Test

API java.nio 2

Puzzle

Polimorfismo

Código

Pattern Matching

Código

Streams: flatMap()

Test

Llamada y sobrecarga de funciones

Puzzle

Métodos referenciados

Test

Métodos de la clase String

Código

Representación de Fecha

Puzzle

Operadores lógicos

Test

Inferencia de tipos con var

Código

Tipos de datos

Código

Estructuras de iteración

Puzzle

Streams: forEach()

Test

Objetos

Puzzle

Funciones lambda

Test

Uso de Scanner

Puzzle

Tipos de variables

Puzzle

Streams: collect()

Puzzle

Operadores aritméticos

Puzzle

Arrays y matrices

Código

Clases y objetos

Código

Interfaz funcional Consumer

Test

CRUD en Java de modelo Customer sobre un HashMap

Proyecto

Interfaces

Código

Enumeraciones Enums

Código

API Optional

Test

Interfaz funcional Function

Test

Encapsulación

Test

Interfaces

Código

Uso de API Optional

Puzzle

Representación de Hora

Test

Herencia básica

Test

Clases y objetos

Código

Interfaz funcional Supplier

Puzzle

HashMap

Puzzle

Sobrecarga de métodos

Test

Polimorfismo de tiempo de ejecución

Puzzle

OOP en Java

Proyecto

Sobrecarga de métodos

Código

CRUD de productos en Java

Proyecto

Clases sealed

Código

Creación de Streams

Test

Records

Código

Encapsulación

Código

Streams: min max

Puzzle

Herencia

Código

Métodos avanzados de la clase String

Puzzle

Funciones

Código

Polimorfismo de tiempo de compilación

Test

Reto sintaxis Java

Proyecto

Conjuntos

Código

Estructuras de control

Código

Recursión

Código

Excepciones

Puzzle

Herencia avanzada

Puzzle

Estructuras de selección

Test

Uso de interfaces

Test

Operadores

Código

Variables

Código

HashSet

Test

Objeto Scanner

Test

Streams: filter()

Puzzle

Operaciones de Streams

Puzzle

Interfaz funcional Predicate

Puzzle

Streams: sorted()

Test

Configuración de entorno

Test

Uso de variables

Test

Clases

Test

Streams: distinct()

Puzzle

Streams: count()

Test

ArrayList

Test

Mapas

Código

Datos de referencia

Test

Interfaces funcionales

Puzzle

Métodos básicos de la clase String

Test

Tipos de datos

Código

Clases abstractas

Código

Instalación

Test

Funciones

Código

Excepciones

Código

Estructuras de control

Código

Herencia de clases

Código

La clase Scanner

Código

Generics

Código

Streams: map()

Puzzle

Funciones y encapsulamiento

Test

Todas las lecciones de Java

Accede a todas las lecciones de Java y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Instalación De Java

Introducción Y Entorno

Configuración De Entorno Java

Introducción Y Entorno

Tipos De Datos

Sintaxis

Variables

Sintaxis

Operadores

Sintaxis

Estructuras De Control

Sintaxis

Funciones

Sintaxis

Recursión

Sintaxis

Arrays Y Matrices

Sintaxis

Excepciones

Programación Orientada A Objetos

Clases Y Objetos

Programación Orientada A Objetos

Encapsulación

Programación Orientada A Objetos

Herencia

Programación Orientada A Objetos

Clases Abstractas

Programación Orientada A Objetos

Interfaces

Programación Orientada A Objetos

Sobrecarga De Métodos

Programación Orientada A Objetos

Polimorfismo

Programación Orientada A Objetos

La Clase Scanner

Programación Orientada A Objetos

Métodos De La Clase String

Programación Orientada A Objetos

Excepciones

Programación Orientada A Objetos

Records

Programación Orientada A Objetos

Pattern Matching

Programación Orientada A Objetos

Inferencia De Tipos Con Var

Programación Orientada A Objetos

Enumeraciones Enums

Programación Orientada A Objetos

Generics

Programación Orientada A Objetos

Clases Sealed

Programación Orientada A Objetos

Listas

Framework Collections

Conjuntos

Framework Collections

Mapas

Framework Collections

Funciones Lambda

Programación Funcional

Interfaz Funcional Consumer

Programación Funcional

Interfaz Funcional Predicate

Programación Funcional

Interfaz Funcional Supplier

Programación Funcional

Interfaz Funcional Function

Programación Funcional

Métodos Referenciados

Programación Funcional

Creación De Streams

Programación Funcional

Operaciones Intermedias Con Streams: Map()

Programación Funcional

Operaciones Intermedias Con Streams: Filter()

Programación Funcional

Operaciones Intermedias Con Streams: Distinct()

Programación Funcional

Operaciones Finales Con Streams: Collect()

Programación Funcional

Operaciones Finales Con Streams: Min Max

Programación Funcional

Operaciones Intermedias Con Streams: Flatmap()

Programación Funcional

Operaciones Intermedias Con Streams: Sorted()

Programación Funcional

Operaciones Finales Con Streams: Reduce()

Programación Funcional

Operaciones Finales Con Streams: Foreach()

Programación Funcional

Operaciones Finales Con Streams: Count()

Programación Funcional

Operaciones Finales Con Streams: Match

Programación Funcional

Api Optional

Programación Funcional

Transformación

Programación Funcional

Reducción Y Acumulación

Programación Funcional

Mapeo

Programación Funcional

Streams Paralelos

Programación Funcional

Agrupación Y Partición

Programación Funcional

Filtrado Y Búsqueda

Programación Funcional

Api Java.nio 2

Entrada Y Salida Io

Fundamentos De Io

Entrada Y Salida Io

Leer Y Escribir Archivos

Entrada Y Salida Io

Httpclient Moderno

Entrada Y Salida Io

Clases De Nio2

Entrada Y Salida Io

Api Java.time

Api Java.time

Localtime

Api Java.time

Localdatetime

Api Java.time

Localdate

Api Java.time

Executorservice

Concurrencia

Virtual Threads (Project Loom)

Concurrencia

Future Y Completablefuture

Concurrencia

Spring Framework

Frameworks Para Java

Micronaut

Frameworks Para Java

Maven

Frameworks Para Java

Gradle

Frameworks Para Java

Lombok Para Java

Frameworks Para Java

Quarkus

Frameworks Para Java

Ecosistema Jakarta Ee De Java

Frameworks Para Java

Introducción A Junit 5

Testing

Accede GRATIS a Java y certifícate

Certificados de superación de Java

Supera todos los ejercicios de programación del curso de Java y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.

En esta lección

Objetivos de aprendizaje de esta lección

  • Comprender el funcionamiento y uso del método filter() para seleccionar elementos de un Stream según un predicado.
  • Aprender a utilizar findFirst() y findAny() para recuperar elementos individuales de un Stream.
  • Diferenciar entre anyMatch(), allMatch() y noneMatch() para validar condiciones sobre elementos de un Stream.
  • Aplicar encadenamiento de filtros y referencias a métodos para escribir código más legible y eficiente.
  • Entender las consideraciones de rendimiento y evaluación perezosa en operaciones con Streams.