Класс Random

Random

public Random()

Random

public Random(long seed)

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

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

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

Параметры:

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

См. также:

• setSeed(long)

setSeed

public void setSeed(long seed)

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

Параметры:

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

next

protected int next(int bits)

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

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

Параметры:

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 - если bound не положительное

С момента:

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()

Указано в:

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

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

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

Указано в:

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

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

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

Указано в:

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

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

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

Возвращает:

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

ints

public IntStream ints(long streamSize)

Указано в:

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

Параметры:

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

Возвращает:

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

Исключения:

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

С:

1.8

ints

public IntStream ints()

Указано в:

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

Примечание для реализации:

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

Возвращает:

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

С:

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

С:

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

Указано в:

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

Примечание для реализации:

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

С:

1.8

longs

public LongStream longs(long streamSize)

Указано в:

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

Параметры:

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

Возвращает:

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

Исключения:

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

С:

1.8

longs

public LongStream longs()

Указано в:

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

Примечание для реализации:

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

Возвращает:

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

С:

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 - количество значений для генерации

Возвращает:

поток значений с плавающей точкой двойной точности

Выбрасывает:

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

С:

1.8

doubles

public DoubleStream doubles()

Указано в:

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

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

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

Возвращает:

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

С:

1.8

doubles

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

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

Параметры:

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

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

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

Возвращает:

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

Выбрасывает:

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

С:

1.8

doubles

public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound)

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

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

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

Параметры:

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

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

Возвращает:

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

Выбрасывает:

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

С:

1.8