src/java.base/share/classes/java/util/stream/Collector.java

rev 53968 : enable Collector pre-sizing

@@ -26,14 +26,11 @@
 
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.Objects;
 import java.util.Set;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Function;
-import java.util.function.Supplier;
+import java.util.function.*;
 
 /**
  * A <a href="package-summary.html#Reduction">mutable reduction operation</a> that
  * accumulates input elements into a mutable result container, optionally transforming
  * the accumulated result into a final representation after all input elements

@@ -201,10 +198,20 @@
      * @return a function which returns a new, mutable result container
      */
     Supplier<A> supplier();
 
     /**
+     * A function that creates and returns a new mutable result container,
+     * when applied with an initial capacity.
+     *
+     * @return a function which returns a new, mutable result container
+     */
+    default IntFunction<A> sizedSupplier() {
+        return ignored -> supplier().get();
+    }
+
+    /**
      * A function that folds a value into a mutable result container.
      *
      * @return a function which folds a value into a mutable result container
      */
     BiConsumer<A, T> accumulator();

@@ -259,25 +266,75 @@
      */
     public static<T, R> Collector<T, R, R> of(Supplier<R> supplier,
                                               BiConsumer<R, T> accumulator,
                                               BinaryOperator<R> combiner,
                                               Characteristics... characteristics) {
+        return of(ignored -> supplier.get(), supplier, accumulator, combiner, characteristics);
+    }
+
+    /**
+     * Returns a new {@code Collector} described by the given {@code supplier},
+     * {@code accumulator}, {@code combiner}, and {@code finisher} functions.
+     *
+     * @param supplier The supplier function for the new collector
+     * @param accumulator The accumulator function for the new collector
+     * @param combiner The combiner function for the new collector
+     * @param finisher The finisher function for the new collector
+     * @param characteristics The collector characteristics for the new
+     *                        collector
+     * @param <T> The type of input elements for the new collector
+     * @param <A> The intermediate accumulation type of the new collector
+     * @param <R> The final result type of the new collector
+     * @throws NullPointerException if any argument is null
+     * @return the new {@code Collector}
+     */
+    public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
+                                                 BiConsumer<A, T> accumulator,
+                                                 BinaryOperator<A> combiner,
+                                                 Function<A, R> finisher,
+                                                 Characteristics... characteristics) {
+        return of(ignored -> supplier.get(), supplier, accumulator, combiner, finisher, characteristics);
+    }
+
+    /**
+     * Returns a new {@code Collector} described by the given {@code supplier},
+     * {@code accumulator}, {@code combiner}, and {@code finisher} functions.
+     *
+     * @param sizedSupplier The sized supplier function for the new collector
+     * @param supplier The supplier function for the new collector
+     * @param accumulator The accumulator function for the new collector
+     * @param combiner The combiner function for the new collector
+     * @param characteristics The collector characteristics for the new
+     *                        collector
+     * @param <T> The type of input elements for the new collector
+     * @param <A> The intermediate accumulation type of the new collector
+     * @param <R> The final result type of the new collector
+     * @throws NullPointerException if any argument is null
+     * @return the new {@code Collector}
+     */
+    public static<T, A, R> Collector<T, A, R> of(IntFunction<A> sizedSupplier,
+                                                 Supplier<A> supplier,
+                                                 BiConsumer<A, T> accumulator,
+                                                 BinaryOperator<A> combiner,
+                                                 Characteristics... characteristics) {
+        Objects.requireNonNull(sizedSupplier);
         Objects.requireNonNull(supplier);
         Objects.requireNonNull(accumulator);
         Objects.requireNonNull(combiner);
         Objects.requireNonNull(characteristics);
         Set<Characteristics> cs = (characteristics.length == 0)
                                   ? Collectors.CH_ID
                                   : Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH,
                                                                            characteristics));
-        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, cs);
+        return new Collectors.CollectorImpl<>(sizedSupplier, supplier, accumulator, combiner, cs);
     }
 
     /**
      * Returns a new {@code Collector} described by the given {@code supplier},
      * {@code accumulator}, {@code combiner}, and {@code finisher} functions.
      *
+     * @param sizedSupplier The sized supplier function for the new collector
      * @param supplier The supplier function for the new collector
      * @param accumulator The accumulator function for the new collector
      * @param combiner The combiner function for the new collector
      * @param finisher The finisher function for the new collector
      * @param characteristics The collector characteristics for the new

@@ -286,15 +343,17 @@
      * @param <A> The intermediate accumulation type of the new collector
      * @param <R> The final result type of the new collector
      * @throws NullPointerException if any argument is null
      * @return the new {@code Collector}
      */
-    public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
+    public static<T, A, R> Collector<T, A, R> of(IntFunction<A> sizedSupplier,
+                                                 Supplier<A> supplier,
                                                  BiConsumer<A, T> accumulator,
                                                  BinaryOperator<A> combiner,
                                                  Function<A, R> finisher,
                                                  Characteristics... characteristics) {
+        Objects.requireNonNull(sizedSupplier);
         Objects.requireNonNull(supplier);
         Objects.requireNonNull(accumulator);
         Objects.requireNonNull(combiner);
         Objects.requireNonNull(finisher);
         Objects.requireNonNull(characteristics);

@@ -302,11 +361,11 @@
         if (characteristics.length > 0) {
             cs = EnumSet.noneOf(Characteristics.class);
             Collections.addAll(cs, characteristics);
             cs = Collections.unmodifiableSet(cs);
         }
-        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, finisher, cs);
+        return new Collectors.CollectorImpl<>(sizedSupplier, supplier, accumulator, combiner, finisher, cs);
     }
 
     /**
      * Characteristics indicating properties of a {@code Collector}, which can
      * be used to optimize reduction implementations.