java.util.Spliterator# ORDERED 源码实例Demo

/**
 * Returns an infinite sequential ordered {@code DoubleStream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code DoubleStream}
 * will be the provided {@code seed}.  For {@code n > 0}, the element at
 * position {@code n}, will be the result of applying the function {@code f}
 *  to the element at position {@code n - 1}.
 *
 * <p>The action of applying {@code f} for one element
 * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>
 * the action of applying {@code f} for subsequent elements.  For any given
 * element the action may be performed in whatever thread the library
 * chooses.
 *
 * @param seed the initial element
 * @param f a function to be applied to the previous element to produce
 *          a new element
 * @return a new sequential {@code DoubleStream}
 */
public static DoubleStream iterate(final double seed, final DoubleUnaryOperator f) {
    Objects.requireNonNull(f);
    Spliterator.OfDouble spliterator = new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE,
           Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL) {
        double prev;
        boolean started;

        @Override
        public boolean tryAdvance(DoubleConsumer action) {
            Objects.requireNonNull(action);
            double t;
            if (started)
                t = f.applyAsDouble(prev);
            else {
                t = seed;
                started = true;
            }
            action.accept(prev = t);
            return true;
        }
    };
    return StreamSupport.doubleStream(spliterator, false);
}
 

public static OfInt ofNode(String name, Node.OfInt node) {
    int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
    return new AbstractTestData.IntTestData<>(name, node,
                                              n -> StreamSupport.intStream(n::spliterator, characteristics, false),
                                              n -> StreamSupport.intStream(n::spliterator, characteristics, true),
                                              Node.OfInt::spliterator,
                                              n -> (int) n.count());
}
 

public static OfInt ofNode(String name, Node.OfInt node) {
    int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
    return new AbstractTestData.IntTestData<>(name, node,
                                              n -> StreamSupport.intStream(n::spliterator, characteristics, false),
                                              n -> StreamSupport.intStream(n::spliterator, characteristics, true),
                                              Node.OfInt::spliterator,
                                              n -> (int) n.count());
}
 

EntrySpliterator(int index, int fence, IntFunction<T> gen) {
    super((long)fence,
          Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.IMMUTABLE |
          Spliterator.NONNULL);
    this.index = index;
    this.fence = fence;
    this.gen = gen;
}
 

public static OfInt ofNode(String name, Node.OfInt node) {
    int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
    return new AbstractTestData.IntTestData<>(name, node,
                                              n -> StreamSupport.intStream(n::spliterator, characteristics, false),
                                              n -> StreamSupport.intStream(n::spliterator, characteristics, true),
                                              Node.OfInt::spliterator,
                                              n -> (int) n.count());
}
 

CharsSpliterator(byte[] array, int origin, int fence, int acs) {
    this.array = array;
    this.index = origin;
    this.fence = fence;
    this.cs = acs | Spliterator.ORDERED | Spliterator.SIZED
              | Spliterator.SUBSIZED;
}
 

public int characteristics() {
    return Spliterator.DISTINCT | Spliterator.SORTED |
        Spliterator.ORDERED | Spliterator.CONCURRENT |
        Spliterator.NONNULL;
}
 

public final int characteristics() {
    return s.characteristics() &
           ~(Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED);
}
 

@Override
public int characteristics() {
    return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED |
           Spliterator.IMMUTABLE | Spliterator.NONNULL |
           Spliterator.DISTINCT | Spliterator.SORTED;
}
 

public int characteristics() {
    return (Spliterator.ORDERED |
            Spliterator.NONNULL |
            Spliterator.CONCURRENT);
}
 

public int characteristics() {
    return Spliterator.DISTINCT | Spliterator.ORDERED |
        Spliterator.SORTED;
}
 

public int characteristics() {
    return Spliterator.ORDERED | Spliterator.NONNULL |
        Spliterator.CONCURRENT;
}
 

CodePointsSpliterator(byte[] array, int origin, int fence, int acs) {
    this.array = array;
    this.index = origin;
    this.fence = fence;
    this.cs = acs | Spliterator.ORDERED;
}
 

public final int characteristics() {
    return s.characteristics() &
           ~(Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED);
}
 

public int characteristics() {
    return Spliterator.ORDERED | Spliterator.NONNULL |
        Spliterator.CONCURRENT;
}
 

public int characteristics() {
    return Spliterator.ORDERED | Spliterator.NONNULL |
        Spliterator.CONCURRENT;
}
 

public int characteristics() {
    return (Spliterator.ORDERED |
            Spliterator.NONNULL |
            Spliterator.CONCURRENT);
}
 

public int characteristics() {
    return Spliterator.ORDERED | Spliterator.NONNULL |
        Spliterator.CONCURRENT;
}
 

@Override
public int characteristics() {
    return (s.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED |
                                    Spliterator.SORTED | Spliterator.ORDERED))
           | Spliterator.DISTINCT;
}
 

public int characteristics() {
    return (Spliterator.ORDERED |
            Spliterator.NONNULL |
            Spliterator.CONCURRENT);
}