Java StreamSupport.doubleStream方法代码示例

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns an effectively unlimited stream of pseudorandom {@code
 * double} values from this generator and/or one split from it; each value
 * conforms to the given origin (inclusive) and bound (exclusive).
 *
 * @implNote This method is implemented to be equivalent to {@code
 * doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
 *
 * @param randomNumberOrigin the origin (inclusive) of each random value
 * @param randomNumberBound the bound (exclusive) of each random value
 * @return a stream of pseudorandom {@code double} values,
 *         each with the given origin (inclusive) and bound (exclusive)
 * @throws IllegalArgumentException if {@code randomNumberOrigin}
 *         is greater than or equal to {@code randomNumberBound}
 */
public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
    if (!(randomNumberOrigin < randomNumberBound))
        throw new IllegalArgumentException(BadRange);
    return StreamSupport.doubleStream
        (new RandomDoublesSpliterator
         (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
         false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns an effectively unlimited stream of pseudorandom {@code
 * double} values, each between zero (inclusive) and one
 * (exclusive).
 *
 * <p>A pseudorandom {@code double} value is generated as if it's the result
 * of calling the method {@link #nextDouble()}.
 *
 * @implNote This method is implemented to be equivalent to {@code
 * doubles(Long.MAX_VALUE)}.
 *
 * @return a stream of pseudorandom {@code double} values
 * @since 1.8
 */
public DoubleStream doubles() {
    return StreamSupport.doubleStream
            (new RandomDoublesSpliterator
                     (this, 0L, Long.MAX_VALUE, Double.MAX_VALUE, 0.0),
             false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns a stream producing the given {@code streamSize} number of
 * pseudorandom {@code double} values, each between zero
 * (inclusive) and one (exclusive).
 *
 * @param streamSize the number of values to generate
 * @return a stream of {@code double} values
 * @throws IllegalArgumentException if {@code streamSize} is
 *         less than zero
 * @since 1.8
 */
public DoubleStream doubles(long streamSize) {
    if (streamSize < 0L)
        throw new IllegalArgumentException(BAD_SIZE);
    return StreamSupport.doubleStream
        (new RandomDoublesSpliterator
         (0L, streamSize, Double.MAX_VALUE, 0.0),
         false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns a stream producing the given {@code streamSize} number of
 * pseudorandom {@code double} values, each between zero
 * (inclusive) and one (exclusive).
 *
 * @param streamSize the number of values to generate
 * @return a stream of {@code double} values
 * @throws IllegalArgumentException if {@code streamSize} is
 *         less than zero
 * @since 1.8
 */
public DoubleStream doubles(long streamSize) {
    if (streamSize < 0L)
        throw new IllegalArgumentException(BadSize);
    return StreamSupport.doubleStream
        (new RandomDoublesSpliterator
         (0L, streamSize, Double.MAX_VALUE, 0.0),
         false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns an effectively unlimited stream of pseudorandom {@code
 * double} values from this generator and/or one split from it; each value
 * is between zero (inclusive) and one (exclusive).
 *
 * @implNote This method is implemented to be equivalent to {@code
 * doubles(Long.MAX_VALUE)}.
 *
 * @return a stream of pseudorandom {@code double} values
 */
public DoubleStream doubles() {
    return StreamSupport.doubleStream
        (new RandomDoublesSpliterator
         (this, 0L, Long.MAX_VALUE, Double.MAX_VALUE, 0.0),
         false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns a stream producing the given {@code streamSize} number of
 * pseudorandom {@code double} values, each conforming to the given origin
 * (inclusive) and bound (exclusive).
 *
 * <p>A pseudorandom {@code double} value is generated as if it's the result
 * of calling the following method with the origin and bound:
 * <pre> {@code
 * double nextDouble(double origin, double bound) {
 *   double r = nextDouble();
 *   r = r * (bound - origin) + origin;
 *   if (r >= bound) // correct for rounding
 *     r = Math.nextDown(bound);
 *   return r;
 * }}</pre>
 *
 * @param streamSize the number of values to generate
 * @param randomNumberOrigin the origin (inclusive) of each random value
 * @param randomNumberBound the bound (exclusive) of each random value
 * @return a stream of pseudorandom {@code double} values,
 *         each with the given origin (inclusive) and bound (exclusive)
 * @throws IllegalArgumentException if {@code streamSize} is
 *         less than zero
 * @throws IllegalArgumentException if {@code randomNumberOrigin}
 *         is greater than or equal to {@code randomNumberBound}
 * @since 1.8
 */
public DoubleStream doubles(long streamSize, double randomNumberOrigin,
                            double randomNumberBound) {
    if (streamSize < 0L)
        throw new IllegalArgumentException(BadSize);
    if (!(randomNumberOrigin < randomNumberBound))
        throw new IllegalArgumentException(BadRange);
    return StreamSupport.doubleStream
            (new RandomDoublesSpliterator
                     (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
             false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns a stream producing the given {@code streamSize} number of
 * pseudorandom {@code double} values, each between zero
 * (inclusive) and one (exclusive).
 *
 * <p>A pseudorandom {@code double} value is generated as if it's the result
 * of calling the method {@link #nextDouble()}.
 *
 * @param streamSize the number of values to generate
 * @return a stream of {@code double} values
 * @throws IllegalArgumentException if {@code streamSize} is
 *         less than zero
 * @since 1.8
 */
public DoubleStream doubles(long streamSize) {
    if (streamSize < 0L)
        throw new IllegalArgumentException(BadSize);
    return StreamSupport.doubleStream
            (new RandomDoublesSpliterator
                     (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
             false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns an effectively unlimited stream of pseudorandom {@code
 * double} values, each conforming to the given origin (inclusive) and bound
 * (exclusive).
 *
 * @implNote This method is implemented to be equivalent to {@code
 * doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
 *
 * @param randomNumberOrigin the origin (inclusive) of each random value
 * @param randomNumberBound the bound (exclusive) of each random value
 * @return a stream of pseudorandom {@code double} values,
 *         each with the given origin (inclusive) and bound (exclusive)
 * @throws IllegalArgumentException if {@code randomNumberOrigin}
 *         is greater than or equal to {@code randomNumberBound}
 * @since 1.8
 */
public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
    if (!(randomNumberOrigin < randomNumberBound))
        throw new IllegalArgumentException(BadRange);
    return StreamSupport.doubleStream
        (new RandomDoublesSpliterator
         (0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
         false);
}
 

import java.util.stream.StreamSupport; //导入方法依赖的package包/类
/**
 * Returns a sequential {@link DoubleStream} with the specified range of the
 * specified array as its source.
 *
 * @param array the array, assumed to be unmodified during use
 * @param startInclusive the first index to cover, inclusive
 * @param endExclusive index immediately past the last index to cover
 * @return a {@code DoubleStream} for the array range
 * @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
 *         negative, {@code endExclusive} is less than
 *         {@code startInclusive}, or {@code endExclusive} is greater than
 *         the array size
 * @since 1.8
 */
public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
    return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
}