java.util

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

java.lang. Объект

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

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

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

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

SecureRandom, ThreadLocalRandom

public class Random
extends Object
implements Serializable

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

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

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

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

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

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

С тех пор:

1.0

См. Также:

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

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

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

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

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

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

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

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

Параметры:

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

затем

protected int next(int bits)

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

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

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

Возвраты:

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

nextInt

public int nextInt(int n)

Возвращает псевдослучайное, однородно распределенное int значение между 0 (содержащий) и указанное значение (монопольное), оттянутое из последовательности этого генератора случайных чисел. Общий контракт nextInt тот int значение в указанном диапазоне псевдобеспорядочно сгенерировано и возвращено. Все n возможный int значения производятся с (приблизительно) равной вероятностью. Метод nextInt(int n) реализуется классом 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 генераторов псевдослучайного числа, таких как тот, реализованный этим классом, как известно, есть короткие периоды в последовательности значений их битов младшего разряда. Таким образом этот особый случай значительно увеличивает длину последовательности значений, возвращенных последовательными звонками в этот метод, если n является маленьким питанием два.

Параметры:

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

Возвраты:

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

Броски:

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

С тех пор:

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

Возвращает следующее псевдослучайное, Гауссово ("обычно") распределяемое 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, алгоритм П. Ноут, что это генерирует два независимых значения за счет только одного звонка StrictMath.log и один звонок StrictMath.sqrt.

Возвраты:

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