Java Academy · Lección

Supplier y Consumer

Produzca y consuma valores

Supplier y Consumer es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Qué hace Supplier

Supplier<T> no recibe ningún argumento y produce un valor de tipo T.

Su método es T get().
Es perfecto para crear valores de forma diferida.

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<String> greeting = () -> "Hello!";
        System.out.println(greeting.get());
    }
}

Los Supplier son diferidos

El código dentro de un Supplier solo se ejecuta cuando se llama a get. Esto hace que los Supplier sean ideales para valores predeterminados costosos que quizá nunca necesite.

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<Integer> expensive = () -> {
            System.out.println("computing...");
            return 42;
        };
        System.out.println("before get");
        System.out.println(expensive.get());
    }
}

Supplier para valores predeterminados

Muchas API aceptan un Supplier para poder calcular un valor solo cuando sea necesario, como Optional.orElseGet.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.empty();
        System.out.println(name.orElseGet(() -> "default"));
    }
}

Qué hace Consumer

Consumer<T> acepta un valor y no devuelve nada (void).

Su método es void accept(T t).
Se utiliza para efectos secundarios, como imprimir o registrar información.

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> printer = s -> System.out.println("Got: " + s);
        printer.accept("data");
    }
}

Consumer con forEach

El lugar más habitual donde encontrará Consumer es Iterable.forEach y Stream.forEach.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = List.of("a", "b", "c");
        items.forEach(item -> System.out.println(item));
    }
}

Encadenar Consumer con andThen

Consumer admite andThen, que ejecuta dos Consumer en secuencia sobre la misma entrada.

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> first = s -> System.out.println("upper: " + s.toUpperCase());
        Consumer<String> second = s -> System.out.println("len: " + s.length());
        first.andThen(second).accept("hello");
    }
}

BiConsumer para dos entradas

BiConsumer<T, U> acepta dos argumentos y no devuelve nada. Map.forEach lo utiliza para recorrer pares de clave y valor.

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bob", 25);
        ages.forEach((name, age) -> System.out.println(name + "=" + age));
    }
}

Referencias a métodos como Consumer

Una referencia a método como System.out::println es un Consumer limpio y conciso.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3);
        nums.forEach(System.out::println);
    }
}

Combinación de Supplier y Consumer

Un Supplier puede pasar directamente el valor que produce a un Consumer, formando un flujo sencillo de producción y consumo.

import java.util.function.Supplier;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Supplier<String> source = () -> "payload";
        Consumer<String> sink = s -> System.out.println("received " + s);
        sink.accept(source.get());
    }
}

Supplier que devuelve objetos

Los constructores crean proveedores naturales mediante ClassName::new cuando no se necesitan argumentos.

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<List<String>> factory = ArrayList::new;
        List<String> list = factory.get();
        list.add("x");
        System.out.println(list);
    }
}

Efectos secundarios frente a funciones puras

Recuerde la diferencia:

Supplier: no recibe ninguna entrada y produce una salida.
Consumer: recibe una entrada y no produce ninguna salida (efecto secundario).
Function: recibe una entrada y devuelve una salida.

import java.util.function.Supplier;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Supplier<Integer> dice = () -> 4;
        Consumer<Integer> show = n -> System.out.println("rolled " + n);
        show.accept(dice.get());
    }
}

Comprobación rápida

¿Qué interfaz funcional no recibe argumentos y devuelve un valor?

Resumen

Produjo y consumió valores de forma funcional:

Supplier<T> usa get() para producir valores de forma diferida.
Consumer<T> usa accept() para producir efectos secundarios y se encadena con andThen.
BiConsumer<T,U> gestiona dos entradas, como en Map.forEach.
Las referencias a métodos y constructores hacen que ambas operaciones sean más concisas.

Preguntas frecuentes

¿La lección «Supplier y Consumer» es gratis?

Sí — el texto completo de «Supplier y Consumer» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Supplier y Consumer»?

Produzca y consuma valores Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Supplier y Consumer»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy