Java reduces the list to a backup chain

Question

Suppose I have a list of some objects in Java, for example

List<Entity> entities = Arrays.asList(entity1, entity2, entity3...);

I would like to reduce it to one instance of a chain object, for example:

class EntityChain {
    private final Entity entity;
    private final Optional<EntityChain> fallback;

    private EntityChain(Builder builder) {
        this.entity = builder.entity;
        this.fallback = builder.fallback;
    }

    public static Builder builder() {
        return new Builder();
    }

    public static final class Builder {
        private Entity entity;
        private Optional<EntityChain> fallback = Optional.empty();           

        public Builder withEntity(Entity entity) {
            this.entity = entity;
            return this;
        }

        public Builder withFallback(EntityChain fallback) {
            this.fallback = Optional.of(fallback);
            return this;
        }

        public EntityChain build() {
            return new EntityChain(this);
        }
    }
}

EntityChainis immutable and has a builder.
Thus, the result will be an instance EntityChain, for example:

chain
   -> entity = entity1
   -> fallback
        -> entity = entity2
        -> fallback
            -> entity = entity3
            -> fallback
                ...

Is it possible to do this with some magic version of Java 8? Is an

Stream.reduce(U identity,
              BiFunction<U, ? super T, U> accumulator,
              BinaryOperator<U> combiner)

applicable here? Somehow this is a builder?

Answer 1

, , , Supplier<EntityChain> . : (n), (n-1),... entity (0).

BiFunction<EntityChain, Entity, EntityChain> reducing =
    (next, entity) -> Optional.ofNullable(next)
                    // create a builder with fallback if EntityChain present
                    .map(fallback -> EntityChain.builder().withFallback(fallback))
                    // create a builder without fallback
                    .orElseGet(EntityChain::builder)
                    //build the EntityChain
                    .withEntity(entity).build();

// combiner never be used in sequentially stream
BinaryOperator<EntityChain> rejectedInParallelStream = (t1, t2) -> {
    //when you use parallel the chain order maybe changed, and the result is wrong.
    throw new IllegalStateException("Can't be used in parallel stream!");
};


EntityChain chain = reverse(entities).
        stream().reduce(null, reducing, rejectedInParallelStream);


//copy & reverse the copied List
static <T> List<T> reverse(List<T> list) {
    List<T> it = list.stream().collect(Collectors.toList());
    Collections.reverse(it);
    return it;
}

-> entity = entity1
-> fallback
    -> entity = entity2
    -> fallback (empty)

Answer 2

, lazying EntityChain. Supplier<EntityChain> .

BiFunction<Supplier<EntityChain>, Entity, Supplier<EntityChain>> reducing =
    (initializer, entity) ->
            // get the EntityChain instance when get() called.
            () -> Optional.ofNullable(initializer.get())
                    // create a builder with fallback if EntityChain present
                    .map(fallback -> EntityChain.builder().withFallback(fallback))
                    // create a builder without fallback
                    .orElseGet(EntityChain::builder)
                    //build the EntityChain
                    .withEntity(entity).build();

// combiner never be used in sequentially stream
BinaryOperator<Supplier<EntityChain>> rejectedInParallelStream = (t1, t2) -> {
    throw new IllegalStateException("Can't be used in parallel stream!");
};

EntityChain chain = reverse(entities).
        stream().reduce(() -> null, reducing, rejectedInParallelStream)
        //when the initializer chain built/reduced,
        //calling the get() to fetch EntityChain header
        .get();

//copy & reverse the copied List
static <T> List<T> reverse(List<T> list) {
    List<T> it = list.stream().collect(Collectors.toList());
    Collections.reverse(it);
    return it;
}

-> entity = entity1
-> fallback
    -> entity = entity2
    -> fallback (empty)

Answer 3

, (Builder::withEntity) (Builder::combine):

public class ChainBuilder {

  public static class Entity {
    int data;
    public Entity(int i) {
      data = i;
    }
    @Override
    public String toString() {
      return "Entity [data=" + data + "]";
    }
  }

  public static class EntityChain {
    private Entity entity;
    private Optional<EntityChain> fallback = null;

    @Override
    public String toString() {
      return "EntityChain [entity=" + entity + ", fallback=" + fallback + "]";
    }

    public static class Builder {
      private EntityChain chain = null;

      public Builder() { }

      private static EntityChain newChainLink(Entity e){
        EntityChain n = new EntityChain();
        n.entity = e;
        n.fallback = Optional.empty();
        return n;
      }

      /** accumulator, attaches to the end of the chain */
      public Builder withEntity(Entity e) {
        if(chain == null) {
          chain = newChainLink(e);
        } else {
          EntityChain last = getLast();
          last.fallback = Optional.of(newChainLink(e));
        }
        return this;
      }

      /** combiner, glues two chains together */
      public Builder combine(Builder u) {
        if(u.chain != null) {
          getLast().fallback = Optional.of(u.chain);
        }
        return this;
      }


      /** returns the end of the chain */
      private EntityChain getLast() {
        EntityChain link = chain;
        while(link.fallback.isPresent()){
          link = link.fallback.get();
        }
        return link;
      }

      public EntityChain build() {
        return chain;
      }

    }
  }

  public static void main(String[] args) {
    List<Entity> entities = Arrays.asList(new Entity(1), new Entity(2), new Entity(3));
    final Builder reduced = entities.stream().reduce(new EntityChain.Builder(),
                                                     (t,u)->t.withEntity(u),
                                                     (t,u)->t.combine(u));
    System.out.println(reduced.build());
  }
}

:

EntityChain [entity = Entity [data = 1], fallback = [EntityChain [entity = Entity [data = 2], fallback = [EntityChain [entity = Entity [data = 3], fallback = Optional.empty] ]]]]