java.util.Spliterator# OfLong ( ) 源码实例Demo

@Override
default Node.OfLong truncate(long from, long to, IntFunction<Long[]> generator) {
    if (from == 0 && to == count())
        return this;
    long size = to - from;
    Spliterator.OfLong spliterator = spliterator();
    Node.Builder.OfLong nodeBuilder = Nodes.longBuilder(size);
    nodeBuilder.begin(size);
    for (int i = 0; i < from && spliterator.tryAdvance((LongConsumer) e -> { }); i++) { }
    for (int i = 0; (i < size) && spliterator.tryAdvance((LongConsumer) nodeBuilder); i++) { }
    nodeBuilder.end();
    return nodeBuilder.build();
}
 

/**
 * Adapt a {@code Spliterator<Long>} to a {@code Spliterator.OfLong}.
 *
 * @implNote
 * The implementation attempts to cast to a Spliterator.OfLong, and throws
 * an exception if this cast is not possible.
 */
private static Spliterator.OfLong adapt(Spliterator<Long> s) {
    if (s instanceof Spliterator.OfLong) {
        return (Spliterator.OfLong) s;
    } else {
        if (Tripwire.ENABLED)
            Tripwire.trip(AbstractPipeline.class,
                          "using LongStream.adapt(Spliterator<Long> s)");
        throw new UnsupportedOperationException("LongStream.adapt(Spliterator<Long> s)");
    }
}
 

protected LongTestData(String name,
                       I state,
                       Function<I, LongStream> streamFn,
                       Function<I, LongStream> parStreamFn,
                       Function<I, Spliterator.OfLong> splitrFn,
                       ToIntFunction<I> sizeFn) {
    super(name, StreamShape.LONG_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

void add(String description, List<Long> expected, Supplier<Spliterator.OfLong> s) {
    description = joiner(description).toString();
    data.add(new Object[]{description, expected, s});
}
 

@Override
public Spliterator.OfLong spliterator() {
    return new InternalNodeSpliterator.OfLong(this);
}
 

@Override
final void forEachWithCancel(Spliterator<Long> spliterator, Sink<Long> sink) {
    Spliterator.OfLong spl = adapt(spliterator);
    LongConsumer adaptedSink =  adapt(sink);
    do { } while (!sink.cancellationRequested() && spl.tryAdvance(adaptedSink));
}
 

void add(String description, Supplier<Spliterator.OfLong> s) {
    add(description, exp, s);
}
 

OfLong(Spliterator.OfLong s, long sliceOrigin, long sliceFence) {
    super(s, sliceOrigin, sliceFence);
}
 

@Override
public Spliterator.OfLong spliterator() {
    assert !building : "during building";
    return super.spliterator();
}
 

@Test(dataProvider = "Spliterator.OfLong")
public void testLongSplitAfterFullTraversal(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
    testSplitAfterFullTraversal(s, longBoxingConsumer());
}
 

@Override
public void forEachRemaining(Consumer<? super Long> consumer) {
    Spliterator.OfLong.super.forEachRemaining(consumer);
}
 

public static void testLongSpliterator(Supplier<Spliterator.OfLong> supplier) {
    testLongSpliterator(supplier, defaultContentAsserter());
}
 

OfLong(Spliterator.OfLong s, long skip, long limit) {
    super(s, skip, limit);
}
 

@Override
@SuppressWarnings("unchecked")
final Spliterator.OfLong lazySpliterator(Supplier<? extends Spliterator<Long>> supplier) {
    return new StreamSpliterators.DelegatingSpliterator.OfLong((Supplier<Spliterator.OfLong>) supplier);
}
 

@Override
public Spliterator.OfLong trySplit() {
    if (estimate == 0)
        return null;
    return new InfiniteSupplyingSpliterator.OfLong(estimate = estimate >>> 1, s);
}
 

@Override
public Spliterator.OfLong spliterator() {
    return DesugarArrays.spliterator(array, 0, curSize);
}
 

@Override
protected Spliterator.OfLong makeSpliterator(Spliterator.OfLong s,
                                             long sliceOrigin, long sliceFence,
                                             long origin, long fence) {
    return new SliceSpliterator.OfLong(s, sliceOrigin, sliceFence, origin, fence);
}
 

@Override
public Spliterator.OfLong spliterator() {
    assert !building : "during building";
    return super.spliterator();
}
 

@Override
public Spliterator.OfLong spliterator() {
    return Arrays.spliterator(array, 0, curSize);
}
 

/**
 * Creates a new sequential or parallel {@code LongStream} from a
 * {@code Spliterator.OfLong}.
 *
 * <p>The spliterator is only traversed, split, or queried for estimated
 * size after the terminal operation of the stream pipeline commences.
 *
 * <p>It is strongly recommended the spliterator report a characteristic of
 * {@code IMMUTABLE} or {@code CONCURRENT}, or be
 * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
 * {@link #longStream(java.util.function.Supplier, int, boolean)} should be
 * used to reduce the scope of potential interference with the source.  See
 * <a href="package-summary.html#NonInterference">Non-Interference</a> for
 * more details.
 *
 * @param spliterator a {@code Spliterator.OfLong} describing the stream elements
 * @param parallel if {@code true} then the returned stream is a parallel
 *        stream; if {@code false} the returned stream is a sequential
 *        stream.
 * @return a new sequential or parallel {@code LongStream}
 */
public static LongStream longStream(Spliterator.OfLong spliterator,
                                    boolean parallel) {
    return new LongPipeline.Head<>(spliterator,
                                   StreamOpFlag.fromCharacteristics(spliterator),
                                   parallel);
}