Format the rest

Author: fmeum

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

@@ -328,16 +328,16 @@ static <T, A, R> CollectorImpl<T, A, R> of(Supplier<A> supplier,
     public static <T>
     Collector<T, ?, Set<T>> toSet() {
         return CollectorImpl.ofUnsized(HashSet::new, Set::add,
-            (left, right) -> {
-                if (left.size() < right.size()) {
-                    right.addAll(left);
-                    return right;
-                } else {
-                    left.addAll(right);
-                    return left;
-                }
-            },
-            CH_UNORDERED_ID);
+                                       (left, right) -> {
+                                           if (left.size() < right.size()) {
+                                               right.addAll(left);
+                                               return right;
+                                           } else {
+                                               left.addAll(right);
+                                               return left;
+                                           }
+                                       },
+                                       CH_UNORDERED_ID);
     }
 
     /**
@@ -359,17 +359,17 @@ static <T, A, R> CollectorImpl<T, A, R> of(Supplier<A> supplier,
     public static <T>
     Collector<T, ?, Set<T>> toUnmodifiableSet() {
         return CollectorImpl.ofUnsized(HashSet::new, Set::add,
-            (left, right) -> {
-                if (left.size() < right.size()) {
-                    right.addAll(left);
-                    return right;
-                } else {
-                    left.addAll(right);
-                    return left;
-                }
-            },
-            set -> (Set<T>) Set.of(set.toArray()),
-            CH_UNORDERED_NOID);
+                                       (left, right) -> {
+                                           if (left.size() < right.size()) {
+                                               right.addAll(left);
+                                               return right;
+                                           } else {
+                                               left.addAll(right);
+                                               return left;
+                                           }
+                                       },
+                                       set -> (Set<T>) Set.of(set.toArray()),
+                                       CH_UNORDERED_NOID);
     }
 
     /**
@@ -380,12 +380,13 @@ static <T, A, R> CollectorImpl<T, A, R> of(Supplier<A> supplier,
      * {@code String}, in encounter order
      */
     public static Collector<CharSequence, ?, String> joining() {
-        return CollectorImpl.ofUnsized(StringBuilder::new, StringBuilder::append,
-            (r1, r2) -> {
-                r1.append(r2);
-                return r1;
-            },
-            StringBuilder::toString, CH_NOID);
+        return CollectorImpl.ofUnsized(
+                StringBuilder::new, StringBuilder::append,
+                (r1, r2) -> {
+                    r1.append(r2);
+                    return r1;
+                },
+                StringBuilder::toString, CH_NOID);
     }
 
     /**
@@ -417,10 +418,10 @@ static <T, A, R> CollectorImpl<T, A, R> of(Supplier<A> supplier,
                                                              CharSequence prefix,
                                                              CharSequence suffix) {
         return CollectorImpl.of(
-            () -> new StringJoiner(delimiter, prefix, suffix),
-            exactSize -> new StringJoiner(delimiter, prefix, suffix, exactSize),
-            StringJoiner::add, StringJoiner::merge,
-            StringJoiner::toString, CH_NOID);
+                () -> new StringJoiner(delimiter, prefix, suffix),
+                exactSize -> new StringJoiner(delimiter, prefix, suffix, exactSize),
+                StringJoiner::add, StringJoiner::merge,
+                StringJoiner::toString, CH_NOID);
     }
 
     /**
@@ -476,7 +477,7 @@ BinaryOperator<M> mapMerger(BinaryOperator<V> mergeFunction) {
                                Collector<? super U, A, R> downstream) {
         BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();
         return new CollectorImpl<>(downstream.supplier(), downstream.sizedSupplier(),
-            (r, t) -> downstreamAccumulator.accept(r, mapper.apply(t)),
+                                   (r, t) -> downstreamAccumulator.accept(r, mapper.apply(t)),
                                    downstream.combiner(), downstream.finisher(),
                                    downstream.characteristics());
     }
@@ -612,7 +613,7 @@ public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> dow
             }
         }
         return new CollectorImpl<>(downstream.supplier(), downstream.sizedSupplier(),
-            downstream.accumulator(),
+                                   downstream.accumulator(),
                                    downstream.combiner(),
                                    downstream.finisher().andThen(finisher),
                                    characteristics);
@@ -1487,10 +1488,10 @@ public void accept(T t) {
         // uniqKeysMapMerger() throws if duplicate keys are encountered, so
         // presizing is generally beneficial.
         return CollectorImpl.of(HashMap::new,
-            HashMap::newHashMap,
-            uniqKeysMapAccumulator(keyMapper, valueMapper),
-            uniqKeysMapMerger(),
-            CH_ID);
+                                HashMap::newHashMap,
+                                uniqKeysMapAccumulator(keyMapper, valueMapper),
+                                uniqKeysMapMerger(),
+                                CH_ID);
     }
 
     /**

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

@@ -468,8 +468,8 @@ protected Hybrid(Spliterator<T> spliterator) {
                 this.targetSize =
                     AbstractTask.suggestTargetSize(estimatedSize);
                 this.localResult = new Sequential(spliterator.hasCharacteristics(Spliterator.SIZED)
-                    ? estimatedSize
-                    : -1);
+                                                  ? estimatedSize
+                                                  : -1);
                 this.cancelled = greedy ? null : new AtomicBoolean(false);
                 this.leftPredecessor = null;
             }