util/stream/Stream.java

53  * {@link Stream} and {@link IntStream}:
68  * <p>In addition to {@code Stream}, which is a stream of object references,
78  * stream into another stream, such as {@link Stream#filter(Predicate)}), and a
80  * as {@link Stream#count()} or {@link Stream#forEach(Consumer)}).
150  * <p>Stream pipelines may execute either sequentially or in
167 public interface Stream<T> extends BaseStream<T, Stream<T>> {
182     Stream<T> filter(Predicate<? super T> predicate);
197     <R> Stream<R> map(Function<? super T, ? extends R> mapper);
269      *     Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8);
270      *     Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +")));
283     <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
372     Stream<T> distinct();
388     Stream<T> sorted();
405     Stream<T> sorted(Comparator<? super T> comparator);
423      *     Stream.of("one", "two", "three", "four")
441     Stream<T> peek(Consumer<? super T> action);
468     Stream<T> limit(long maxSize);
497     Stream<T> skip(long n);
555     default Stream<T> takeWhile(Predicate<? super T> predicate) {
621     default Stream<T> dropWhile(Predicate<? super T> predicate) {
1132      * Returns a builder for a {@code Stream}.
1142      * Returns an empty sequential {@code Stream}.
1147     public static<T> Stream<T> empty() {
1152      * Returns a sequential {@code Stream} containing a single element.
1158     public static<T> Stream<T> of(T t) {
1163      * Returns a sequential {@code Stream} containing a single element, if
1164      * non-null, otherwise returns an empty {@code Stream}.
1172     public static<T> Stream<T> ofNullable(T t) {
1173         return t == null ? Stream.empty()
1186     public static<T> Stream<T> of(T... values) {
1191      * Returns an infinite sequential ordered {@code Stream} produced by iterative
1193      * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
1196      * <p>The first element (position {@code 0}) in the {@code Stream} will be
1211      * @return a new sequential {@code Stream}
1213     public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
1238      * Returns a sequential ordered {@code Stream} produced by iterative
1243      * <p>{@code Stream.iterate} should produce the same sequence of elements as
1272      * @return a new sequential {@code Stream}
1275     public static<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
1328      * @return a new infinite sequential unordered {@code Stream}
1330     public static<T> Stream<T> generate(Supplier<? extends T> s) {
1357     public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
1364         Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
1369      * A mutable builder for a {@code Stream}.  This allows the creation of a
1370      * {@code Stream} by generating elements individually and adding them to the
1378      * {@code Stream} whose elements are the elements that were added to the stream
1382      * @see Stream#builder()
1425         Stream<T> build();