code: @NotNull
      public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(
              @NotNull final Predicate<? super T> predicate,
              @NotNull final Collector<? super T, A, D> downstream) {
  
          final BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
          return new CollectorsImpl<T, Tuple2<A>, Map<Boolean, D>>(
                  new Supplier<Tuple2<A>>() {
                      @NotNull
                      @Override
                      public Tuple2<A> get() {
                          return new Tuple2<A>(
                                  downstream.supplier().get(),
                                  downstream.supplier().get());
                      }
                  },
                  new BiConsumer<Tuple2<A>, T>() {
                      @Override
                      public void accept(@NotNull Tuple2<A> container, T t) {
                          downstreamAccumulator.accept(
                                  predicate.test(t) ? container.a : container.b, t);
                      }
                  },
                  new Function<Tuple2<A>, Map<Boolean, D>>() {
                      @NotNull
                      @Override
                      public Map<Boolean, D> apply(@NotNull Tuple2<A> container) {
                          final Function<A, D> finisher = downstream.finisher();
                          Map<Boolean, D> result = new HashMap<Boolean, D>(2);
                          result.put(Boolean.TRUE, finisher.apply(container.a));
                          result.put(Boolean.FALSE, finisher.apply(container.b));
                          return result;
                      }
                  }
          );
      }
docs: Returns a {@code Collector} that performs partitioning operation according to a predicate.
  The returned {@code Map} always contains mappings for both {@code false} and {@code true} keys.
  
  @param <T> the type of the input elements
  @param <D> the result type of downstream reduction
  @param <A> the accumulation type
  @param predicate  a predicate used for classifying input elements
  @param downstream  the collector of partitioned elements
  @return a {@code Collector}
  @since 1.1.9