Класс Random

Все реализуемые интерфейсы:
Serializable
Прямые известные подклассы:
SecureRandom, ThreadLocalRandom 
public class Random
extends Object
implements Serializable

Экземпляр этого класса используется для генерации потока псевдослучайных чисел. Класс использует 48-битный seed, который модифицируется с помощью линейной конгруэнтной формулы. (См. Дональд Кнут, Искусство программирования, том 2, раздел 3.2.1.)

Если два экземпляра Random создаются с одинаковым seed и для каждого выполняется одинаковая последовательность вызовов методов, они будут генерировать и возвращать идентичные последовательности чисел. Для гарантии этого свойства определены конкретные алгоритмы для класса Random. Реализации Java должны использовать все представленные здесь алгоритмы для класса Random, ради абсолютной переносимости кода Java. Однако подклассы класса Random могут использовать другие алгоритмы, при условии соблюдения общих контрактов для всех методов.

Алгоритмы, реализованные классом Random , используют вспомогательный метод protected, который при каждом вызове может предоставить до 32 псевдослучайных бита.

Многие приложения найдут метод Math.random() более простым в использовании.

Экземпляры java.util.Random являются потокобезопасными. Однако одновременное использование одного и того же экземпляра java.util.Random в разных потоках может привести к конфликтам и, как следствие, к плохой производительности. Вместо этого следует использовать ThreadLocalRandom в многопоточных проектах.

Экземпляры java.util.Random не являются криптографически безопасными. Вместо этого используйте SecureRandom для получения криптографически безопасного генератора псевдослучайных чисел для использования в приложениях, чувствительных к безопасности.

С:
1.0
См. также:
Сериализованная форма

Конструкторы

Конструктор Описание
Random()

Создает новый генератор случайных чисел.
Random​(long seed)

Создает новый генератор случайных чисел, используя один long seed.

Методы

Модификатор и тип Метод Описание
DoubleStream doubles()

Возвращает эффективно неограниченный поток псевдослучайных значений, каждое из которых находится между нулём (включительно) и единицей (исключительно).
DoubleStream doubles​(double randomNumberOrigin, double randomNumberBound)

Возвращает эффективно неограниченный поток псевдослучайных значений, каждое из которых соответствует заданному началу (включительно) и границе (исключительно).
DoubleStream doubles​(long streamSize)

Возвращает поток, производящий заданное количество псевдослучайных значений, каждое из которых находится между нулём (включительно) и единицей (исключительно).
DoubleStream doubles​(long streamSize, double randomNumberOrigin, double randomNumberBound)

Возвращает поток, производящий заданное количество псевдослучайных значений, каждое из которых соответствует заданному началу (включительно) и границе (исключительно).
IntStream ints()

Возвращает эффективно неограниченный поток псевдослучайных значений.
IntStream ints​(int randomNumberOrigin, int randomNumberBound)

Возвращает эффективно неограниченный поток псевдослучайных значений, каждое из которых соответствует заданному началу (включительно) и границе (исключительно).
IntStream ints​(long streamSize)

Возвращает поток, производящий заданное количество псевдослучайных значений.
IntStream ints​(long streamSize, int randomNumberOrigin, int randomNumberBound)

Возвращает поток, производящий заданное количество псевдослучайных значений, каждое из которых соответствует заданному началу (включительно) и границе (исключительно).
LongStream longs()

Возвращает эффективно неограниченный поток псевдослучайных значений.
LongStream longs​(long streamSize)

Возвращает поток, производящий заданное количество псевдослучайных значений.
LongStream longs​(long randomNumberOrigin, long randomNumberBound)

Возвращает эффективно неограниченный поток псевдослучайных значений, каждое из которых соответствует заданному началу (включительно) и границе (исключительно).
LongStream longs​(long streamSize, long randomNumberOrigin, long randomNumberBound)

Возвращает поток, производящий заданное количество псевдослучайных значений, каждое из которых соответствует заданному началу (включительно) и границе (исключительно).
protected int next​(int bits)

Генерирует следующее псевдослучайное число.
boolean nextBoolean()

Возвращает следующее псевдослучайное, равномерно распределённое значение из последовательности этого генератора случайных чисел.
void nextBytes​(byte[] bytes)

Генерирует случайные байты и помещает их в предоставленный пользователем массив байтов.
double nextDouble()

Возвращает следующее псевдослучайное, равномерно распределённое значение между 0.0 и 1.0 из последовательности этого генератора случайных чисел.
float nextFloat()

Возвращает следующее псевдослучайное, равномерно распределённое значение между 0.0 и 1.0 из последовательности этого генератора случайных чисел.
double nextGaussian()

Возвращает следующее псевдослучайное, Гауссово ("нормальное") распределённое значение со средним значением 0.0 и стандартным отклонением 1.0 из последовательности этого генератора случайных чисел.
int nextInt()

Возвращает следующее псевдослучайное, равномерно распределённое значение из последовательности этого генератора случайных чисел.
int nextInt​(int bound)

Возвращает псевдослучайное, равномерно распределённое значение между 0 (включительно) и заданным значением (исключительно), взятое из последовательности этого генератора случайных чисел.
long nextLong()

Возвращает следующее псевдослучайное, равномерно распределённое значение из последовательности этого генератора случайных чисел.
void setSeed​(long seed)

Устанавливает seed этого генератора случайных чисел, используя один long seed.

Методы, объявленные в классе java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Конструкторы

Random

public Random()

Создает новый генератор случайных чисел. Этот конструктор устанавливает seed генератора случайных чисел в значение, очень вероятно отличное от любого другого вызова этого конструктора.

Random

public Random(long seed)

Создает новый генератор случайных чисел, используя один long seed. Seed — это начальное значение внутреннего состояния генератора псевдослучайных чисел, которое поддерживается методом next(int).

Вызов new Random(seed) эквивалентен:

Random rnd = new Random();
 rnd.setSeed(seed);
Параметры:
seed - начальный seed
См. также:
setSeed(long)

Методы

setSeed

public void setSeed(long seed)

Устанавливает начальное значение (seed) этого генератора псевдослучайных чисел, используя единственное long начальное значение. Общее соглашение для setSeed состоит в том, что оно изменяет состояние этого объекта генератора псевдослучайных чисел таким образом, чтобы оно было точно таким же, как если бы он был только что создан с аргументом seed в качестве начального значения. Метод setSeed реализуется классом Random путем атомарного обновления начального значения до 

(seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)
и сброса флага haveNextNextGaussian используемого методом nextGaussian().

Реализация setSeed классом Random использует только 48 бит заданного начального значения. Однако, в общем случае, переопределенный метод может использовать все 64 бита аргумента long в качестве начального значения.

Параметры:
seed - начальное значение

next

protected int next(int bits)

Генерирует следующее псевдослучайное число. Подклассы должны переопределить этот метод, так как он используется всеми другими методами.

Общее соглашение для next состоит в том, что он возвращает значение int и если аргумент bits находится между 1 и 32 (включительно), то столько младших битов возвращаемого значения будут (приблизительно) независимо выбранными битовыми значениями, каждое из которых (приблизительно) одинаково вероятно иметь значение 0 или 1. Метод next реализуется классом Random путем атомарного обновления начального значения до 

(seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)
и возвращает 
(int)(seed >>> (48 - bits)).
Это линейный конгруэнциальный генератор псевдослучайных чисел, как определено Д. Х. Лемером и описано Дональдом Е. Кнутом в книге Искусство программирования, том 2: Получисленные алгоритмы, раздел 3.2.1.
Параметры:
bits - случайные биты
Возвращает:
следующее псевдослучайное значение из последовательности этого генератора псевдослучайных чисел
С момента:
1.1

nextBytes

public void nextBytes(byte[] bytes)

Генерирует случайные байты и помещает их в предоставленный пользователем массив байтов. Количество сгенерированных случайных байтов равно длине массива байтов.

Метод nextBytes реализуется классом Random как если бы: 

public void nextBytes(byte[] bytes) {
   for (int i = 0; i < bytes.length; )
     for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
          n-- > 0; rnd >>= 8)
       bytes[i++] = (byte)rnd;
 }
Параметры:
bytes - массив байтов, который нужно заполнить случайными байтами
Исключения:
NullPointerException - если массив байтов равен null
С момента:
1.1

nextInt

public int nextInt()

Возвращает следующее псевдослучайное, равномерно распределённое int значение из последовательности этого генератора псевдослучайных чисел. Общее соглашение для nextInt состоит в том, что одно int значение генерируется псевдослучайным образом и возвращается. Все 232 возможных значений int генерируются с (приблизительно) равной вероятностью.

Метод nextInt реализуется классом Random как если бы: 

public int nextInt() {
   return next(32);
 }
Возвращает:
следующее псевдослучайное, равномерно распределённое int значение из последовательности этого генератора псевдослучайных чисел

nextInt

public int nextInt(int bound)

Возвращает псевдослучайное, равномерно распределенное int значение между 0 (включительно) и заданным значением (исключительно), выбранное из последовательности этого генератора псевдослучайных чисел. Общее соглашение для nextInt состоит в том, что одно int значение в заданном диапазоне генерируется псевдослучайным образом и возвращается. Все bound возможные значения int генерируются с (приблизительно) равной вероятностью. Метод nextInt(int bound) реализуется классом Random как если бы: 

public int nextInt(int bound) {
   if (bound <= 0)
     throw new IllegalArgumentException("bound must be positive");

   if ((bound & -bound) == bound)  // i.e., bound is a power of 2
     return (int)((bound * (long)next(31)) >> 31);

   int bits, val;
   do {
       bits = next(31);
       val = bits % bound;
   } while (bits - val + (bound-1) < 0);
   return val;
 }

Ограничение «приблизительно» используется в приведенном описании только потому, что следующий метод является лишь приблизительно несмещенным источником независимо выбранных битов. Если бы это был идеальный источник случайных битов, то показанный алгоритм выбирал бы значения int из указанного диапазона с идеальной равномерностью.

Алгоритм немного сложный. Он отбрасывает значения, которые могут привести к неравномерному распределению (из-за того, что 2^31 не делится на n). Вероятность отбрасывания значения зависит от n. Наихудший случай - n=2^30+1, при котором вероятность отбрасывания составляет 1/2, а ожидаемое количество итераций перед завершением цикла составляет 2.

Алгоритм обрабатывает случай, когда n является степенью двойки специально: он возвращает правильное количество старших битов из базового генератора псевдослучайных чисел. В отсутствие специальной обработки вернулось бы правильное количество младших битов. Линейные конгруэнциальные генераторы псевдослучайных чисел, такие как реализованный в этом классе, известны своими короткими периодами в последовательности значений их младших битов. Таким образом, этот специальный случай значительно увеличивает длину последовательности значений, возвращаемых последовательными вызовами этого метода, если n - небольшая степень двойки.

Параметры:
bound - верхняя граница (исключительно). Должно быть положительным.
Возвращает:
следующее псевдослучайное, равномерно распределенное int значение между нулем (включительно) и bound (исключительно) из последовательности этого генератора псевдослучайных чисел
Исключения:
IllegalArgumentException - если bound не положительно
С момента:
1.2

nextLong

public long nextLong()

Возвращает следующее псевдослучайное, равномерно распределенное long значение из последовательности этого генератора псевдослучайных чисел. Общее соглашение для nextLong состоит в том, что одно long значение генерируется псевдослучайным образом и возвращается.

Метод nextLong реализуется классом Random как если бы: 

public long nextLong() {
   return ((long)next(32) << 32) + next(32);
 }
Поскольку класс Random использует начальное значение только с 48 битами, этот алгоритм не вернет все возможные значения long.
Возвращает:
следующее псевдослучайное, равномерно распределенное long значение из последовательности этого генератора псевдослучайных чисел

nextBoolean

public boolean nextBoolean()

Возвращает следующее псевдослучайное, равномерно распределенное boolean значение из последовательности этого генератора псевдослучайных чисел. Общее соглашение для nextBoolean состоит в том, что одно boolean значение генерируется псевдослучайным образом и возвращается. Значения true и false генерируются с (приблизительно) равной вероятностью.

Метод nextBoolean реализуется классом Random как если бы: 

public boolean nextBoolean() {
   return next(1) != 0;
 }
Возвращает:
следующее псевдослучайное, равномерно распределенное boolean значение из последовательности этого генератора псевдослучайных чисел
С момента:
1.2

nextFloat

public float nextFloat()

Возвращает следующее псевдослучайное, равномерно распределенное float значение между 0.0 и 1.0 из последовательности этого генератора псевдослучайных чисел.

Общее соглашение для nextFloat состоит в том, что одно float значение, выбранное (приблизительно) равномерно из диапазона 0.0f (включительно) до 1.0f (исключительно), генерируется псевдослучайным образом и возвращается. Все 224 возможные значения float вида m x 2-24, где m - положительное целое число меньше 224, генерируются с (приблизительно) равной вероятностью.

Метод nextFloat реализуется классом Random как если бы: 

public float nextFloat() {
   return next(24) / ((float)(1 << 24));
 }

Ограничение «приблизительно» используется в приведенном описании только потому, что следующий метод является лишь приблизительно несмещенным источником независимо выбранных битов. Если бы это был идеальный источник случайных битов, то показанный алгоритм выбирал бы значения float из указанного диапазона с идеальной равномерностью.

[В ранних версиях Java результат вычислялся неправильно как: 

return next(30) / ((float)(1 << 30));
Это, возможно, выглядело бы эквивалентным, если не лучшим, но на самом деле оно вносило небольшую неравномерность из-за смещения при округления чисел с плавающей точкой: было немного вероятнее, что младший бит мантиссы будет равен 0, чем 1.]
Возвращает:
следующее псевдослучайное, равномерно распределенное float значение между 0.0 и 1.0 из последовательности этого генератора псевдослучайных чисел

nextDouble

public double nextDouble()

Возвращает следующее псевдослучайное, равномерно распределенное double значение между 0.0 и 1.0 из последовательности этого генератора псевдослучайных чисел.

Общее соглашение для nextDouble состоит в том, что одно double значение, выбранное (приблизительно) равномерно из диапазона 0.0d (включительно) до 1.0d (исключительно), генерируется псевдослучайным образом и возвращается.

Метод nextDouble реализуется классом Random как если бы: 

public double nextDouble() {
   return (((long)next(26) << 27) + next(27))
     / (double)(1L << 53);
 }

Ограничение «приблизительно» используется в приведенном описании только потому, что метод next является лишь приблизительно несмещенным источником независимо выбранных битов. Если бы это был идеальный источник случайных битов, то алгоритм показанный выбрал бы значения double из указанного диапазона с идеальной равномерностью.

[В ранних версиях Java результат вычислялся неправильно как: 

return (((long)next(27) << 27) + next(27))
     / (double)(1L << 54);
Это, возможно, выглядело бы эквивалентным, если не лучшим, но на самом деле это вносило значительную неравномерность из-за смещения при округления чисел с плавающей точкой: вероятность того, что младший бит мантиссы будет 0, была в три раза больше, чем вероятность того, что он будет 1! Эта неравномерность, вероятно, не имеет большого значения на практике, но мы стремимся к совершенству.]
Возвращает:
следующее псевдослучайное, равномерно распределенное double значение между 0.0 и 1.0 из последовательности этого генератора псевдослучайных чисел
См. также:
Math.random()

nextGaussian

public double nextGaussian()

Возвращает следующее псевдослучайное значение, распределённое по гауссову закону («нормальному»), со средним значением 0.0 и стандартным отклонением 1.0 из последовательности этого генератора псевдослучайных чисел.

Общая спецификация nextGaussian заключается в том, что выбирается одно псевдослучайное значение, взятое (приблизительно) из стандартного нормального распределения со средним значением 0.0 и стандартным отклонением 1.0, и возвращается.

Метод nextGaussian реализован классом Random так, как будто это безопасная для потоков версия следующего:

private double nextNextGaussian;
 private boolean haveNextNextGaussian = false;

 public double nextGaussian() {
   if (haveNextNextGaussian) {
     haveNextNextGaussian = false;
     return nextNextGaussian;
   } else {
     double v1, v2, s;
     do {
       v1 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
       v2 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
       s = v1 * v1 + v2 * v2;
     } while (s >= 1 || s == 0);
     double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
     nextNextGaussian = v2 * multiplier;
     haveNextNextGaussian = true;
     return v1 * multiplier;
   }
 }
Это использует метод полярных координат Г. Э. П. Бокса, М. Э. Муллера и Г. Марсалья, как описано Дональдом Э. Кнутом в Искусстве программирования для ЭВМ, том 2: Получисленные алгоритмы, раздел 3.4.1, подраздел C, алгоритм P. Обратите внимание, что он генерирует два независимых значения ценой только одного вызова StrictMath.log и одного вызова StrictMath.sqrt.
Возвращает:
следующее псевдослучайное значение, распределённое по гауссову закону («нормальному»), со средним значением 0.0 и стандартным отклонением 1.0 из последовательности этого генератора псевдослучайных чисел

ints

public IntStream ints(long streamSize)

Возвращает поток, генерирующий заданное количество streamSize псевдослучайных int значений.

Псевдослучайное int значение генерируется так, как будто это результат вызова метода nextInt().

Параметры:
streamSize - количество генерируемых значений
Возвращает:
поток псевдослучайных int значений
Исключения:
IllegalArgumentException - если streamSize меньше нуля
С тех пор:
1.8

ints

public IntStream ints()

Возвращает эффективно неограниченный поток псевдослучайных int значений.

Псевдослучайное int значение генерируется так, как будто это результат вызова метода nextInt().

Примечание для реализации:
Этот метод реализован так, чтобы быть эквивалентным ints(Long.MAX_VALUE).
Возвращает:
поток псевдослучайных int значений
С тех пор:
1.8

ints

public IntStream ints(long streamSize,
                      int randomNumberOrigin,
                      int randomNumberBound)

Возвращает поток, генерирующий заданное streamSize количество псевдослучайных int значений, каждое из которых соответствует заданному начальному (включительно) и конечному (исключительно) значениям.

Псевдослучайное int значение генерируется так, как будто это результат вызова следующего метода с начальным и конечным значениями:

int nextInt(int origin, int bound) {
   int n = bound - origin;
   if (n > 0) {
     return nextInt(n) + origin;
   }
   else {  // range not representable as int
     int r;
     do {
       r = nextInt();
     } while (r < origin || r >= bound);
     return r;
   }
 }
Параметры:
streamSize - количество генерируемых значений
randomNumberOrigin - начальное значение (включительно) каждого случайного значения
randomNumberBound - конечное значение (исключительно) каждого случайного значения
Возвращает:
поток псевдослучайных int значений, каждое из которых имеет заданное начальное (включительно) и конечное (исключительно) значение
Исключения:
IllegalArgumentException - если streamSize меньше нуля или randomNumberOrigin больше или равно randomNumberBound
С тех пор:
1.8

ints

public IntStream ints(int randomNumberOrigin,
                      int randomNumberBound)

Возвращает эффективно неограниченный поток псевдослучайных int значений, каждое из которых соответствует заданному начальному (включительно) и конечному (исключительно) значениям.

Псевдослучайное int значение генерируется так, как будто это результат вызова следующего метода с начальным и конечным значениями:

int nextInt(int origin, int bound) {
   int n = bound - origin;
   if (n > 0) {
     return nextInt(n) + origin;
   }
   else {  // range not representable as int
     int r;
     do {
       r = nextInt();
     } while (r < origin || r >= bound);
     return r;
   }
 }
Примечание для реализации:
Этот метод реализован так, чтобы быть эквивалентным ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
Параметры:
randomNumberOrigin - начальное значение (включительно) каждого случайного значения
randomNumberBound - конечное значение (исключительно) каждого случайного значения
Возвращает:
поток псевдослучайных int значений, каждое из которых имеет заданное начальное (включительно) и конечное (исключительно) значение
Исключения:
IllegalArgumentException - если randomNumberOrigin больше или равно randomNumberBound
С тех пор:
1.8

longs

public LongStream longs(long streamSize)

Возвращает поток, генерирующий заданное streamSize количество псевдослучайных long значений.

Псевдослучайное long значение генерируется так, как будто это результат вызова метода nextLong().

Параметры:
streamSize - количество генерируемых значений
Возвращает:
поток псевдослучайных long значений
Исключения:
IllegalArgumentException - если streamSize меньше нуля
С тех пор:
1.8

longs

public LongStream longs()

Возвращает эффективно неограниченный поток псевдослучайных long значений.

Псевдослучайное long значение генерируется так, как будто это результат вызова метода nextLong().

Примечание для реализации:
Этот метод реализован так, чтобы быть эквивалентным longs(Long.MAX_VALUE).
Возвращает:
поток псевдослучайных long значений
С тех пор:
1.8

longs

public LongStream longs(long streamSize,
                        long randomNumberOrigin,
                        long randomNumberBound)

Возвращает поток, генерирующий заданное streamSize количество псевдослучайных long, каждое из которых соответствует заданному начальному (включительно) и конечному (исключительно) значениям.

Псевдослучайное long значение генерируется так, как будто это результат вызова следующего метода с начальным и конечным значениями:

long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n & m) == 0L)  // power of two
     r = (r & m) + origin;
   else if (n > 0L) {  // reject over-represented candidates
     for (long u = r >>> 1;            // ensure nonnegative
          u + m - (r = u % n) < 0L;    // rejection check
          u = nextLong() >>> 1) // retry
         ;
     r += origin;
   }
   else {              // range not representable as long
     while (r < origin || r >= bound)
       r = nextLong();
   }
   return r;
 }
Параметры:
streamSize - количество генерируемых значений
randomNumberOrigin - начальное значение (включительно) каждого случайного значения
randomNumberBound - конечное значение (исключительно) каждого случайного значения
Возвращает:
поток псевдослучайных long значений, каждое из которых имеет заданное начальное (включительно) и конечное (исключительно) значение
Исключения:
IllegalArgumentException - если streamSize меньше нуля или randomNumberOrigin больше или равно randomNumberBound
С тех пор:
1.8

longs

public LongStream longs(long randomNumberOrigin,
                        long randomNumberBound)

Возвращает эффективно неограниченный поток псевдослучайных long значений, каждое из которых соответствует заданному начальному (включительно) и конечному (исключительно) значениям.

Псевдослучайное long значение генерируется так, как будто это результат вызова следующего метода с начальным и конечным значениями:

long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n & m) == 0L)  // power of two
     r = (r & m) + origin;
   else if (n > 0L) {  // reject over-represented candidates
     for (long u = r >>> 1;            // ensure nonnegative
          u + m - (r = u % n) < 0L;    // rejection check
          u = nextLong() >>> 1) // retry
         ;
     r += origin;
   }
   else {              // range not representable as long
     while (r < origin || r >= bound)
       r = nextLong();
   }
   return r;
 }
Примечание для реализации:
Этот метод реализован так, чтобы быть эквивалентным longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
Параметры:
randomNumberOrigin - начальное значение (включительно) каждого случайного значения
randomNumberBound - конечное значение (исключительно) каждого случайного значения
Возвращает:
поток псевдослучайных long значений, каждое из которых имеет заданное начальное (включительно) и конечное (исключительно) значение
Исключения:
IllegalArgumentException - если randomNumberOrigin больше или равно randomNumberBound
С тех пор:
1.8

doubles

public DoubleStream doubles(long streamSize)

Возвращает поток, генерирующий заданное streamSize количество псевдослучайных double значений, каждое из которых находится в диапазоне от нуля (включительно) до единицы (исключительно).

Псевдослучайное double значение генерируется так, как будто это результат вызова метода nextDouble().

Параметры:
streamSize - количество генерируемых значений
Возвращает:
поток double значений
Исключения:
IllegalArgumentException - если streamSize меньше нуля
С тех пор:
1.8

doubles

public DoubleStream doubles()

Возвращает эффективно неограниченный поток псевдослучайных double значений, каждое из которых находится в диапазоне от нуля (включительно) до единицы (исключительно).

Псевдослучайное double значение генерируется так, как будто это результат вызова метода nextDouble().

Примечание для реализации:
Этот метод реализован так, чтобы быть эквивалентным doubles(Long.MAX_VALUE).
Возвращает:
поток псевдослучайных double значений
С тех пор:
1.8

doubles

public DoubleStream doubles(long streamSize,
                            double randomNumberOrigin,
                            double randomNumberBound)

Возвращает поток, генерирующий заданное streamSize количество псевдослучайных double значений, каждое из которых соответствует заданному начальному (включительно) и конечному (исключительно) значениям.

Псевдослучайное double значение генерируется так, как будто это результат вызова следующего метода с начальным и конечным значениями:

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;
 }
Параметры:
streamSize - количество генерируемых значений
randomNumberOrigin - начальное значение (включительно) каждого случайного значения
randomNumberBound - конечное значение (исключительно) каждого случайного значения
Возвращает:
поток псевдослучайных double значений, каждое из которых имеет заданное начальное (включительно) и конечное (исключительно) значение
Исключения:
IllegalArgumentException - если streamSize меньше нуля
IllegalArgumentException - если randomNumberOrigin больше или равно randomNumberBound
С тех пор:
1.8

doubles

public DoubleStream doubles(double randomNumberOrigin,
                            double randomNumberBound)

Возвращает эффективно неограниченный поток псевдослучайных double значений, каждое из которых соответствует заданному начальному (включительно) и конечному (исключительно) значениям.

Псевдослучайное double значение генерируется так, как будто это результат вызова следующего метода с начальным и конечным значениями:

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;
 }
Примечание для реализации:
Этот метод реализован так, чтобы быть эквивалентным doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
Параметры:
randomNumberOrigin - начальное значение (включительно) каждого случайного значения
randomNumberBound - конечное значение (исключительно) каждого случайного значения
Возвращает:
поток псевдослучайных double значений, каждое из которых имеет заданное начальное (включительно) и конечное (исключительно) значение
Исключения:
IllegalArgumentException - если randomNumberOrigin больше или равно randomNumberBound
С тех пор:
1.8

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html

Spec-Zone .ru
спецификации, руководства, описания, API