Merge pull request #6 from lokic/dev/stream-ex

Dev/stream ex

Author: lokic

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.lokic</groupId>
     <artifactId>java-plus</artifactId>
-    <version>0.3.1</version>
+    <version>0.4.0</version>
     <name>java-plus</name>
     <description>Provide some useful extensions on the basis of java8 to make java more usable.</description>
     <url>https://github.com/lokic/java-plus</url>

src/main/java/com/github/lokic/javaplus/NullData.java

@@ -1,11 +1,12 @@
 package com.github.lokic.javaplus;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Stream;
 
 public class NullData {
-    private static final List<?> NULL_LIST = createNullList();
+    private static final List<?> NULL_LIST = Collections.unmodifiableList(createNullList());
 
     private static <T> List<T> createNullList() {
         List<T> li = new ArrayList<>();

src/main/java/com/github/lokic/javaplus/Collectors.java renamed to src/main/java/com/github/lokic/javaplus/OtherCollectors.java

@@ -4,14 +4,32 @@
 import com.github.lokic.javaplus.tuple.Tuple;
 import com.github.lokic.javaplus.tuple.Tuple2;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.util.*;
-import java.util.function.BinaryOperator;
-import java.util.function.Function;
-import java.util.function.Supplier;
+import java.util.function.*;
 import java.util.stream.Collector;
 import java.util.stream.Stream;
 
-public class Collectors {
+public class OtherCollectors {
+
+
+    public static final Set<Collector.Characteristics> CH_CONCURRENT_ID
+            = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.CONCURRENT,
+            Collector.Characteristics.UNORDERED,
+            Collector.Characteristics.IDENTITY_FINISH));
+    public static final Set<Collector.Characteristics> CH_CONCURRENT_NOID
+            = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.CONCURRENT,
+            Collector.Characteristics.UNORDERED));
+    public static final Set<Collector.Characteristics> CH_ID
+            = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));
+    public static final Set<Collector.Characteristics> CH_UNORDERED_ID
+            = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.UNORDERED,
+            Collector.Characteristics.IDENTITY_FINISH));
+    public static final Set<Collector.Characteristics> CH_NOID = Collections.emptySet();
+    public static final Set<Collector.Characteristics> CH_UNORDERED_NOID
+            = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.UNORDERED));
+
 
     public static class Reversed {
 
@@ -193,4 +211,127 @@ private enum Order {
                 java.util.stream.Collectors.toMap(keyMapper, valueMapper, mergeFunction, mapSupplier),
                 m -> m.entrySet().stream().map(e -> Tuple.of(e.getKey(), e.getValue())));
     }
+
+    @SuppressWarnings("unchecked")
+    private static <I, R> Function<I, R> castingIdentity() {
+        return i -> (R) i;
+    }
+
+    /**
+     * Simple implementation class for {@code Collector}.
+     *
+     * @param <T> the type of elements to be collected
+     * @param <R> the type of the result
+     */
+    public static class CollectorImpl<T, A, R> implements Collector<T, A, R> {
+        private final Supplier<A> supplier;
+        private final BiConsumer<A, T> accumulator;
+        private final BinaryOperator<A> combiner;
+        private final Function<A, R> finisher;
+        private final Set<Characteristics> characteristics;
+
+        CollectorImpl(Supplier<A> supplier,
+                      BiConsumer<A, T> accumulator,
+                      BinaryOperator<A> combiner,
+                      Function<A, R> finisher,
+                      Set<Characteristics> characteristics) {
+            this.supplier = supplier;
+            this.accumulator = accumulator;
+            this.combiner = combiner;
+            this.finisher = finisher;
+            this.characteristics = characteristics;
+        }
+
+        public CollectorImpl(Supplier<A> supplier,
+                             BiConsumer<A, T> accumulator,
+                             BinaryOperator<A> combiner,
+                             Set<Characteristics> characteristics) {
+            this(supplier, accumulator, combiner, castingIdentity(), characteristics);
+        }
+
+        @Override
+        public BiConsumer<A, T> accumulator() {
+            return accumulator;
+        }
+
+        @Override
+        public Supplier<A> supplier() {
+            return supplier;
+        }
+
+        @Override
+        public BinaryOperator<A> combiner() {
+            return combiner;
+        }
+
+        @Override
+        public Function<A, R> finisher() {
+            return finisher;
+        }
+
+        @Override
+        public Set<Characteristics> characteristics() {
+            return characteristics;
+        }
+    }
+
+
+    public static <T, A, R>
+    Collector<T, ?, R> filtering(Predicate<? super T> predicate,
+                                 Collector<? super T, A, R> downstream) {
+        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
+        return Collector.of(downstream.supplier(),
+                (r, t) -> {
+                    if (predicate.test(t)) {
+                        downstreamAccumulator.accept(r, t);
+                    }
+                },
+                downstream.combiner(), downstream.finisher(),
+                downstream.characteristics().toArray(new Collector.Characteristics[0]));
+    }
+
+    public static <T, U, A, R>
+    Collector<T, ?, R> flatMapping(Function<? super T, ? extends Stream<? extends U>> mapper,
+                                   Collector<? super U, A, R> downstream) {
+        BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();
+        return Collector.of(downstream.supplier(),
+                (r, t) -> {
+                    try (Stream<? extends U> result = mapper.apply(t)) {
+                        if (result != null)
+                            result.sequential().forEach(u -> downstreamAccumulator.accept(r, u));
+                    }
+                },
+                downstream.combiner(), downstream.finisher(),
+                downstream.characteristics().toArray(new Collector.Characteristics[0]));
+    }
+
+    public static <T> Collector<T, ?, BigDecimal> summingBigDecimal(Function<? super T, BigDecimal> mapper) {
+        return new CollectorImpl<>(
+                () -> new BigDecimal[]{BigDecimal.ZERO},
+                (a, t) -> a[0] = a[0].add(mapper.apply(t)),
+                (a, b) -> {
+                    a[0] = a[0].add(b[0]);
+                    return a;
+                },
+                a -> a[0], CH_NOID);
+    }
+
+
+    public static <T> Collector<T, ?, BigDecimal> averagingBigDecimal(Function<? super T, BigDecimal> mapper, int scale, RoundingMode roundingMode) {
+        return new CollectorImpl<>(
+                () -> new BigDecimal[]{BigDecimal.ZERO, BigDecimal.ZERO},
+                (a, t) -> {
+                    a[0] = a[0].add(mapper.apply(t));
+                    a[1] = a[1].add(BigDecimal.ONE);
+                },
+                (a, b) -> {
+                    a[0] = a[0].add(b[0]);
+                    a[1] = a[1].add(b[1]);
+                    return a;
+                },
+                a -> (a[1].compareTo(BigDecimal.ZERO) == 0) ? BigDecimal.ZERO.setScale(scale, roundingMode) : a[0].divide(a[1], scale, roundingMode),
+                CH_NOID);
+    }
+
+
 }

src/main/java/com/github/lokic/javaplus/Predicates.java

@@ -1,9 +1,14 @@
 package com.github.lokic.javaplus;
 
 import java.util.Set;
+import java.util.Spliterator;
+import java.util.Spliterators;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 public class Predicates {
 
@@ -17,4 +22,67 @@ public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor
         return object -> seen.add(keyExtractor.apply(object));
     }
 
+    /**
+     * 获取数据，直到{@code predicate}为false
+     * <p>
+     * stream : "1", "2", "3", "", "5", "6"
+     * predicate: isNotEmpty
+     * result:  "1", "2", "3"
+     *
+     * @param stream
+     * @param predicate
+     * @param <T>
+     * @return
+     */
+    public static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> predicate) {
+        Spliterator<T> spliterator = stream.spliterator();
+        return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(spliterator.estimateSize(), 0) {
+            private boolean stillGoing = true;
+
+            @Override
+            public boolean tryAdvance(Consumer<? super T> action) {
+                boolean hasNext = spliterator.tryAdvance(item -> {
+                    if (predicate.test(item)) {
+                        action.accept(item);
+                    } else {
+                        stillGoing = false;
+                    }
+                });
+                return hasNext && stillGoing;
+            }
+        }, false);
+    }
+
+    /**
+     * 抛弃数据，直到{@code predicate}为false
+     * <p>
+     * stream : "1", "2", "3", "", "5", "6"
+     * predicate: isNotEmpty
+     * result:  "", "5", "6"
+     *
+     * @param stream
+     * @param predicate
+     * @param <T>
+     * @return
+     */
+    public static <T> Stream<T> dropWhile(Stream<T> stream, Predicate<? super T> predicate) {
+        Spliterator<T> spliterator = stream.spliterator();
+        return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(spliterator.estimateSize(), 0) {
+            private boolean canGo = false;
+
+            @Override
+            public boolean tryAdvance(Consumer<? super T> action) {
+                return spliterator.tryAdvance(item -> {
+                    if (!canGo) {
+                        if (!predicate.test(item)) {
+                            action.accept(item);
+                            canGo = true;
+                        }
+                    } else {
+                        action.accept(item);
+                    }
+                });
+            }
+        }, false);
+    }
 }

src/main/java/com/github/lokic/javaplus/TupleCollectors.java

@@ -0,0 +1,80 @@
+package com.github.lokic.javaplus;
+
+import com.github.lokic.javaplus.tuple.*;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collector;
+
+import static com.github.lokic.javaplus.OtherCollectors.filtering;
+
+public class TupleCollectors {
+
+    public static <T1, T2>
+    Collector<Tuple2<T1, T2>, ?, Map<T1, List<T2>>> groupingBy1() {
+        return java.util.stream.Collectors.groupingBy(
+                Tuple2::getT1,
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple2::getT2, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3>
+    Collector<Tuple3<T1, T2, T3>, ?, Map<Tuple2<T1, T2>, List<T3>>> groupingBy2() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple3::getT3, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3, T4>
+    Collector<Tuple4<T1, T2, T3, T4>, ?, Map<Tuple3<T1, T2, T3>, List<T4>>> groupingBy3() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2(), t.getT3()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple4::getT4, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3, T4, T5>
+    Collector<Tuple5<T1, T2, T3, T4, T5>, ?, Map<Tuple4<T1, T2, T3, T4>, List<T5>>> groupingBy4() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2(), t.getT3(), t.getT4()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple5::getT5, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3, T4, T5, T6>
+    Collector<Tuple6<T1, T2, T3, T4, T5, T6>, ?, Map<Tuple5<T1, T2, T3, T4, T5>, List<T6>>> groupingBy5() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2(), t.getT3(), t.getT4(), t.getT5()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple6::getT6, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7>
+    Collector<Tuple7<T1, T2, T3, T4, T5, T6, T7>, ?, Map<Tuple6<T1, T2, T3, T4, T5, T6>, List<T7>>> groupingBy6() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2(), t.getT3(), t.getT4(), t.getT5(), t.getT6()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple7::getT7, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, T8>
+    Collector<Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>, ?, Map<Tuple7<T1, T2, T3, T4, T5, T6, T7>, List<T8>>> groupingBy7() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2(), t.getT3(), t.getT4(), t.getT5(), t.getT6(), t.getT7()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple8::getT8, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9>
+    Collector<Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>, ?, Map<Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>, List<T9>>> groupingBy8() {
+        return java.util.stream.Collectors.groupingBy(
+                t -> Tuple.of(t.getT1(), t.getT2(), t.getT3(), t.getT4(), t.getT5(), t.getT6(), t.getT7(), t.getT8()),
+                LinkedHashMap::new,
+                java.util.stream.Collectors.mapping(Tuple9::getT9, filtering(Objects::nonNull, java.util.stream.Collectors.toList())));
+    }
+
+
+}