Java 8 - using Consumer andThen

Question

I have a POC to use the Java 8 feature.

I want to update the DB after the accept method. Is it good to go with andThen()? When is this method called? Who calls it?

What is the main use of the method andThen()? The look at the documents was confusing.

public class StockTest {

    public static void main(String[] args) {

    List<Trader> traders = new ArrayList<>();

    Random random = new Random();

    // Initializing trading a/c's.
    for (int i = 0; i < 10; i++) {
        Trader trader = new Trader((random.nextInt(100) + 1) * 3);
        traders.add(trader);
    }
    // Display Trade accounts.
    System.out.println("Before Bonus, Units are:");
    for (Trader trader : traders) {
        System.out.print(trader.getUnits() + "\t");
    }

    // Add bonus to each trader.
    traders.forEach(new Consumer<Trader>() {

        @Override
        public void accept(Trader trader) {
            trader.updateBonus(2);
        }

        @Override
        public Consumer<Trader> andThen(Consumer<? super Trader> after) 
       {
            System.out.println("In andThen");
            return Consumer.super.andThen(after);
        }
        });

    // Display Trade accounts after bonus applied..
    System.out.println("\nAfter bonus:");
    for (Trader trader : traders) {
        System.out.print(trader.getUnits() + "\t");
     }

   }

 }

 class Trader {
    private int units;

    public Trader(int initialUnits) {
    this.units = initialUnits;
 }

   public int getUnits() {
        return units;
    }

public void setUnits(int units) {
    this.units = units;
}

 public void updateBonus(int bonusUnits) {
    this.units = this.units * bonusUnits;
  }
 }

Please help with an example or use cases to use this method.

Answer 1

Briefly andThen is used to connect consumers, so the entrance will go to the first and second consumers, lke below:

        Consumer<Trader> consumer1 = new Consumer<Trader>() {

            @Override
            public void accept(Trader trader) {
                trader.updateBonus(2);
            }};

        Consumer<Trader> consumer2 = new Consumer<Trader>() {

            @Override
            public void accept(Trader trader) {
                // do something
            }};
        // Add bonus to each trader.
        traders.forEach(consumer1.andThen(consumer2));

So, here the trader will be transferred consumer1, then consumer2and so on.

. , accept.

andThen . , .

Answer 2

andThen, Consumer s. consumer1.andThen(consumer2) accept consumer1, accept consumer2.

andThen -/ .

andThen Consumer s:

traders.forEach(((Consumer<Trader>)(trader -> trader.updateBonus(2))).andThen(trader -> System.out.println("some more processing")));

, Consumer Consumer:

traders.forEach(trader -> {trader.updateBonus(2);
                           System.out.println("some more processing");});

andThen, Consumer s:

Consumer<Trader> traderConsumer1 = trader -> trader.updateBonus(2);
Consumer<Trader> traderConsumer2 = trader -> System.out.println(trader);
traders.forEach(traderConsumer1.andThen(traderConsumer2));