java.util.function.DoubleConsumer#accept ( )源码实例Demo

@Override
public final DoubleStream peek(DoubleConsumer action) {
    Objects.requireNonNull(action);
    return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                   0) {
        @Override
        public Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedDouble<Double>(sink) {
                @Override
                public void accept(double t) {
                    action.accept(t);
                    downstream.accept(t);
                }
            };
        }
    };
}
 

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

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

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

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

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

@Override
public void forEachRemaining(DoubleConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
    }
}
 

@Override
protected void arrayForEach(double[] array,
                            int from, int to,
                            DoubleConsumer consumer) {
    for (int i = from; i < to; i++)
        consumer.accept(array[i]);
}
 

@Override
protected void arrayForEach(double[] array,
                            int from, int to,
                            DoubleConsumer consumer) {
    for (int i = from; i < to; i++)
        consumer.accept(array[i]);
}
 

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

@Override
protected void arrayForEach(double[] array,
                            int from, int to,
                            DoubleConsumer consumer) {
    for (int i = from; i < to; i++)
        consumer.accept(array[i]);
}
 

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

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

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

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

@Override
public void forEachRemaining(DoubleConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
    }
}
 

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

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

@Override
public void forEachRemaining(DoubleConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
    }
}
 

@Override
public void forEach(DoubleConsumer consumer) {
    for (int i = 0; i < curSize; i++) {
        consumer.accept(array[i]);
    }
}
 

@Override
protected void acceptConsumed(DoubleConsumer action) {
    action.accept(tmpValue);
}
 

/**
 * Have the specified consumer accept the value if a value is present,
 * otherwise do nothing.
 *
 * @param consumer block to be executed if a value is present
 * @throws NullPointerException if value is present and {@code consumer} is
 * null
 */
public void ifPresent(DoubleConsumer consumer) {
    if (isPresent)
        consumer.accept(value);
}