com.landawn.abacus.util.stream.Stream Maven / Gradle / Ivy

     * 
     * Stream.of("a", "ab", "ac", "b", "c", "cb").rangeMap((a, b) -> b.startsWith(a), (a, b) -> a + "->" + b).toList(); // a->ac, b->b, c->cb
     * 
     * 

* This is a quasi-intermediate * partial reduction operation. * * @param the type of the resulting elements * @param sameRange a non-interfering, stateless predicate to apply to * the leftmost and next elements which returns true for elements * which belong to the same range. * @param mapper a non-interfering, stateless function to apply to the * range borders and produce the resulting element. If value was * not merged to the interval, then mapper will receive the same * value twice, otherwise it will receive the leftmost and the * rightmost values which were merged to the range. * @return the new stream * @see #collapse(BiPredicate, BinaryOperator) */ @SequentialOnly public abstract Stream rangeMap(final BiPredicate sameRange, final BiFunction mapper); @ParallelSupported public abstract Stream mapFirst(Function mapperForFirst); @ParallelSupported public abstract Stream mapFirstOrElse(Function mapperForFirst, Function mapperForElse); @ParallelSupported public abstract Stream mapLast(Function mapperForLast); @ParallelSupported public abstract Stream mapLastOrElse(Function mapperForLast, Function mapperForElse); @ParallelSupported public abstract CharStream mapToChar(ToCharFunction mapper); @ParallelSupported public abstract ByteStream mapToByte(ToByteFunction mapper); @ParallelSupported public abstract ShortStream mapToShort(ToShortFunction mapper); @ParallelSupported public abstract IntStream mapToInt(ToIntFunction mapper); @ParallelSupported public abstract LongStream mapToLong(ToLongFunction mapper); @ParallelSupported public abstract FloatStream mapToFloat(ToFloatFunction mapper); @ParallelSupported public abstract DoubleStream mapToDouble(ToDoubleFunction mapper); // public abstract EntryStream mapToEntry(); @ParallelSupported public abstract EntryStream mapToEntry(Function> mapper); @ParallelSupported public abstract EntryStream mapToEntry(Function keyMapper, Function valueMapper); // public abstract Stream mapp(Function> mapper); @ParallelSupported public abstract Stream flatMap(Function> mapper); @ParallelSupported public abstract Stream flattMap(Function> mapper); @ParallelSupported public abstract Stream flatMapp(Function mapper); @ParallelSupported public abstract CharStream flatMapToChar(Function mapper); @ParallelSupported public abstract CharStream flattMapToChar(Function mapper); @ParallelSupported public abstract ByteStream flatMapToByte(Function mapper); @ParallelSupported public abstract ByteStream flattMapToByte(Function mapper); @ParallelSupported public abstract ShortStream flatMapToShort(Function mapper); @ParallelSupported public abstract ShortStream flattMapToShort(Function mapper); @ParallelSupported public abstract IntStream flatMapToInt(Function mapper); @ParallelSupported public abstract IntStream flattMapToInt(Function mapper); @ParallelSupported public abstract LongStream flatMapToLong(Function mapper); @ParallelSupported public abstract LongStream flattMapToLong(Function mapper); @ParallelSupported public abstract FloatStream flatMapToFloat(Function mapper); @ParallelSupported public abstract FloatStream flattMapToFloat(Function mapper); @ParallelSupported public abstract DoubleStream flatMapToDouble(Function mapper); @ParallelSupported public abstract DoubleStream flattMapToDouble(Function mapper); @ParallelSupported public abstract EntryStream flatMapToEntry(Function>> mapper); @ParallelSupported public abstract EntryStream flattMapToEntry(Function> mapper); @ParallelSupported public abstract EntryStream flatMappToEntry(Function> mapper); @ParallelSupported public abstract Stream>> groupBy(final Function classifier); @ParallelSupported public abstract Stream>> groupBy(final Function classifier, final Supplier>> mapFactory); /** * * @param classifier * @param valueMapper * @return * @see Collectors#toMultimap(Function, Function) */ @ParallelSupported public abstract Stream>> groupBy(Function classifier, Function valueMapper); /** * * @param classifier * @param valueMapper * @param mapFactory * @return * @see Collectors#toMultimap(Function, Function, Supplier) */ @ParallelSupported public abstract Stream>> groupBy(Function classifier, Function valueMapper, Supplier>> mapFactory); @ParallelSupported public abstract Stream> groupBy(final Function classifier, final Collector downstream); @ParallelSupported public abstract Stream> groupBy(final Function classifier, final Collector downstream, final Supplier> mapFactory); @ParallelSupported public abstract Stream> groupBy(final Function classifier, final Function valueMapper, final Collector downstream); @ParallelSupported public abstract Stream> groupBy(final Function classifier, final Function valueMapper, final Collector downstream, final Supplier> mapFactory); @ParallelSupported public abstract Stream> groupBy(final Function classifier, final Function valueMapper, BinaryOperator mergeFunction); @ParallelSupported public abstract Stream> groupBy(final Function classifier, final Function valueMapper, final BinaryOperator mergeFunction, final Supplier> mapFactory); /** * * @param predicate * @return * @see Collectors#partitioningBy(Predicate) */ @ParallelSupported public abstract Stream>> partitionBy(final Predicate predicate); /** * * @param predicate * @param downstream * @return * @see Collectors#partitioningBy(Predicate, Collector) */ @ParallelSupported public abstract Stream> partitionBy(final Predicate predicate, final Collector downstream); @ParallelSupported public Stream> countBy(final Function classifier) { return groupBy(classifier, Collectors.countingInt()); } @ParallelSupported public abstract EntryStream> groupByToEntry(final Function classifier); @ParallelSupported public abstract EntryStream> groupByToEntry(final Function classifier, final Supplier>> mapFactory); /** * * @param classifier * @param valueMapper * @return * @see Collectors#toMultimap(Function, Function) */ @ParallelSupported public abstract EntryStream> groupByToEntry(Function classifier, Function valueMapper); /** * * @param classifier * @param valueMapper * @param mapFactory * @return * @see Collectors#toMultimap(Function, Function, Supplier) */ @ParallelSupported public abstract EntryStream> groupByToEntry(Function classifier, Function valueMapper, Supplier>> mapFactory); @ParallelSupported public abstract EntryStream groupByToEntry(final Function classifier, final Collector downstream); @ParallelSupported public abstract EntryStream groupByToEntry(final Function classifier, final Collector downstream, final Supplier> mapFactory); @ParallelSupported public abstract EntryStream groupByToEntry(final Function classifier, final Function valueMapper, final Collector downstream); @ParallelSupported public abstract EntryStream groupByToEntry(final Function classifier, final Function valueMapper, final Collector downstream, final Supplier> mapFactory); @ParallelSupported public abstract EntryStream groupByToEntry(final Function classifier, final Function valueMapper, BinaryOperator mergeFunction); @ParallelSupported public abstract EntryStream groupByToEntry(final Function classifier, final Function valueMapper, final BinaryOperator mergeFunction, final Supplier> mapFactory); /** * * @param predicate * @return * @see Collectors#partitioningBy(Predicate) */ @ParallelSupported public abstract EntryStream> partitionByToEntry(final Predicate predicate); /** * * @param predicate * @param downstream * @return * @see Collectors#partitioningBy(Predicate, Collector) */ @ParallelSupported public abstract EntryStream partitionByToEntry(final Predicate predicate, final Collector downstream); @ParallelSupported public EntryStream countByToEntry(final Function classifier) { return groupByToEntry(classifier, Collectors.countingInt()); } @SequentialOnly public abstract Stream> collapse(final BiPredicate collapsible); @SequentialOnly public abstract > Stream collapse(final BiPredicate collapsible, Supplier supplier); /** * Merge series of adjacent elements which satisfy the given predicate using * the merger function and return a new stream. * *

Example: *

     * 
     * Stream.of(new Integer[0]).collapse((a, b) -> a < b, (a, b) -> a + b) => []
     * Stream.of(1).collapse((a, b) -> a < b, (a, b) -> a + b) => [1]
     * Stream.of(1, 2).collapse((a, b) -> a < b, (a, b) -> a + b) => [3]
     * Stream.of(1, 2, 3).collapse((a, b) -> a < b, (a, b) -> a + b) => [6]
     * Stream.of(1, 2, 3, 3, 2, 1).collapse((a, b) -> a < b, (a, b) -> a + b) => [6, 3, 2, 1]
     * 
     * 

     * 
     * Stream.of(new Integer[0]).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => []
     * Stream.of(1).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [1]
     * Stream.of(1, 2).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [3]
     * Stream.of(1, 2, 3).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [6]
     * Stream.of(1, 2, 3, 3, 2, 1).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [6, 3, 2, 1]
     * 
     * 

     * 
     * Stream.of(new Integer[0]).scan((a, b) -> a + b) => []
     * Stream.of(1).scan((a, b) -> a + b) => [1]
     * Stream.of(1, 2).scan((a, b) -> a + b) => [1, 3]
     * Stream.of(1, 2, 3).scan((a, b) -> a + b) => [1, 3, 6]
     * Stream.of(1, 2, 3, 3, 2, 1).scan((a, b) -> a + b) => [1, 3, 6, 9, 11, 12]
     * 
     * 

     * 
     * Stream.of(new Integer[0]).scan(10, (a, b) -> a + b) => []
     * Stream.of(1).scan(10, (a, b) -> a + b) => [11]
     * Stream.of(1, 2).scan(10, (a, b) -> a + b) => [11, 13]
     * Stream.of(1, 2, 3).scan(10, (a, b) -> a + b) => [11, 13, 16]
     * Stream.of(1, 2, 3, 3, 2, 1).scan(10, (a, b) -> a + b) => [11, 13, 16, 19, 21, 22]
     * 
     * 

     * 
     * Stream.of(1, 2, 3).combinations().forEach(Fn.println());
     * // output
     * []
     * [1]
     * [2]
     * [3]
     * [1, 2]
     * [1, 3]
     * [2, 3]
     * [1, 2, 3]
     * 
     * 

     * 
     * Stream.of(1, 2, 3).combinations(2).forEach(Fn.println());
     * // output
     * [1, 2]
     * [1, 3]
     * [2, 3]
     * 
     * 

     * 
     * Stream.of(1, 2, 3).combinations(2, true).forEach(Fn.println());
     * // output
     * [1, 1]
     * [1, 2]
     * [1, 3]
     * [2, 1]
     * [2, 2]
     * [2, 3]
     * [3, 1]
     * [3, 2]
     * [3, 3]
     * 
     * 

     * 
     * Stream.of(1, 2, 3).permutations().forEach(Fn.println());
     * // output
     * [1, 2, 3]
     * [1, 3, 2]
     * [3, 1, 2]
     * [3, 2, 1]
     * [2, 3, 1]
     * [2, 1, 3]
     * 
     * 

     * 
     * Stream.of(1, 2, 3).orderedPermutations().forEach(Fn.println());
     * // output
     * [1, 2, 3]
     * [1, 3, 2]
     * [2, 1, 3]
     * [2, 3, 1]
     * [3, 1, 2]
     * [3, 2, 1]
     * 
     *