Класс Random

public Random()

public Random(long seed)

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

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

Random rnd = new Random();
 rnd.setSeed(seed);

public void setSeed(long seed)

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

(seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)

и сброса флага haveNextNextGaussian , используемого методом nextGaussian().

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

protected int next(int bits)

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

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

(seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)

и возврата

(int)(seed >>> (48 - bits)).

. Это линейный конгруэнтный генератор псевдослучайных чисел, как определено Д. Х. Лемером и описано Дональдом Э. Кнутом в Искусстве программирования, Том 3: Получисленные алгоритмы, раздел 3.2.1.

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;
 }

public int nextInt()

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

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

public int nextInt() {
   return next(32);
 }

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 — малая степень двойки.

public long nextLong()

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

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

public long nextLong() {
   return ((long)next(32) << 32) + next(32);
 }

Поскольку класс Random использует начальное значение с только 48 битами, этот алгоритм не вернёт все возможные long значения.

public boolean nextBoolean()

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

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

public boolean nextBoolean() {
   return next(1) != 0;
 }

public float nextFloat()

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

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

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

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

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

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

return next(30) / ((float)(1 << 30));

Это, возможно, кажется эквивалентным, если не лучшим, но на самом деле оно вносило небольшую неоднородность из-за смещения при округления чисел с плавающей точкой: было немного более вероятно, что младший бит мантиссы будет 0, чем 1.]

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! Эта неравномерность, вероятно, не имеет большого значения на практике, но мы стремимся к совершенству.]

public double nextGaussian()

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

Общая спецификация nextGaussian заключается в том, что одно double значение, выбранное из (приблизительно) обычного нормального распределения со средним значением 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;
   }
 }

Это использует полярный метод Г. Э. П. Бокса, М. Э. Мюллера и Г. Марсаглии, как описано Дональдом Э. Кнутом в Искусстве программирования вычислений, том 3: Получисленные алгоритмы, раздел 3.4.1, подразд. C, алгоритм P. Обратите внимание, что он генерирует два независимых значения ценой только одного вызова StrictMath.log и одного вызова StrictMath.sqrt.

public IntStream ints(long streamSize)

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

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

public IntStream ints()

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

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

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;
   }
 }

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;
   }
 }

public LongStream longs(long streamSize)

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

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

public LongStream longs()

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

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

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;
 }

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;
 }

public DoubleStream doubles(long streamSize)

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

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

public DoubleStream doubles()

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

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

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;
 }

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;
 }