Java 类java.util.function.IntConsumer 实例源码

@Override
public boolean tryAdvance(IntConsumer action) {
    boolean test = true;
    if (takeOrDrop &&               // If can take
        checkCancelOnCount() && // and if not cancelled
        s.tryAdvance(this) &&   // and if advanced one element
        (test = p.test(t))) {   // and test on element passes
        action.accept(t);           // then accept element
        return true;
    }
    else {
        // Taking is finished
        takeOrDrop = false;
        // Cancel all further traversal and splitting operations
        // only if test of element failed (short-circuited)
        if (!test)
            cancel.set(true);
        return false;
    }
}

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

public static Future<Void> list(GuildMessageReceivedEvent event, int timeoutSeconds, boolean canEveryoneUse, List<MessageEmbed> embeds, IntConsumer beforePageSent) {
    if(embeds.size() == 0) return null;
    AtomicInteger index = new AtomicInteger();
    Message m = event.getChannel().sendMessage(embeds.get(0)).complete();
    return ReactionOperations.create(m, timeoutSeconds, (e)->{
        if(!canEveryoneUse && e.getUser().getIdLong() != event.getAuthor().getIdLong()) return Operation.IGNORED;
        switch(e.getReactionEmote().getName()) {
            case "\u2b05": //left arrow
                if(index.get() == 0) break;
                m.editMessage(embeds.get(index.decrementAndGet())).queue();
                break;
            case "\u27a1": //right arrow
                if(index.get() + 1 >= embeds.size()) break;
                m.editMessage(embeds.get(index.incrementAndGet())).queue();
                break;
        }
        if(event.getGuild().getSelfMember().hasPermission(e.getTextChannel(), Permission.MESSAGE_MANAGE)) {
            e.getReaction().removeReaction(e.getUser()).queue();
        }
        return Operation.RESET_TIMEOUT;
    }, "\u2b05", "\u27a1");
}

@Override
public final IntStream peek(IntConsumer action) {
    Objects.requireNonNull(action);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    0) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void accept(int t) {
                    action.accept(t);
                    downstream.accept(t);
                }
            };
        }
    };
}

public void testIntForEachRemainingWithNull() {
    PrimitiveIterator.OfInt i = new PrimitiveIterator.OfInt() {
        @Override
        public int nextInt() {
            return 0;
        }

        @Override
        public boolean hasNext() {
            return false;
        }
    };

    executeAndCatch(() -> i.forEachRemaining((IntConsumer) null));
    executeAndCatch(() -> i.forEachRemaining((Consumer<Integer>) null));
}

/**
 * Returns an infinite sequential ordered {@code IntStream} 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 IntStream} 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 IntStream}
 */
public static IntStream iterate(final int seed, final IntUnaryOperator f) {
    Objects.requireNonNull(f);
    Spliterator.OfInt spliterator = new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE,
           Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL) {
        int prev;
        boolean started;

        @Override
        public boolean tryAdvance(IntConsumer action) {
            Objects.requireNonNull(action);
            int t;
            if (started)
                t = f.applyAsInt(prev);
            else {
                t = seed;
                started = true;
            }
            action.accept(prev = t);
            return true;
        }
    };
    return StreamSupport.intStream(spliterator, false);
}

@Override
public boolean tryAdvance(IntConsumer consumer) {
    Objects.requireNonNull(consumer);

    final int i = from;
    if (i < upTo) {
        from++;
        consumer.accept(i);
        return true;
    }
    else if (last > 0) {
        last = 0;
        consumer.accept(i);
        return true;
    }
    return false;
}

@Override
public void forEachRemaining(IntConsumer consumer) {
    Objects.requireNonNull(consumer);

    int i = from;
    final int hUpTo = upTo;
    int hLast = last;
    from = upTo;
    last = 0;
    while (i < hUpTo) {
        consumer.accept(i++);
    }
    if (hLast > 0) {
        // Last element of closed range
        consumer.accept(i);
    }
}

@Override
public final IntStream peek(IntConsumer action) {
    Objects.requireNonNull(action);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    0) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void accept(int t) {
                    action.accept(t);
                    downstream.accept(t);
                }
            };
        }
    };
}

@Override
public final IntStream peek(IntConsumer action) {
    Objects.requireNonNull(action);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    0) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void accept(int t) {
                    action.accept(t);
                    downstream.accept(t);
                }
            };
        }
    };
}

@Override
public boolean tryAdvance(IntConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
        return true;
    }
    else {
        return false;
    }
}

@Override
public boolean tryAdvance(IntConsumer action) {
    if (action == null)
        throw new NullPointerException();
    if (index >= 0 && index < limit) {
        action.accept(buffer.getUnchecked(index++));
        return true;
    }
    return false;
}

public boolean tryAdvance(IntConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(ThreadLocalRandom.current().internalNextInt(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}

@Override
public boolean tryAdvance(IntConsumer action) {
    if (action == null)
        throw new NullPointerException();
    int i = index;
    if (i >= 0 && i < fence) {
        action.accept(charAt(array, i));
        index++;
        return true;
    }
    return false;
}

@Override
public boolean tryAdvance(IntConsumer action) {
    if (action == null)
        throw new NullPointerException();
    if (index >= 0 && index < fence) {
        action.accept(array[index++] & 0xff);
        return true;
    }
    return false;
}

@Test
public void run() {
    Arrays.stream(arr).forEach(new IntConsumer() {
        @Override
        public void accept(int value) {
            System.out.println(value);
        }
    });
}

/**
 * 这里首先使用函数引用，直接定义了两个Int-Consumer接口实例，一个指向标准输出，另一个指向标准错误。
 * 使用接口默认函数IntConsumer.addThen()，将两个IntConsumer进行组合，得到一个新的IntConsumer，
 * 这个新的Int-Consumer会依次调用outprintln和errprintln，完成对数组中元素的处理。
 *
 * 这个新的IntConsumer会先调用第1个IntConsumer进行处理，接着调用第2个Int-Consumer处理，从而实现多个处理器的整合
 */
@Test
public void run3() {

    IntConsumer outprintln = System.out::println;
    IntConsumer errprintln = System.err::println;
    Arrays.stream(arr).forEach(outprintln.andThen(errprintln));
}

public static void main(String[] args) {
    Arrays.stream(arr).forEach(new IntConsumer() {
        @Override
        public void accept(int value) {
            System.out.println(value);
        }
    });
}

public boolean tryAdvance(IntConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(rng.internalNextInt(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}

@Override
public void forEachRemaining(IntConsumer action) {
    int[] a; int i, hi; // hoist accesses and checks from loop
    if (action == null)
        throw new NullPointerException();
    if ((a = array).length >= (hi = fence) &&
        (i = index) >= 0 && i < (index = hi)) {
        do { action.accept(a[i]); } while (++i < hi);
    }
}

@Override
public boolean tryAdvance(IntConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
        return true;
    }
    else {
        return false;
    }
}

/**
 * {@inheritDoc}
 * @implSpec
 * If the action is an instance of {@code IntConsumer} then it is cast
 * to {@code IntConsumer} and passed to
 * {@link #tryAdvance(java.util.function.IntConsumer)}; otherwise
 * the action is adapted to an instance of {@code IntConsumer}, by
 * boxing the argument of {@code IntConsumer}, and then passed to
 * {@link #tryAdvance(java.util.function.IntConsumer)}.
 */
@Override
default boolean tryAdvance(Consumer<? super Integer> action) {
    if (action instanceof IntConsumer) {
        return tryAdvance((IntConsumer) action);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(),
                          "{0} calling Spliterator.OfInt.tryAdvance((IntConsumer) action::accept)");
        return tryAdvance((IntConsumer) action::accept);
    }
}

/**
 * Creates an {@code PrimitiveIterator.OfInt} from a
 * {@code Spliterator.OfInt}.
 *
 * <p>Traversal of elements should be accomplished through the iterator.
 * The behaviour of traversal is undefined if the spliterator is operated
 * after the iterator is returned.
 *
 * @param spliterator The spliterator
 * @return An iterator
 * @throws NullPointerException if the given spliterator is {@code null}
 */
public static PrimitiveIterator.OfInt iterator(Spliterator.OfInt spliterator) {
    Objects.requireNonNull(spliterator);
    class Adapter implements PrimitiveIterator.OfInt, IntConsumer {
        boolean valueReady = false;
        int nextElement;

        @Override
        public void accept(int t) {
            valueReady = true;
            nextElement = t;
        }

        @Override
        public boolean hasNext() {
            if (!valueReady)
                spliterator.tryAdvance(this);
            return valueReady;
        }

        @Override
        public int nextInt() {
            if (!valueReady && !hasNext())
                throw new NoSuchElementException();
            else {
                valueReady = false;
                return nextElement;
            }
        }
    }

    return new Adapter();
}

@Override
public final IntStream flatMapToInt(Function<? super P_OUT, ? extends IntStream> mapper) {
    Objects.requireNonNull(mapper);
    // We can do better than this, by polling cancellationRequested when stream is infinite
    return new IntPipeline.StatelessOp<P_OUT>(this, StreamShape.REFERENCE,
                                          StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedReference<P_OUT, Integer>(sink) {
                IntConsumer downstreamAsInt = downstream::accept;
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(P_OUT u) {
                    try (IntStream result = mapper.apply(u)) {
                        // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                        if (result != null)
                            result.sequential().forEach(downstreamAsInt);
                    }
                }
            };
        }
    };
}

@Override
public void forEach(Consumer<? super Integer> consumer) {
    if (consumer instanceof IntConsumer) {
        forEach((IntConsumer) consumer);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(), "{0} calling SpinedBuffer.OfInt.forEach(Consumer)");
        spliterator().forEachRemaining(consumer);
    }
}

@Override
public boolean tryAdvance(IntConsumer consumer) {
    Objects.requireNonNull(consumer);
    boolean hasNext = doAdvance();
    if (hasNext)
        consumer.accept(buffer.get(nextToConsume));
    return hasNext;
}

@Override
public boolean tryAdvance(IntConsumer action) {
    if (action == null)
        throw new NullPointerException();
    if (index >= 0 && index < fence) {
        index = advance(array, index, fence, action);
        return true;
    }
    return false;
}

@Override
public boolean tryAdvance(IntConsumer action) {
    Objects.requireNonNull(action);

    action.accept(s.getAsInt());
    return true;
}

@Override
public void forEachRemaining(IntConsumer action) {
    int[] a; int i, hi; // hoist accesses and checks from loop
    if (action == null)
        throw new NullPointerException();
    if ((a = array).length >= (hi = fence) &&
        (i = index) >= 0 && i < (index = hi)) {
        do { action.accept(a[i]); } while (++i < hi);
    }
}

/**
 * {@inheritDoc}
 *
 * @param consumer a {@code Consumer} that is to be invoked with each
 *        element in this {@code Node}.  If this is an
 *        {@code IntConsumer}, it is cast to {@code IntConsumer} so the
 *        elements may be processed without boxing.
 */
@Override
default void forEach(Consumer<? super Integer> consumer) {
    if (consumer instanceof IntConsumer) {
        forEach((IntConsumer) consumer);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(), "{0} calling Node.OfInt.forEachRemaining(Consumer)");
        spliterator().forEachRemaining(consumer);
    }
}

public void forEachRemaining(IntConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        index = f;
        Random r = rng;
        int o = origin, b = bound;
        do {
            consumer.accept(r.internalNextInt(o, b));
        } while (++i < f);
    }
}

/**
 * Creates an {@code PrimitiveIterator.OfInt} from a
 * {@code Spliterator.OfInt}.
 *
 * <p>Traversal of elements should be accomplished through the iterator.
 * The behaviour of traversal is undefined if the spliterator is operated
 * after the iterator is returned.
 *
 * @param spliterator The spliterator
 * @return An iterator
 * @throws NullPointerException if the given spliterator is {@code null}
 */
public static PrimitiveIterator.OfInt iterator(Spliterator.OfInt spliterator) {
    Objects.requireNonNull(spliterator);
    class Adapter implements PrimitiveIterator.OfInt, IntConsumer {
        boolean valueReady = false;
        int nextElement;

        @Override
        public void accept(int t) {
            valueReady = true;
            nextElement = t;
        }

        @Override
        public boolean hasNext() {
            if (!valueReady)
                spliterator.tryAdvance(this);
            return valueReady;
        }

        @Override
        public int nextInt() {
            if (!valueReady && !hasNext())
                throw new NoSuchElementException();
            else {
                valueReady = false;
                return nextElement;
            }
        }
    }

    return new Adapter();
}

@Override
public void forEach(IntConsumer action) {
    if (!isParallel()) {
        adapt(sourceStageSpliterator()).forEachRemaining(action);
    }
    else {
        super.forEach(action);
    }
}

@Override
public void forEachOrdered(IntConsumer action) {
    if (!isParallel()) {
        adapt(sourceStageSpliterator()).forEachRemaining(action);
    }
    else {
        super.forEachOrdered(action);
    }
}

/**
 * {@inheritDoc}
 * @implSpec
 * If the action is an instance of {@code IntConsumer} then it is cast
 * to {@code IntConsumer} and passed to {@link #forEachRemaining};
 * otherwise the action is adapted to an instance of
 * {@code IntConsumer}, by boxing the argument of {@code IntConsumer},
 * and then passed to {@link #forEachRemaining}.
 */
@Override
default void forEachRemaining(Consumer<? super Integer> action) {
    if (action instanceof IntConsumer) {
        forEachRemaining((IntConsumer) action);
    }
    else {
        // The method reference action::accept is never null
        Objects.requireNonNull(action);
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(), "{0} calling PrimitiveIterator.OfInt.forEachRemainingInt(action::accept)");
        forEachRemaining((IntConsumer) action::accept);
    }
}

/**
 * {@inheritDoc}
 * @implSpec
 * If the action is an instance of {@code IntConsumer} then it is cast
 * to {@code IntConsumer} and passed to
 * {@link #forEachRemaining(java.util.function.IntConsumer)}; otherwise
 * the action is adapted to an instance of {@code IntConsumer}, by
 * boxing the argument of {@code IntConsumer}, and then passed to
 * {@link #forEachRemaining(java.util.function.IntConsumer)}.
 */
@Override
default void forEachRemaining(Consumer<? super Integer> action) {
    if (action instanceof IntConsumer) {
        forEachRemaining((IntConsumer) action);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(),
                          "{0} calling Spliterator.OfInt.forEachRemaining((IntConsumer) action::accept)");
        forEachRemaining((IntConsumer) action::accept);
    }
}

@Override
public boolean tryAdvance(IntConsumer action) {
    if (action == null) throw new NullPointerException();
    if (it.hasNext()) {
        action.accept(it.nextInt());
        return true;
    }
    return false;
}

public void forEachRemaining(IntConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        index = f;
        Random r = rng;
        int o = origin, b = bound;
        do {
            consumer.accept(r.internalNextInt(o, b));
        } while (++i < f);
    }
}

public void forEachRemaining(IntConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        index = f;
        int o = origin, b = bound;
        ThreadLocalRandom rng = ThreadLocalRandom.current();
        do {
            consumer.accept(rng.internalNextInt(o, b));
        } while (++i < f);
    }
}

public boolean tryAdvance(IntConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(rng.internalNextInt(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}