codestory

Die Anleitung zu Java Consumer

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

1. Consumer

In Java 8 ist Consumer eine functional interface. Er stellt einen Operator dar, der einen Eingabeparameter akzeptiert und nichts zurückgibt.
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);
        };
    }
}
Zum Beispiel:
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
    }
}
In die Erweiterung des oben genannten Beispiel verwenden wir Consumer in der Methode 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
Unten ist die Liste der Methode in Paket java.util mit der Verwendung von 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)
Mehr sehen: BiConsumer ist eine ähnliche functional interface wie Consumer. Der Unterschied liegt darin, dass er 2 Parameter akzeptiert:

2. Consumer + Method reference

Wenn eine Methode einen einzigen Parameter hat und nichts zurückgibt, wird ihre Referenz als Consumer behandelt.
Z.B: Die Methode System.out.println(param) hat einen Parameter und gibt nichts zurück, wird ihre Referenz System.out::println als Consumer behandelt .
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!
Zum Beispiel:
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

Die Methode andThen(after) gibt einen verbunden Consumer . Zuerst wird der aktuelle Consumer aufgerufen, dann wird after aufgerufen. Wenn ein Fehler in einem der beiden oben genannteen Schritte auftritt, wird der Fehler an den Anrufer (caller) übergeben. Wenn der Fehler beim aktuellen Consumer auftritt, wird after ignoriert.
Consumer
default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> {
       accept(t);
       after.accept(t);
    };
}
Zum Beispiel:
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");
    }
}
Das Ergebnis ist, das das Wort "hello" zweimal gedruck wurde:
hello
hello
Zum Beispiel:
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 Grundlagen

Show More

Java Grundlagen

Show More

Neueste Artikel

Show More