Класс Random

Random

public Random()

Random

public Random(long seed)

Требования к реализации:

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

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

Параметры:

seed - начальное значение

См. также:

• setSeed(long)

from

public static Random from(RandomGenerator generator)

Параметры:

generator - генератор, к которому делегируются вызовы RandomGenerator

Возвращает:

экземпляр Random с делегированием

Исключение:

NullPointerException - если генератор равен null

С:

19

setSeed

public void setSeed(long seed)

Требования к реализации:

Реализация в этом классе изменяет состояние этого генератора случайных чисел так, что оно совпадает с состоянием, как если бы он был только что создан с new Random(seed). Он атомарно обновляет начальное значение до

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

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

Параметры:

seed - значение начального значения

Исключение:

UnsupportedOperationException - если операция setSeed не поддерживается этим генератором случайных чисел

next

protected int next(int bits)

Примечание API:

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

Требования к реализации:

Реализация в этом классе атомарно обновляет начальное значение до

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

и возвращает

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

Это линейный конгруэнтный генератор псевдослучайных чисел, как определено D. H. Lehmer и описано Donald E. Knuth в Искусство программирования, том 2, Третье издание: Алгоритмы счисления, раздел 3.2.1.

Параметры:

bits - случайные биты

Возвращает:

следующее псевдослучайное значение из последовательности этого генератора случайных чисел

С:

1.1

nextBytes

public void nextBytes(byte[] bytes)

Задано:

nextBytes в интерфейсе RandomGenerator

Требования к реализации:

Метод 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()

Задано:

nextInt в интерфейсе RandomGenerator

Требования к реализации:

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

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

Возвращает:

следующее псевдослучайное, равномерно распределенное int значение из последовательности этого генератора случайных чисел

nextInt

public int nextInt(int bound)

Задано:

nextInt в интерфейсе RandomGenerator

Требования к реализации:

Метод 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 - если граница не положительна

С:

1.2

nextLong

public long nextLong()

Задано:

nextLong в интерфейсе RandomGenerator

Требования к реализации:

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

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

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

Возвращает:

следующее псевдослучайное, равномерно распределенное long значение из последовательности этого генератора случайных чисел

nextBoolean

public boolean nextBoolean()

Задано:

nextBoolean в интерфейсе RandomGenerator

Требования к реализации:

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

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

Возвращает:

следующее псевдослучайное, равномерно распределенное boolean значение из последовательности этого генератора случайных чисел

С:

1.2

nextFloat

public float nextFloat()

Specified by:

nextFloat в интерфейсе RandomGenerator

Implementation Requirements:

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

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

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

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

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

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

Returns:

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

nextDouble

public double nextDouble()

Specified by:

nextDouble в интерфейсе RandomGenerator

Implementation Requirements:

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

Returns:

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

See Also:

• Math.random()

nextGaussian

public double nextGaussian()

Specified by:

nextGaussian в интерфейсе RandomGenerator

Implementation Requirements:

Метод 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, подпункт С, алгоритм P. Обратите внимание, что он генерирует два независимых значения за счет всего одного вызова StrictMath.log и одного вызова StrictMath.sqrt.

Returns:

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

ints

public IntStream ints(long streamSize)

Specified by:

ints в интерфейсе RandomGenerator

Parameters:

streamSize - количество генерируемых значений

Returns:

поток псевдослучайных int значений

Throws:

IllegalArgumentException - если streamSize меньше нуля

Since:

1.8

ints

public IntStream ints()

Specified by:

ints в интерфейсе RandomGenerator

Implementation Note:

Этот метод реализуется эквивалентно ints(Long.MAX_VALUE).

Returns:

поток псевдослучайных int значений

Since:

1.8

ints

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

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

Specified by:

ints в интерфейсе RandomGenerator

Parameters:

streamSize - количество генерируемых значений

randomNumberOrigin - начало (включительно) каждого случайного значения

randomNumberBound - граница (исключительно) каждого случайного значения

Returns:

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

Throws:

IllegalArgumentException - если streamSize меньше нуля или randomNumberOrigin больше или равно randomNumberBound

Since:

1.8

ints

public IntStream ints(int randomNumberOrigin, int randomNumberBound)

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

Specified by:

ints в интерфейсе RandomGenerator

Implementation Note:

Этот метод реализуется эквивалентно ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).

Parameters:

randomNumberOrigin - начало (включительно) каждого случайного значения

randomNumberBound - граница (исключительно) каждого случайного значения

Returns:

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

Throws:

IllegalArgumentException - если randomNumberOrigin больше или равно randomNumberBound

Since:

1.8

longs

public LongStream longs(long streamSize)

Specified by:

longs в интерфейсе RandomGenerator

Parameters:

streamSize - количество генерируемых значений

Returns:

поток псевдослучайных long значений

Throws:

IllegalArgumentException - если streamSize меньше нуля

Since:

1.8

longs

public LongStream longs()

Specified by:

longs в интерфейсе RandomGenerator

Implementation Note:

Этот метод реализуется эквивалентно longs(Long.MAX_VALUE).

Returns:

поток псевдослучайных long значений

Since:

1.8

longs

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

 
 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 в интерфейсе RandomGenerator

Параметры:

streamSize - количество значений для генерации

randomNumberOrigin - начало (включительно) каждого случайного значения

randomNumberBound - граница (исключительно) каждого случайного значения

Возвращает:

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

Исключения:

IllegalArgumentException - если streamSize меньше нуля или randomNumberOrigin больше или равно randomNumberBound

С:

1.8

longs

public LongStream longs(long randomNumberOrigin, long randomNumberBound)

 
 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 в интерфейсе RandomGenerator

Примечание по реализации:

Этот метод реализован так, чтобы быть эквивалентным longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).

Параметры:

randomNumberOrigin - начало (включительно) каждого случайного значения

randomNumberBound - граница (исключительно) каждого случайного значения

Возвращает:

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

Исключения:

IllegalArgumentException - если randomNumberOrigin больше или равно randomNumberBound

С:

1.8

doubles

public DoubleStream doubles(long streamSize)

Указано в:

doubles в интерфейсе RandomGenerator

Параметры:

streamSize - количество значений для генерации

Возвращает:

поток значений double

Исключения:

IllegalArgumentException - если streamSize меньше нуля

С:

1.8

doubles

public DoubleStream doubles()

Указано в:

doubles в интерфейсе RandomGenerator

Примечание по реализации:

Этот метод реализован так, чтобы быть эквивалентным doubles(Long.MAX_VALUE).

Возвращает:

поток псевдослучайных значений double

С:

1.8

doubles

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

Указано в:

doubles в интерфейсе RandomGenerator

Параметры:

streamSize - количество значений для генерации

randomNumberOrigin - начало (включительно) каждого случайного значения

randomNumberBound - граница (исключительно) каждого случайного значения

Возвращает:

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

Исключения:

IllegalArgumentException - если streamSize меньше нуля, или randomNumberOrigin не является конечным, или randomNumberBound не является конечным, или randomNumberOrigin больше или равно randomNumberBound

С:

1.8

doubles

public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound)

Указано в:

doubles в интерфейсе RandomGenerator

Примечание по реализации:

Этот метод реализован так, чтобы быть эквивалентным doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).

Параметры:

randomNumberOrigin - начало (включительно) каждого случайного значения

randomNumberBound - граница (исключительно) каждого случайного значения

Возвращает:

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

Исключения:

IllegalArgumentException - если randomNumberOrigin не является конечным, или randomNumberBound не является конечным, или randomNumberOrigin больше или равно randomNumberBound

С:

1.8