Java Academy · Aula

Supplier e Consumer

Produza e consuma valores.

Supplier e Consumer é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que um fornecedor faz

Supplier<T> não recebe nenhum argumento e produz um valor do tipo T.

Seu método é T get().
É perfeito para a criação lenta ou adiada de valores.

import java.util.function.Supplier;

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

Fornecedores são avaliados sob demanda

O código dentro de um Supplier só é executado quando get é chamado. Isso torna os fornecedores ideais para valores padrão dispendiosos de que talvez você nunca precise.

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());
    }
}

Fornecedor para valores padrão

Muitas APIs aceitam um Supplier para poderem calcular um valor somente quando necessário, como em 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"));
    }
}

O que um consumidor faz

Consumer<T> aceita um valor e não retorna nada (void).

Seu método é void accept(T t).
É usado para efeitos colaterais, como imprimir ou registrar eventos.

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");
    }
}

Consumidor com forEach

O lugar mais comum em que você encontra Consumer é Iterable.forEach e 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));
    }
}

Encadeando consumidores com andThen

Consumer aceita andThen, que executa dois consumidores em sequência sobre a mesma 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 duas entradas

BiConsumer<T, U> aceita dois argumentos e não retorna nada. Map.forEach usa-o para iterar sobre pares de chave e 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));
    }
}

Referências de método como consumidores

Uma referência de método como System.out::println é um Consumer simples e claro.

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);
    }
}

Combinando fornecedor e consumidor

Um Supplier pode enviar seu valor produzido diretamente para um Consumer, formando um fluxo simples de produção e 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());
    }
}

Fornecedores que retornam objetos

Os construtores funcionam naturalmente como fornecedores por meio de ClassName::new quando não são necessários 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);
    }
}

Efeitos colaterais versus funções puras

Lembre-se do contraste:

Supplier: não recebe entrada e produz uma saída.
Consumer: recebe uma entrada e não produz saída (efeito colateral).
Function: recebe uma entrada e retorna uma saída.

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());
    }
}

Verificação rápida

Qual interface funcional não recebe argumentos e retorna um valor?

Recapitulação

Você produziu e consumiu valores de forma funcional:

Supplier<T> usa get() para produzir valores sob demanda.
Consumer<T> usa accept() para efeitos colaterais e permite encadeamento com andThen.
BiConsumer<T,U> lida com duas entradas, como em Map.forEach.
Referências a métodos e referências a construtores tornam ambos concisos.

Perguntas Frequentes

A aula “Supplier e Consumer” é grátis?

Sim — o texto completo de “Supplier e Consumer” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Supplier e Consumer”?

Produza e consuma valores. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Supplier e Consumer”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy