0Pricing
Java Academy · Leçon

Supplier et Consumer

Produisez et consommez des valeurs

Supplier et Consumer est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Rôle d'un fournisseur

Supplier<T> ne prend aucun argument et produit une valeur de type T.

  • Sa méthode est T get().
  • Idéal pour créer une valeur de manière différée ou à la demande.
import java.util.function.Supplier;

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

Les fournisseurs sont paresseux

Le code contenu dans un Supplier ne s'exécute que lorsque get est appelé. Les fournisseurs sont donc idéaux pour les valeurs par défaut coûteuses dont vous n'aurez peut-être jamais besoin.

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

Les fournisseurs pour les valeurs par défaut

De nombreuses API acceptent un Supplier afin de ne calculer une valeur que lorsque cela est nécessaire, comme avec 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"));
    }
}

Rôle d'un consommateur

Consumer<T> accepte une valeur et ne renvoie aucune valeur.

  • Sa méthode est void accept(T t).
  • Il est utilisé pour les effets secondaires comme l'affichage ou la journalisation.
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 avec forEach

Vous rencontrez le plus souvent Consumer avec Iterable.forEach et 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));
    }
}

Enchaîner des consommateurs avec andThen

Consumer prend en charge andThen, qui exécute deux consommateurs successivement sur la même entrée.

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 pour deux entrées

BiConsumer<T, U> accepte deux arguments et ne renvoie rien. Map.forEach l'utilise pour parcourir les paires clé-valeur.

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

Les références de méthode comme consommateurs

Une référence de méthode telle que System.out::println constitue un Consumer clair.

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

Combiner un fournisseur et un consommateur

Un Supplier peut transmettre directement la valeur qu'il produit à un Consumer, formant ainsi un flux simple de production puis de consommation.

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

Fournisseur renvoyant des objets

Les constructeurs constituent des fournisseurs naturels avec ClassName::new lorsqu’aucun argument n’est nécessaire.

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

Effets secondaires et fonctions pures

Retenez bien la différence :

  • Supplier : aucune entrée, produit une sortie.
  • Consumer : reçoit une entrée et ne produit aucune sortie (effet secondaire).
  • Function : reçoit une entrée et renvoie une sortie.
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());
    }
}

Vérification rapide

Quelle interface fonctionnelle ne prend aucun argument et renvoie une valeur ?

Récapitulatif

Vous avez produit et consommé des valeurs de manière fonctionnelle :

  • Supplier<T> utilise get() pour une production différée.
  • Consumer<T> utilise accept() pour les effets secondaires et s’enchaîne avec andThen.
  • BiConsumer<T,U> gère deux entrées, comme avec Map.forEach.
  • Les références de méthodes et de constructeurs rendent les deux approches concises.

Questions Fréquemment Posées

La leçon « Supplier et Consumer » est-elle gratuite ?

Oui — le texte complet de « Supplier et Consumer » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Supplier et Consumer » ?

Produisez et consommez des valeurs Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Supplier et Consumer » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Function et BiFunction
  2. Supplier et Consumer
  3. Predicate et composition
  4. Interfaces fonctionnelles personnalisées
← Retour à Java Academy