compact1, compact2, compact3

java.util

Случайный класс

java.lang. Объект

java.util. Случайный

Все Реализованные Интерфейсы:

Сериализуемый

Прямые Известные Подклассы:

SecureRandom, ThreadLocalRandom

public class Random
extends Object
implements Serializable

Экземпляр этого class используется, чтобы генерировать поток псевдослучайных чисел. class использует 48-разрядное семя, которое изменяется, используя линейную congruential формулу. (См. Дональда Нута, Искусство Программирования, Объем 2, Раздел 3.2.1.)

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

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

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

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

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

С тех пор:

1.0

См. Также:

Сериализированная Форма

Сводка конструктора

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

Конструктор и Описание
Random() Создает новый генератор случайных чисел.
Random(long seed) Создает новый генератор случайных чисел, используя сингл long семя.

Сводка метода

Модификатор и Тип	Метод и Описание
DoubleStream	doubles() Возвращает поток псевдослучайных, однородно распределенных double значения между 0.0 и 1.0 от последовательности этого генератора случайных чисел.
DoubleStream	gaussians() Возвращает поток псевдослучайных, Гауссовых ("обычно") распределяемых double значения со средним значением 0.0 и стандартное отклонение 1.0 от последовательности этого генератора случайных чисел.
IntStream	ints() Возвращает поток псевдослучайных, однородно распределенных integer значения от последовательности этого генератора случайных чисел.
LongStream	longs() Возвращает поток псевдослучайных, однородно распределенных long значения от последовательности этого генератора случайных чисел.
protected int	next(int bits) Генерирует следующее псевдослучайное число.
boolean	nextBoolean() Возвращает следующее псевдослучайное, однородно распределенное boolean значение от последовательности этого генератора случайных чисел.
void	nextBytes(byte[] bytes) Генерирует случайные байты и размещает их в предоставленный пользователем байтовый массив.
double	nextDouble() Возвращает следующее псевдослучайное, однородно распределенное double значение между 0.0 и 1.0 от последовательности этого генератора случайных чисел.
float	nextFloat() Возвращает следующее псевдослучайное, однородно распределенное float значение между 0.0 и 1.0 от последовательности этого генератора случайных чисел.
double	nextGaussian() Возвращает следующее псевдослучайное, Гауссово ("обычно") распределяемое double значение со средним значением 0.0 и стандартное отклонение 1.0 от последовательности этого генератора случайных чисел.
int	nextInt() Возвращает следующее псевдослучайное, однородно распределенное int значение от последовательности этого генератора случайных чисел.
int	nextInt(int n) Возвращает псевдослучайное, однородно распределенное int значение между 0 (содержащий) и указанное значение (монопольное), оттянутое из последовательности этого генератора случайных чисел.
long	nextLong() Возвращает следующее псевдослучайное, однородно распределенное long значение от последовательности этого генератора случайных чисел.
void	setSeed(long seed) Устанавливает семя этого генератора случайных чисел, используя сингл long семя.

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

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

Деталь конструктора

Случайный

public Random()

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

Случайный

public Random(long seed)

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

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

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

Параметры:

seed - начальное семя

См. Также:

setSeed(long)

Деталь метода

setSeed

public void setSeed(long seed)

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

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

и очистка haveNextNextGaussian флаг, используемый nextGaussian().

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

Параметры:

seed - начальное семя

затем

protected int next(int bits)

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

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

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

и возврат

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

Это - линейный congruential генератор псевдослучайного числа, как определено Д. Х. Лехмером и описало Дональдом Э. Нутом в Искусстве Программирования, Объем 3: получисловые Алгоритмы, раздел 3.2.1.

Параметры:

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

Возвраты:

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

С тех пор:

1.1

nextBytes

public void nextBytes(byte[] bytes)

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

Метод nextBytes реализуется class 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 - если байтовый массив является нулем

С тех пор:

1.1

nextInt

public int nextInt()

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

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

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

Возвраты:

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

nextInt

public int nextInt(int n)

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

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

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

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

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

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

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

Параметры:

n - привязанный случайное число, которое будет возвращено. Должно быть положительным.

Возвраты:

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

Броски:

IllegalArgumentException - если n не положителен

С тех пор:

1.2

nextLong

public long nextLong()

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

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

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

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

Возвраты:

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

nextBoolean

public boolean nextBoolean()

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

Метод nextBoolean реализуется class 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 (монопольный), псевдобеспорядочно сгенерирован и возвращен. Все возможные ²²⁴ float значения формы м. x ^2-24, где м. является положительным целым числом ^{меньше чем 224}, производятся с (приблизительно) равной вероятностью.

Метод nextFloat реализуется class 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 реализуется class 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()

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

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

Метод nextGaussian реализуется class 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, алгоритм П. Ноут, что это генерирует два независимых значения за счет только одного звонка StrictMath.log и один звонок StrictMath.sqrt.

Возвраты:

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

ints

public IntStream ints()

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

Возвраты:

бесконечный поток integer значения

С тех пор:

1.8

longs

public LongStream longs()

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

Возвраты:

бесконечный поток long значения

С тех пор:

1.8

удваивается

public DoubleStream doubles()

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

Возвраты:

бесконечный поток double значения

С тех пор:

1.8

gaussians

public DoubleStream gaussians()

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

Возвраты:

бесконечный поток double значения

С тех пор:

1.8