devstory

Le Tutoriel de Java Consumer

  1. Consumer
  2. Consumer + Method reference
  3. Consumer.andThen

1. Consumer

Dans Java 8, Consumer est une functional interface, représentant une opération qui accepte un paramètre d'entrée et ne renvoie rien.
Consumer
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> {
            accept(t);
            after.accept(t);
        };
    }
}
Par exemple:
ConsumerEx1.java
package org.o7planning.ex;

import java.util.function.Consumer;

public class ConsumerEx1 {
    
    public static void main(String[] args)  {

        // Create a Consumer object directly
        Consumer<String> greeter = name -> System.out.println("Hello " + name);
        
        greeter.accept("Tran");   // Hello Tran
    }
}
En développant l'exemple ci-dessus, on utilise Consumer dans la méthode Stream.forEach.
// A method of Stream class
public void forEach(Consumer<? super T> action);
ConsumerEx2.java
package org.o7planning.ex;

import java.util.function.Consumer;
import java.util.stream.Stream;

public class ConsumerEx2 {
    
    public static void main(String[] args)  {

        // Create a Consumer object directly
        Consumer<String> greeter = name -> System.out.println("Hello " + name);  
        
        Stream<String> names = Stream.of("Tran", "Nguyen", "Pham");
        
        names.forEach(greeter);
    }
}
Output:
Hello Tran
Hello Nguyen
Hello Pham
Ci-dessous une liste de méthodes dans le package java.util utilisant Consumer:
Modifier and Type
Method and Description
void
ArrayList.forEach(Consumer<? super E> action)
void
Vector.forEach(Consumer<? super E> action)
default void
PrimitiveIterator.OfDouble.forEachRemaining(Consumer<? super Double> action)
default void
Spliterator.OfDouble.forEachRemaining(Consumer<? super Double> action)
default void
Iterator.forEachRemaining(Consumer<? super E> action)
default void
PrimitiveIterator.OfInt.forEachRemaining(Consumer<? super Integer> action)
default void
Spliterator.OfInt.forEachRemaining(Consumer<? super Integer> action)
default void
PrimitiveIterator.OfLong.forEachRemaining(Consumer<? super Long> action)
default void
Spliterator.OfLong.forEachRemaining(Consumer<? super Long> action)
default void
Spliterator.forEachRemaining(Consumer<? super T> action)
void
Optional.ifPresent(Consumer<? super T> consumer)
default boolean
Spliterator.OfDouble.tryAdvance(Consumer<? super Double> action)
default boolean
Spliterator.OfInt.tryAdvance(Consumer<? super Integer> action)
default boolean
Spliterator.OfLong.tryAdvance(Consumer<? super Long> action)
boolean
Spliterator.tryAdvance(Consumer<? super T> action)
Voir aussi: BiConsumer est une functional interface similaire à Consumer, la différence est qu'elle accepte 2 paramètres:

2. Consumer + Method reference

Si une méthode dispose d'un seul paramètre et ne renvoie rien, sa référence peut être considérée comme un Consumer.
Exemple: La méthode System.out.println(param) prend un paramètre et ne renvoie rien, donc sa référence System.out::println sera considérée comme un Consumer.
ConsumerEx5.java
package org.o7planning.ex;

import java.util.function.Consumer;

public class ConsumerEx5 {

    public static void main(String[] args) {

        myPrintln(System.out::println, "Hello World!");
    }
    
    public static <T> void myPrintln(Consumer<T> c, T t) {
         c.accept(t);
    }
}
Output:
Hello World!
Par exemple:
ConsumerEx6.java
package org.o7planning.ex;

import java.util.stream.Stream;

public class ConsumerEx6 {

    public static void main(String[] args) {
        
        Stream<String> names = Stream.of("Tran", "Nguyen", "Pham");
        
        // Call method: Stream.forEach(Consumer)
        names.forEach(System.out::println);
    }
    
}
Output:
Tran
Nguyen
Pham

3. Consumer.andThen

La méthode andThen(after) renvoie un Consumer associé. D'abord, Consumer actuel sera convoqué et after sera appelé par la suite. Si une erreur se produit dans l'une de deux étapes ci-dessus, l'erreur sera transférée à l'appelant. Si une erreur se produit au niveau de Consumer actuel, donc after est ignoré.
Consumer
default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> {
       accept(t);
       after.accept(t);
    };
}
Par exemple:
ConsumerEx3.java
package org.o7planning.ex;

import java.util.function.Consumer;

public class ConsumerEx3 {
    
    public static void main(String[] args)  {
        
        Consumer<String> c = text -> System.out.println(text.toLowerCase());   
         
        c.andThen(c).accept("Hello");
    }
}
Comme résultat: Le mot "hello" a été imprimé à deux reprises:
hello
hello
Par exemple:
ConsumerEx4.java
package org.o7planning.ex;

import java.util.function.Consumer;

public class ConsumerEx4 {

    public static void main(String[] args) {

        Consumer<UserAccount> c1 = test -> test.auth();

        Consumer<UserAccount> c2 = test -> test.welcome();

        UserAccount user = new UserAccount("tran", "123");

        try {
            c1.andThen(c2).accept(user);
        } catch (Exception e) {

        }
    }

    public static class UserAccount {
        private String userName;
        private String password;

        public UserAccount(String userName, String password) {
            this.userName = userName;
            this.password = password;
        }

        public void auth() {
            if ("123".equals(password)) {
                System.out.println("Valid Account!");
            } else {
                throw new RuntimeException("Invalid Password");
            }
        }

        public void welcome() {
            System.out.println("Welcome! " + this.userName);
        }
    }
}
Output:
Valid Account!
Welcome! tran

Java Basic

Show More

Java Basic

Show More

Articles les plus récents

Show More