{@code
- * // Accumulate elements into a List
- * List list = people.collect(Collectors.toList());
+ * // Accumulate names into a List
+ * List list = people.stream().map(Person::getName).collect(Collectors.toList());
*
- * // Accumulate elements into a TreeSet
- * List list = people.collect(Collectors.toCollection(TreeSet::new));
+ * // Accumulate names into a TreeSet
+ * Set list = people.stream().map(Person::getName).collect(Collectors.toCollection(TreeSet::new));
*
* // Convert elements to strings and concatenate them, separated by commas
- * String joined = stream.map(Object::toString)
- * .collect(Collectors.toStringJoiner(", "))
- * .toString();
+ * String joined = things.stream()
+ * .map(Object::toString)
+ * .collect(Collectors.joining(", "));
*
* // Find highest-paid employee
* Employee highestPaid = employees.stream()
- * .collect(Collectors.maxBy(Comparator.comparing(Employee::getSalary)));
+ * .collect(Collectors.maxBy(Comparator.comparing(Employee::getSalary)))
+ * .get();
*
* // Group employees by department
* Map> byDept
@@ -85,7 +89,7 @@
* .collect(Collectors.groupingBy(Employee::getDepartment));
*
* // Find highest-paid employee by department
- * Map highestPaidByDept
+ * Map> highestPaidByDept
* = employees.stream()
* .collect(Collectors.groupingBy(Employee::getDepartment,
* Collectors.maxBy(Comparator.comparing(Employee::getSalary))));
@@ -93,7 +97,7 @@
* // Partition students into passing and failing
* Map> passingFailing =
* students.stream()
- * .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD);
+ * .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));
*
* }
*
@@ -103,15 +107,19 @@
*/
public final class Collectors {
- private static final Set{@code
@@ -364,23 +336,27 @@
*
* @param the type of the input elements
* @param type of elements accepted by downstream collector
+ * @param intermediate accumulation type of the downstream collector
* @param result type of collector
* @param mapper a function to be applied to the input elements
* @param downstream a collector which will accept mapped values
* @return a collector which applies the mapping function to the input
* elements and provides the mapped results to the downstream collector
*/
- public static Collector
- mapping(Function mapper, Collector downstream) {
- BiFunction downstreamAccumulator = downstream.accumulator();
- return new CollectorImpl<>(downstream.resultSupplier(),
- (r, t) -> downstreamAccumulator.apply(r, mapper.apply(t)),
- downstream.combiner(), downstream.characteristics());
+ public static
+ Collector mapping(Function mapper,
+ Collector downstream) {
+ BiConsumer downstreamAccumulator = downstream.accumulator();
+ return new CollectorImpl<>(downstream.supplier(),
+ (r, t) -> downstreamAccumulator.accept(r, mapper.apply(t)),
+ downstream.combiner(), downstream.finisher(),
+ downstream.characteristics());
}
/**
- * Returns a {@code Collector} that counts the number of input
- * elements.
+ * Returns a {@code Collector} accepting elements of type {@code T} that
+ * counts the number of input elements. If no elements are present, the
+ * result is 0.
*
* @implSpec
* This produces a result equivalent to:
@@ -391,14 +367,14 @@
* @param the type of the input elements
* @return a {@code Collector} that counts the input elements
*/
- public static Collector
+ public static Collector
counting() {
return reducing(0L, e -> 1L, Long::sum);
}
/**
- * Returns a {@code Collector} that produces the minimal element
- * according to a given {@code Comparator}.
+ * Returns a {@code Collector} that produces the minimal element according
+ * to a given {@code Comparator}, described as an {@code Optional}.
*
* @implSpec
* This produces a result equivalent to:
@@ -410,14 +386,14 @@
* @param comparator a {@code Comparator} for comparing elements
* @return a {@code Collector} that produces the minimal value
*/
- public static Collector
+ public static Collector>
minBy(Comparator comparator) {
return reducing(BinaryOperator.minBy(comparator));
}
/**
- * Returns a {@code Collector} that produces the maximal element
- * according to a given {@code Comparator}.
+ * Returns a {@code Collector} that produces the maximal element according
+ * to a given {@code Comparator}, described as an {@code Optional}.
*
* @implSpec
* This produces a result equivalent to:
@@ -429,39 +405,143 @@
* @param comparator a {@code Comparator} for comparing elements
* @return a {@code Collector} that produces the maximal value
*/
- public static Collector
+ public static Collector>
maxBy(Comparator comparator) {
return reducing(BinaryOperator.maxBy(comparator));
}
/**
- * Returns a {@code Collector} that produces the sum of a
- * long-valued function applied to the input element.
+ * Returns a {@code Collector} that produces the sum of a integer-valued
+ * function applied to the input elements. If no elements are present,
+ * the result is 0.
*
- * @implSpec
- * This produces a result equivalent to:
- * {@code
- * reducing(0L, mapper, Long::sum)
- * }
+ * @param the type of the input elements
+ * @param mapper a function extracting the property to be summed
+ * @return a {@code Collector} that produces the sum of a derived property
+ */
+ public static Collector
+ summingInt(ToIntFunction mapper) {
+ return new CollectorImpl(
+ () -> new int[1],
+ (a, t) -> { a[0] += mapper.applyAsInt(t); },
+ (a, b) -> { a[0] += b[0]; return a; },
+ a -> a[0], CH_NOID);
+ }
+
+ /**
+ * Returns a {@code Collector} that produces the sum of a long-valued
+ * function applied to the input elements. If no elements are present,
+ * the result is 0.
+ *
+ * @param the type of the input elements
+ * @param mapper a function extracting the property to be summed
+ * @return a {@code Collector} that produces the sum of a derived property
+ */
+ public static Collector
+ summingLong(ToLongFunction mapper) {
+ return new CollectorImpl(
+ () -> new long[1],
+ (a, t) -> { a[0] += mapper.applyAsLong(t); },
+ (a, b) -> { a[0] += b[0]; return a; },
+ a -> a[0], CH_NOID);
+ }
+
+ /**
+ * Returns a {@code Collector} that produces the sum of a double-valued
+ * function applied to the input elements. If no elements are present,
+ * the result is 0.
+ *
+ * The sum returned can vary depending upon the order in which
+ * values are recorded, due to accumulated rounding error in
+ * addition of values of differing magnitudes. Values sorted by increasing
+ * absolute magnitude tend to yield more accurate results. If any recorded
+ * value is a {@code NaN} or the sum is at any point a {@code NaN} then the
+ * sum will be {@code NaN}.
+ *
+ * @param the type of the input elements
+ * @param mapper a function extracting the property to be summed
+ * @return a {@code Collector} that produces the sum of a derived property
+ */
+ public static Collector
+ summingDouble(ToDoubleFunction mapper) {
+ return new CollectorImpl(
+ () -> new double[1],
+ (a, t) -> { a[0] += mapper.applyAsDouble(t); },
+ (a, b) -> { a[0] += b[0]; return a; },
+ a -> a[0], CH_NOID);
+ }
+
+ /**
+ * Returns a {@code Collector} that produces the average of an integer-valued
+ * function applied to the input elements. If no elements are present,
+ * the result is 0.
*
* @param the type of the input elements
* @param mapper a function extracting the property to be summed
* @return a {@code Collector} that produces the sum of a derived property
*/
- public static Collector
- sumBy(Function mapper) {
- return reducing(0L, mapper, Long::sum);
+ public static Collector
+ averagingInt(ToIntFunction mapper) {
+ return new CollectorImpl(
+ () -> new long[2],
+ (a, t) -> { a[0] += mapper.applyAsInt(t); a[1]++; },
+ (a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
+ a -> (a[1] == 0) ? 0.0d : (double) a[0] / a[1], CH_NOID);
}
/**
- * Returns a {@code Collector} which performs a reduction of its
- * input elements under a specified {@code BinaryOperator}.
+ * Returns a {@code Collector} that produces the average of a long-valued
+ * function applied to the input elements. If no elements are present,
+ * the result is 0.
+ *
+ * @param the type of the input elements
+ * @param mapper a function extracting the property to be summed
+ * @return a {@code Collector} that produces the sum of a derived property
+ */
+ public static Collector
+ averagingLong(ToLongFunction mapper) {
+ return new CollectorImpl(
+ () -> new long[2],
+ (a, t) -> { a[0] += mapper.applyAsLong(t); a[1]++; },
+ (a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
+ a -> (a[1] == 0) ? 0.0d : (double) a[0] / a[1], CH_NOID);
+ }
+
+ /**
+ * Returns a {@code Collector} that produces the average of a double-valued
+ * function applied to the input elements. If no elements are present,
+ * the result is 0.
+ *
+ * The average returned can vary depending upon the order in which
+ * values are recorded, due to accumulated rounding error in
+ * addition of values of differing magnitudes. Values sorted by increasing
+ * absolute magnitude tend to yield more accurate results. If any recorded
+ * value is a {@code NaN} or the sum is at any point a {@code NaN} then the
+ * average will be {@code NaN}.
+ *
+ * @param the type of the input elements
+ * @param mapper a function extracting the property to be summed
+ * @return a {@code Collector} that produces the sum of a derived property
+ */
+ public static Collector
+ averagingDouble(ToDoubleFunction mapper) {
+ return new CollectorImpl(
+ () -> new double[2],
+ (a, t) -> { a[0] += mapper.applyAsDouble(t); a[1]++; },
+ (a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
+ a -> (a[1] == 0) ? 0.0d : a[0] / a[1], CH_NOID);
+ }
+
+ /**
+ * Returns a {@code Collector} which performs a reduction of its
+ * input elements under a specified {@code BinaryOperator} using the
+ * provided identity.
*
* @apiNote
* The {@code reducing()} collectors are most useful when used in a
* multi-level reduction, downstream of {@code groupingBy} or
* {@code partitioningBy}. To perform a simple reduction on a stream,
- * use {@link Stream#reduce(BinaryOperator)} instead.
+ * use {@link Stream#reduce(Object, BinaryOperator)}} instead.
*
* @param element type for the input and output of the reduction
* @param identity the identity value for the reduction (also, the value
@@ -472,14 +552,25 @@
* @see #reducing(BinaryOperator)
* @see #reducing(Object, Function, BinaryOperator)
*/
- public static Collector
+ public static Collector
reducing(T identity, BinaryOperator op) {
- return new CollectorImpl<>(() -> identity, (r, t) -> (r == null ? t : op.apply(r, t)), op);
+ return new CollectorImpl<>(
+ boxSupplier(identity),
+ (a, t) -> { a[0] = op.apply(a[0], t); },
+ (a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
+ a -> a[0],
+ CH_NOID);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static Supplier boxSupplier(T identity) {
+ return () -> (T[]) new Object[] { identity };
}
/**
- * Returns a {@code Collector} which performs a reduction of its
- * input elements under a specified {@code BinaryOperator}.
+ * Returns a {@code Collector} which performs a reduction of its
+ * input elements under a specified {@code BinaryOperator}. The result
+ * is described as an {@code Optional}.
*
* @apiNote
* The {@code reducing()} collectors are most useful when used in a
@@ -491,15 +582,8 @@
* person in each city:
* {@code
* Comparator byHeight = Comparator.comparing(Person::getHeight);
- * BinaryOperator tallerOf = BinaryOperator.greaterOf(byHeight);
* Map tallestByCity
- * = people.stream().collect(groupingBy(Person::getCity, reducing(tallerOf)));
- * }
- *
- * @implSpec
- * The default implementation is equivalent to:
- * {@code
- * reducing(null, op);
+ * = people.stream().collect(groupingBy(Person::getCity, reducing(BinaryOperator.maxBy(byHeight))));
* }
*
* @param element type for the input and output of the reduction
@@ -509,13 +593,32 @@
* @see #reducing(Object, BinaryOperator)
* @see #reducing(Object, Function, BinaryOperator)
*/
- public static Collector
+ public static Collector>
reducing(BinaryOperator op) {
- return reducing(null, op);
+ class OptionalBox implements Consumer {
+ T value = null;
+ boolean present = false;
+
+ @Override
+ public void accept(T t) {
+ if (present) {
+ value = op.apply(value, t);
+ }
+ else {
+ value = t;
+ present = true;
+ }
+ }
+ }
+
+ return new CollectorImpl>(
+ OptionalBox::new, OptionalBox::accept,
+ (a, b) -> { if (b.present) a.accept(b.value); return a; },
+ a -> Optional.ofNullable(a.value), CH_NOID);
}
/**
- * Returns a {@code Collector} which performs a reduction of its
+ * Returns a {@code Collector} which performs a reduction of its
* input elements under a specified mapping function and
* {@code BinaryOperator}. This is a generalization of
* {@link #reducing(Object, BinaryOperator)} which allows a transformation
@@ -524,17 +627,17 @@
* @apiNote
* The {@code reducing()} collectors are most useful when used in a
* multi-level reduction, downstream of {@code groupingBy} or
- * {@code partitioningBy}. To perform a simple reduction on a stream,
- * use {@link Stream#reduce(BinaryOperator)} instead.
+ * {@code partitioningBy}. To perform a simple map-reduce on a stream,
+ * use {@link Stream#map(Function)} and {@link Stream#reduce(Object, BinaryOperator)}
+ * instead.
*
* For example, given a stream of {@code Person}, to calculate the longest
* last name of residents in each city:
*
{@code
* Comparator byLength = Comparator.comparing(String::length);
- * BinaryOperator longerOf = BinaryOperator.greaterOf(byLength);
* Map longestLastNameByCity
* = people.stream().collect(groupingBy(Person::getCity,
- * reducing(Person::getLastName, longerOf)));
+ * reducing(Person::getLastName, BinaryOperator.maxBy(byLength))));
* }
*
* @param the type of the input elements
@@ -549,18 +652,20 @@
* @see #reducing(BinaryOperator)
*/
public static
- Collector reducing(U identity,
- Function mapper,
- BinaryOperator op) {
- return new CollectorImpl<>(() -> identity,
- (r, t) -> (r == null ? mapper.apply(t) : op.apply(r, mapper.apply(t))),
- op);
+ Collector reducing(U identity,
+ Function mapper,
+ BinaryOperator op) {
+ return new CollectorImpl<>(
+ boxSupplier(identity),
+ (a, t) -> { a[0] = op.apply(a[0], mapper.apply(t)); },
+ (a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
+ a -> a[0], CH_NOID);
}
/**
* Returns a {@code Collector} implementing a "group by" operation on
* input elements of type {@code T}, grouping elements according to a
- * classification function.
+ * classification function, and returning the results in a {@code Map}.
*
* The classification function maps elements to some key type {@code K}.
* The collector produces a {@code Map>} whose keys are the
@@ -586,9 +691,9 @@
* @see #groupingBy(Function, Supplier, Collector)
* @see #groupingByConcurrent(Function)
*/
- public static
- Collector>> groupingBy(Function classifier) {
- return groupingBy(classifier, HashMap::new, toList());
+ public static Collector>>
+ groupingBy(Function classifier) {
+ return groupingBy(classifier, toList());
}
/**
@@ -615,6 +720,7 @@
*
* @param the type of the input elements
* @param the type of the keys
+ * @param the intermediate accumulation type of the downstream collector
* @param the result type of the downstream reduction
* @param classifier a classifier function mapping input elements to keys
* @param downstream a {@code Collector} implementing the downstream reduction
@@ -624,9 +730,9 @@
* @see #groupingBy(Function, Supplier, Collector)
* @see #groupingByConcurrent(Function, Collector)
*/
- public static
- Collector> groupingBy(Function classifier,
- Collector downstream) {
+ public static
+ Collector> groupingBy(Function classifier,
+ Collector downstream) {
return groupingBy(classifier, HashMap::new, downstream);
}
@@ -653,6 +759,7 @@
*
* @param the type of the input elements
* @param the type of the keys
+ * @param the intermediate accumulation type of the downstream collector
* @param the result type of the downstream reduction
* @param the type of the resulting {@code Map}
* @param classifier a classifier function mapping input elements to keys
@@ -665,25 +772,39 @@
* @see #groupingBy(Function)
* @see #groupingByConcurrent(Function, Supplier, Collector)
*/
- public static >
- Collector groupingBy(Function classifier,
- Supplier mapFactory,
- Collector downstream) {
- Supplier downstreamSupplier = downstream.resultSupplier();
- BiFunction downstreamAccumulator = downstream.accumulator();
- BiFunction accumulator = (m, t) -> {
+ public static >
+ Collector groupingBy(Function classifier,
+ Supplier mapFactory,
+ Collector downstream) {
+ Supplier downstreamSupplier = downstream.supplier();
+ BiConsumer downstreamAccumulator = downstream.accumulator();
+ BiConsumer, T> accumulator = (m, t) -> {
K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
- D oldContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
- D newContainer = downstreamAccumulator.apply(oldContainer, t);
- if (newContainer != oldContainer)
- m.put(key, newContainer);
- return m;
+ A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());
+ downstreamAccumulator.accept(container, t);
};
- return new CollectorImpl<>(mapFactory, accumulator, mapMerger(downstream.combiner()), CH_STRICT);
+ BinaryOperator> merger = Collectors.>mapMerger(downstream.combiner());
+ @SuppressWarnings("unchecked")
+ Supplier> mangledFactory = (Supplier>) mapFactory;
+
+ if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
+ return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
+ }
+ else {
+ @SuppressWarnings("unchecked")
+ Function downstreamFinisher = (Function) downstream.finisher();
+ Function, M> finisher = intermediate -> {
+ intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
+ @SuppressWarnings("unchecked")
+ M castResult = (M) intermediate;
+ return castResult;
+ };
+ return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
+ }
}
/**
- * Returns a {@code Collector} implementing a concurrent "group by"
+ * Returns a concurrent {@code Collector} implementing a "group by"
* operation on input elements of type {@code T}, grouping elements
* according to a classification function.
*
@@ -716,12 +837,13 @@
* @see #groupingByConcurrent(Function, Supplier, Collector)
*/
public static
- Collector>> groupingByConcurrent(Function classifier) {
+ Collector>>
+ groupingByConcurrent(Function classifier) {
return groupingByConcurrent(classifier, ConcurrentHashMap::new, toList());
}
/**
- * Returns a {@code Collector} implementing a concurrent cascaded "group by"
+ * Returns a concurrent {@code Collector} implementing a cascaded "group by"
* operation on input elements of type {@code T}, grouping elements
* according to a classification function, and then performing a reduction
* operation on the values associated with a given key using the specified
@@ -739,12 +861,13 @@
* where the city names are sorted:
* {@code
* ConcurrentMap> namesByCity
- * = people.stream().collect(groupingByConcurrent(Person::getCity, TreeMap::new,
+ * = people.stream().collect(groupingByConcurrent(Person::getCity, ConcurrentSkipListMap::new,
* mapping(Person::getLastName, toSet())));
* }
*
* @param the type of the input elements
* @param the type of the keys
+ * @param the intermediate accumulation type of the downstream collector
* @param the result type of the downstream reduction
* @param classifier a classifier function mapping input elements to keys
* @param downstream a {@code Collector} implementing the downstream reduction
@@ -754,9 +877,9 @@
* @see #groupingByConcurrent(Function)
* @see #groupingByConcurrent(Function, Supplier, Collector)
*/
- public static
- Collector> groupingByConcurrent(Function classifier,
- Collector downstream) {
+ public static
+ Collector> groupingByConcurrent(Function classifier,
+ Collector downstream) {
return groupingByConcurrent(classifier, ConcurrentHashMap::new, downstream);
}
@@ -787,6 +910,7 @@
*
* @param the type of the input elements
* @param the type of the keys
+ * @param the intermediate accumulation type of the downstream collector
* @param the result type of the downstream reduction
* @param the type of the resulting {@code ConcurrentMap}
* @param classifier a classifier function mapping input elements to keys
@@ -799,51 +923,46 @@
* @see #groupingByConcurrent(Function, Collector)
* @see #groupingBy(Function, Supplier, Collector)
*/
- public static >
- Collector groupingByConcurrent(Function classifier,
- Supplier mapFactory,
- Collector downstream) {
- Supplier downstreamSupplier = downstream.resultSupplier();
- BiFunction downstreamAccumulator = downstream.accumulator();
- BinaryOperator combiner = mapMerger(downstream.combiner());
+ public static >
+ Collector groupingByConcurrent(Function classifier,
+ Supplier mapFactory,
+ Collector downstream) {
+ Supplier downstreamSupplier = downstream.supplier();
+ BiConsumer downstreamAccumulator = downstream.accumulator();
+ BinaryOperator> merger = Collectors.>mapMerger(downstream.combiner());
+ @SuppressWarnings("unchecked")
+ Supplier> mangledFactory = (Supplier>) mapFactory;
+ BiConsumer, T> accumulator;
if (downstream.characteristics().contains(Collector.Characteristics.CONCURRENT)) {
- BiFunction accumulator = (m, t) -> {
+ accumulator = (m, t) -> {
K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
- downstreamAccumulator.apply(m.computeIfAbsent(key, k -> downstreamSupplier.get()), t);
- return m;
+ A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
+ downstreamAccumulator.accept(resultContainer, t);
};
- return new CollectorImpl<>(mapFactory, accumulator, combiner, CH_CONCURRENT);
- } else if (downstream.characteristics().contains(Collector.Characteristics.STRICTLY_MUTATIVE)) {
- BiFunction accumulator = (m, t) -> {
+ }
+ else {
+ accumulator = (m, t) -> {
K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
- D resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
+ A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
synchronized (resultContainer) {
- downstreamAccumulator.apply(resultContainer, t);
+ downstreamAccumulator.accept(resultContainer, t);
}
- return m;
};
- return new CollectorImpl<>(mapFactory, accumulator, combiner, CH_CONCURRENT);
- } else {
- BiFunction accumulator = (m, t) -> {
- K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
- do {
- D oldResult = m.computeIfAbsent(key, k -> downstreamSupplier.get());
- if (oldResult == null) {
- if (m.putIfAbsent(key, downstreamAccumulator.apply(null, t)) == null)
- return m;
- } else {
- synchronized (oldResult) {
- if (m.get(key) != oldResult)
- continue;
- D newResult = downstreamAccumulator.apply(oldResult, t);
- if (oldResult != newResult)
- m.put(key, newResult);
- return m;
- }
- }
- } while (true);
+ }
+
+ if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
+ return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_CONCURRENT_ID);
+ }
+ else {
+ @SuppressWarnings("unchecked")
+ Function downstreamFinisher = (Function) downstream.finisher();
+ Function, M> finisher = intermediate -> {
+ intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
+ @SuppressWarnings("unchecked")
+ M castResult = (M) intermediate;
+ return castResult;
};
- return new CollectorImpl<>(mapFactory, accumulator, combiner, CH_CONCURRENT);
+ return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_CONCURRENT_NOID);
}
}
@@ -862,7 +981,7 @@
* @see #partitioningBy(Predicate, Collector)
*/
public static
- Collector>> partitioningBy(Predicate predicate) {
+ Collector>> partitioningBy(Predicate predicate) {
return partitioningBy(predicate, toList());
}
@@ -877,6 +996,7 @@
* serializability, or thread-safety of the {@code Map} returned.
*
* @param the type of the input elements
+ * @param the intermediate accumulation type of the downstream collector
* @param the result type of the downstream reduction
* @param predicate a predicate used for classifying input elements
* @param downstream a {@code Collector} implementing the downstream
@@ -886,52 +1006,43 @@
*
* @see #partitioningBy(Predicate)
*/
- public static
- Collector> partitioningBy(Predicate predicate,
- Collector downstream) {
- BiFunction downstreamAccumulator = downstream.accumulator();
- BiFunction, T, Map> accumulator = (result, t) -> {
+ public static