Java Spliterator.OfInt方法代码示例

import java.util.Spliterator; //导入方法依赖的package包/类
@Override
final boolean forEachWithCancel(Spliterator<Integer> spliterator, Sink<Integer> sink) {
    Spliterator.OfInt spl = adapt(spliterator);
    IntConsumer adaptedSink = adapt(sink);
    boolean cancelled;
    do { } while (!(cancelled = sink.cancellationRequested()) && spl.tryAdvance(adaptedSink));
    return cancelled;
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
OfInt(Spliterator.OfInt s, long skip, long limit) {
    super(s, skip, limit);
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Override
Spliterator.OfInt makeSpliterator(Spliterator.OfInt s) {
    return new Dropping(s, this);
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Test(dataProvider = "Spliterator.OfInt")
public void testIntSplitUntilNull(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testSplitUntilNull(exp, s, intBoxingConsumer());
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
private OfInt(Spliterator.OfInt sp, boolean proxyEstimateSize) {
    super(sp, proxyEstimateSize);
    this.psp = sp;
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Override
Spliterator.OfInt spliterator();
 

import java.util.Spliterator; //导入方法依赖的package包/类
OfInt(Spliterator.OfInt s, UnorderedWhileSpliterator.OfInt parent) {
    super(s, parent);
    this.p = parent.p;
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Test(dataProvider = "Spliterator.OfInt")
public void testIntSplitAfterFullTraversal(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testSplitAfterFullTraversal(s, intBoxingConsumer());
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
void add(String description, Supplier<Spliterator.OfInt> s) {
    add(description, exp, s);
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Test(dataProvider = "Spliterator.OfInt")
public void testIntForEach(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testForEach(exp, s, intBoxingConsumer());
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Override
protected Spliterator.OfInt makeSpliterator(Spliterator.OfInt s,
                                            long sliceOrigin, long sliceFence,
                                            long origin, long fence) {
    return new SliceSpliterator.OfInt(s, sliceOrigin, sliceFence, origin, fence);
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
@Test(dataProvider = "Spliterator.OfInt")
public void testIntMixedTraverseAndSplit(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testMixedTraverseAndSplit(exp, s, intBoxingConsumer());
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
Dropping(Spliterator.OfInt s, boolean noSplitting, IntPredicate p) {
    super(s, noSplitting, p);
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
/**
 * Creates a lazily concatenated stream whose elements are all the
 * elements of the first stream followed by all the elements of the
 * second stream.  The resulting stream is ordered if both
 * of the input streams are ordered, and parallel if either of the input
 * streams is parallel.  When the resulting stream is closed, the close
 * handlers for both input streams are invoked.
 *
 * @implNote
 * Use caution when constructing streams from repeated concatenation.
 * Accessing an element of a deeply concatenated stream can result in deep
 * call chains, or even {@code StackOverflowException}.
 *
 * @param a the first stream
 * @param b the second stream
 * @return the concatenation of the two input streams
 */
public static IntStream concat(IntStream a, IntStream b) {
    Objects.requireNonNull(a);
    Objects.requireNonNull(b);

    Spliterator.OfInt split = new Streams.ConcatSpliterator.OfInt(
            a.spliterator(), b.spliterator());
    IntStream stream = StreamSupport.intStream(split, a.isParallel() || b.isParallel());
    return stream.onClose(Streams.composedClose(a, b));
}
 

import java.util.Spliterator; //导入方法依赖的package包/类
/**
 * Creates a new sequential or parallel {@code IntStream} from a
 * {@code Supplier} of {@code Spliterator.OfInt}.
 *
 * <p>The {@link Supplier#get()} method will be invoked on the supplier no
 * more than once, and only after the terminal operation of the stream pipeline
 * commences.
 *
 * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
 * or {@code CONCURRENT}, or that are
 * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
 * more efficient to use {@link #intStream(java.util.Spliterator.OfInt, boolean)}
 * instead.
 * <p>The use of a {@code Supplier} in this form provides a level of
 * indirection that reduces the scope of potential interference with the
 * source.  Since the supplier is only invoked after the terminal operation
 * commences, any modifications to the source up to the start of the
 * terminal operation are reflected in the stream result.  See
 * <a href="package-summary.html#NonInterference">Non-Interference</a> for
 * more details.
 *
 * @param supplier a {@code Supplier} of a {@code Spliterator.OfInt}
 * @param characteristics Spliterator characteristics of the supplied
 *        {@code Spliterator.OfInt}.  The characteristics must be equal to
 *        {@code supplier.get().characteristics()}, otherwise undefined
 *        behavior may occur when terminal operation commences.
 * @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 IntStream}
 * @see #intStream(java.util.Spliterator.OfInt, boolean)
 */
public static IntStream intStream(Supplier<? extends Spliterator.OfInt> supplier,
                                  int characteristics,
                                  boolean parallel) {
    return new IntPipeline.Head<>(supplier,
                                  StreamOpFlag.fromCharacteristics(characteristics),
                                  parallel);
}