1 files changed, 32 insertions, 41 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java
index 257f005..de5fe85 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java
@@ -12,77 +12,66 @@ import bjc.utils.data.IPair;
 import bjc.utils.data.Identity;
 import bjc.utils.data.Pair;
 
-final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1,
-		FinalType2> implements
-		Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>,
-				IPair<FinalType1, FinalType2>> {
-	private Set<
-			java.util.stream.Collector.Characteristics>		characteristicSet;
+final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, FinalType2>
+	implements Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> {
 
-	private Collector<InitialType, AuxType1, FinalType1>	firstCollector;
-	private Collector<InitialType, AuxType2,
-			FinalType2>										secondCollector;
+	private Set<java.util.stream.Collector.Characteristics>		characteristicSet;
+
+	private Collector<InitialType, AuxType1, FinalType1>	first;
+	private Collector<InitialType, AuxType2, FinalType2>	second;
 
 	public CompoundCollector(
-			Collector<InitialType, AuxType1, FinalType1> firstCollector,
-			Collector<InitialType, AuxType2, FinalType2> secondCollector) {
-		this.firstCollector = firstCollector;
-		this.secondCollector = secondCollector;
+			Collector<InitialType, AuxType1, FinalType1> first,
+			Collector<InitialType, AuxType2, FinalType2> second) {
+		this.first = first;
+		this.second = second;
 
-		characteristicSet = firstCollector.characteristics();
-		characteristicSet.addAll(secondCollector.characteristics());
+		characteristicSet = first.characteristics();
+		characteristicSet.addAll(second.characteristics());
 	}
 
 	@Override
-	public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>,
-			InitialType> accumulator() {
-		BiConsumer<AuxType1, InitialType> firstAccumulator = firstCollector
-				.accumulator();
-		BiConsumer<AuxType2,
-				InitialType> secondAccumulator = secondCollector
-						.accumulator();
+	public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, InitialType> accumulator() {
+		BiConsumer<AuxType1, InitialType> firstAccumulator = first.accumulator();
+		BiConsumer<AuxType2, InitialType> secondAccumulator = second.accumulator();
 
 		return (state, value) -> {
 			state.doWith((statePair) -> {
-				statePair.doWith((leftState, rightState) -> {
-					firstAccumulator.accept(leftState, value);
-					secondAccumulator.accept(rightState, value);
+				statePair.doWith((left, right) -> {
+					firstAccumulator.accept(left, value);
+					secondAccumulator.accept(right, value);
 				});
 			});
 		};
 	}
 
 	@Override
-	public Set<
-			java.util.stream.Collector.Characteristics> characteristics() {
+	public Set<java.util.stream.Collector.Characteristics> characteristics() {
 		return characteristicSet;
 	}
 
 	@Override
 	public BinaryOperator<IHolder<IPair<AuxType1, AuxType2>>> combiner() {
-		BinaryOperator<AuxType1> firstCombiner = firstCollector.combiner();
-		BinaryOperator<
-				AuxType2> secondCombiner = secondCollector.combiner();
+		BinaryOperator<AuxType1> firstCombiner = first.combiner();
+		BinaryOperator<AuxType2> secondCombiner = second.combiner();
 
 		return (leftState, rightState) -> {
 			return leftState.unwrap((leftPair) -> {
 				return rightState.transform((rightPair) -> {
-					return leftPair.combine(rightPair, firstCombiner,
-							secondCombiner);
+					return leftPair.combine(rightPair, firstCombiner, secondCombiner);
 				});
 			});
 		};
 	}
 
 	@Override
-	public Function<IHolder<IPair<AuxType1, AuxType2>>,
-			IPair<FinalType1, FinalType2>> finisher() {
+	public Function<IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> finisher() {
 		return (state) -> {
 			return state.unwrap((pair) -> {
-				return pair.bind((leftVal, rightVal) -> {
+				return pair.bind((left, right) -> {
 					return new Pair<>(
-							firstCollector.finisher().apply(leftVal),
-							secondCollector.finisher().apply(rightVal));
+							first.finisher().apply(left),
+							second.finisher().apply(right));
 				});
 			});
 		};
@@ -90,8 +79,10 @@ final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1,
 
 	@Override
 	public Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() {
-		return () -> new Identity<>(
-				new Pair<>(firstCollector.supplier().get(),
-						secondCollector.supplier().get()));
+		return () -> {
+			return new Identity<>(new Pair<>(
+					first.supplier().get(),
+					second.supplier().get()));
+		};
 	}
-}
\ No newline at end of file
+}