Class Random
If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers. In order to guarantee this property, particular algorithms are specified for the class Random . Java implementations must use all the algorithms shown here for the class Random , for the sake of absolute portability of Java code. However, subclasses of class Random are permitted to use other algorithms, so long as they adhere to the general contracts for all the methods.
The algorithms implemented by class Random use a protected utility method that on each invocation can supply up to 32 pseudorandomly generated bits.
Many applications will find the method Math.random() simpler to use.
Instances of java.util.Random are threadsafe. However, the concurrent use of the same java.util.Random instance across threads may encounter contention and consequent poor performance. Consider instead using ThreadLocalRandom in multithreaded designs.
Instances of java.util.Random are not cryptographically secure. Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.
Nested Class Summary
Nested classes/interfaces declared in interface java.util.random.RandomGenerator
Constructor Summary
Method Summary
Methods declared in class java.lang.Object
Methods declared in interface java.util.random.RandomGenerator
Constructor Details
Random
Random
Method Details
setSeed
The implementation of setSeed by class Random happens to use only 48 bits of the given seed. In general, however, an overriding method may use all 64 bits of the long argument as a seed value.
The general contract of next is that it returns an int value and if the argument bits is between 1 and 32 (inclusive), then that many low-order bits of the returned value will be (approximately) independently chosen bit values, each of which is (approximately) equally likely to be 0 or 1 . The method next is implemented by class Random by atomically updating the seed to and returning This is a linear congruential pseudorandom number generator, as defined by D. H. Lehmer and described by Donald E. Knuth in The Art of Computer Programming, Volume 2, Third edition: Seminumerical Algorithms , section 3.2.1.
nextBytes
nextInt
nextInt
The hedge «approximately» is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose int values from the stated range with perfect uniformity.
The algorithm is slightly tricky. It rejects values that would result in an uneven distribution (due to the fact that 2^31 is not divisible by n). The probability of a value being rejected depends on n. The worst case is n=2^30+1, for which the probability of a reject is 1/2, and the expected number of iterations before the loop terminates is 2.
The algorithm treats the case where n is a power of two specially: it returns the correct number of high-order bits from the underlying pseudo-random number generator. In the absence of special treatment, the correct number of low-order bits would be returned. Linear congruential pseudo-random number generators such as the one implemented by this class are known to have short periods in the sequence of values of their low-order bits. Thus, this special case greatly increases the length of the sequence of values returned by successive calls to this method if n is a small power of two.
nextLong
nextBoolean
nextFloat
The general contract of nextFloat is that one float value, chosen (approximately) uniformly from the range 0.0f (inclusive) to 1.0f (exclusive), is pseudorandomly generated and returned. All 2 24 possible float values of the form m x 2 -24 , where m is a positive integer less than 2 24 , are produced with (approximately) equal probability.
The hedge «approximately» is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose float values from the stated range with perfect uniformity.
[In early versions of Java, the result was incorrectly calculated as: This might seem to be equivalent, if not better, but in fact it introduced a slight nonuniformity because of the bias in the rounding of floating-point numbers: it was slightly more likely that the low-order bit of the significand would be 0 than that it would be 1.]
nextDouble
The general contract of nextDouble is that one double value, chosen (approximately) uniformly from the range 0.0d (inclusive) to 1.0d (exclusive), is pseudorandomly generated and returned.
The hedge «approximately» is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose double values from the stated range with perfect uniformity.
[In early versions of Java, the result was incorrectly calculated as: This might seem to be equivalent, if not better, but in fact it introduced a large nonuniformity because of the bias in the rounding of floating-point numbers: it was three times as likely that the low-order bit of the significand would be 0 than that it would be 1! This nonuniformity probably doesn’t matter much in practice, but we strive for perfection.]
nextGaussian
The general contract of nextGaussian is that one double value, chosen from (approximately) the usual normal distribution with mean 0.0 and standard deviation 1.0 , is pseudorandomly generated and returned.
A pseudorandom int value is generated as if it’s the result of calling the method nextInt() .
A pseudorandom int value is generated as if it’s the result of calling the method nextInt() .
A pseudorandom int value is generated as if it’s the result of calling the following method with the origin and bound:
A pseudorandom int value is generated as if it’s the result of calling the following method with the origin and bound:
longs
A pseudorandom long value is generated as if it’s the result of calling the method nextLong() .
longs
A pseudorandom long value is generated as if it’s the result of calling the method nextLong() .
longs
A pseudorandom long value is generated as if it’s the result of calling the following method with the origin and bound:
longs
A pseudorandom long value is generated as if it’s the result of calling the following method with the origin and bound:
doubles
A pseudorandom double value is generated as if it’s the result of calling the method nextDouble() .
doubles
A pseudorandom double value is generated as if it’s the result of calling the method nextDouble() .
doubles
A pseudorandom double value is generated as if it’s the result of calling the following method with the origin and bound:
doubles
A pseudorandom double value is generated as if it’s the result of calling the following method with the origin and bound:
Report a bug or suggest an enhancement
For further API reference and developer documentation see the Java SE Documentation, which contains more detailed, developer-targeted descriptions with conceptual overviews, definitions of terms, workarounds, and working code examples. Other versions.
Java is a trademark or registered trademark of Oracle and/or its affiliates in the US and other countries.
Copyright © 1993, 2022, Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
All rights reserved. Use is subject to license terms and the documentation redistribution policy.
Random java как работает
If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers. In order to guarantee this property, particular algorithms are specified for the class Random . Java implementations must use all the algorithms shown here for the class Random , for the sake of absolute portability of Java code. However, subclasses of class Random are permitted to use other algorithms, so long as they adhere to the general contracts for all the methods.
The algorithms implemented by class Random use a protected utility method that on each invocation can supply up to 32 pseudorandomly generated bits.
Many applications will find the method Math.random() simpler to use.
Instances of java.util.Random are threadsafe. However, the concurrent use of the same java.util.Random instance across threads may encounter contention and consequent poor performance. Consider instead using ThreadLocalRandom in multithreaded designs.
Instances of java.util.Random are not cryptographically secure. Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.
Constructor Summary
Method Summary
| Modifier and Type | Method and Description |
|---|---|
| DoubleStream | doubles () |
Methods inherited from class java.lang.Object
Constructor Detail
Random
Random
The invocation new Random(seed) is equivalent to:
Method Detail
setSeed
The implementation of setSeed by class Random happens to use only 48 bits of the given seed. In general, however, an overriding method may use all 64 bits of the long argument as a seed value.
The general contract of next is that it returns an int value and if the argument bits is between 1 and 32 (inclusive), then that many low-order bits of the returned value will be (approximately) independently chosen bit values, each of which is (approximately) equally likely to be 0 or 1 . The method next is implemented by class Random by atomically updating the seed to and returning This is a linear congruential pseudorandom number generator, as defined by D. H. Lehmer and described by Donald E. Knuth in The Art of Computer Programming, Volume 3: Seminumerical Algorithms, section 3.2.1.
nextBytes
The method nextBytes is implemented by class Random as if by:
nextInt
The method nextInt is implemented by class Random as if by:
nextInt
The hedge «approximately» is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose int values from the stated range with perfect uniformity.
The algorithm is slightly tricky. It rejects values that would result in an uneven distribution (due to the fact that 2^31 is not divisible by n). The probability of a value being rejected depends on n. The worst case is n=2^30+1, for which the probability of a reject is 1/2, and the expected number of iterations before the loop terminates is 2.
The algorithm treats the case where n is a power of two specially: it returns the correct number of high-order bits from the underlying pseudo-random number generator. In the absence of special treatment, the correct number of low-order bits would be returned. Linear congruential pseudo-random number generators such as the one implemented by this class are known to have short periods in the sequence of values of their low-order bits. Thus, this special case greatly increases the length of the sequence of values returned by successive calls to this method if n is a small power of two.
nextLong
The method nextLong is implemented by class Random as if by: Because class Random uses a seed with only 48 bits, this algorithm will not return all possible long values.
nextBoolean
The method nextBoolean is implemented by class Random as if by:
nextFloat
The general contract of nextFloat is that one float value, chosen (approximately) uniformly from the range 0.0f (inclusive) to 1.0f (exclusive), is pseudorandomly generated and returned. All 2 24 possible float values of the form m x 2 -24 , where m is a positive integer less than 2 24 , are produced with (approximately) equal probability.
The method nextFloat is implemented by class Random as if by:
The hedge «approximately» is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose float values from the stated range with perfect uniformity.
[In early versions of Java, the result was incorrectly calculated as: This might seem to be equivalent, if not better, but in fact it introduced a slight nonuniformity because of the bias in the rounding of floating-point numbers: it was slightly more likely that the low-order bit of the significand would be 0 than that it would be 1.]
nextDouble
The general contract of nextDouble is that one double value, chosen (approximately) uniformly from the range 0.0d (inclusive) to 1.0d (exclusive), is pseudorandomly generated and returned.
The method nextDouble is implemented by class Random as if by:
The hedge «approximately» is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose double values from the stated range with perfect uniformity.
[In early versions of Java, the result was incorrectly calculated as: This might seem to be equivalent, if not better, but in fact it introduced a large nonuniformity because of the bias in the rounding of floating-point numbers: it was three times as likely that the low-order bit of the significand would be 0 than that it would be 1! This nonuniformity probably doesn’t matter much in practice, but we strive for perfection.]
nextGaussian
The general contract of nextGaussian is that one double value, chosen from (approximately) the usual normal distribution with mean 0.0 and standard deviation 1.0 , is pseudorandomly generated and returned.
The method nextGaussian is implemented by class Random as if by a threadsafe version of the following: This uses the polar method of G. E. P. Box, M. E. Muller, and G. Marsaglia, as described by Donald E. Knuth in The Art of Computer Programming, Volume 3: Seminumerical Algorithms, section 3.4.1, subsection C, algorithm P. Note that it generates two independent values at the cost of only one call to StrictMath.log and one call to StrictMath.sqrt .
A pseudorandom int value is generated as if it’s the result of calling the method nextInt() .
A pseudorandom int value is generated as if it’s the result of calling the method nextInt() .
A pseudorandom int value is generated as if it’s the result of calling the following method with the origin and bound:
A pseudorandom int value is generated as if it’s the result of calling the following method with the origin and bound:
longs
A pseudorandom long value is generated as if it’s the result of calling the method nextLong() .
longs
A pseudorandom long value is generated as if it’s the result of calling the method nextLong() .
longs
A pseudorandom long value is generated as if it’s the result of calling the following method with the origin and bound:
longs
A pseudorandom long value is generated as if it’s the result of calling the following method with the origin and bound:
doubles
A pseudorandom double value is generated as if it’s the result of calling the method nextDouble() .
doubles
A pseudorandom double value is generated as if it’s the result of calling the method nextDouble() .
doubles
A pseudorandom double value is generated as if it’s the result of calling the following method with the origin and bound:
doubles
A pseudorandom double value is generated as if it’s the result of calling the following method with the origin and bound:
- Summary:
- Nested |
- Field | |
- Detail:
- Field | |
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2023, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.
Класс Random
Класс java.util.Random представляет собой генератор псевдослучайных чисел.
Класс представлен двумя конструкторами
- Random() — создаёт генератор чисел, использующий уникальное начальное число
- Random(long seed) — позволяет указать начальное число вручную
Так как класс создаёт псевдослучайное число, то задав начальное число, вы определяете начальную точку случайной последовательности. И будете получать одинаковые случайные последовательности. Чтобы избежать такого совпадения, обычно используют второй конструктор с использованием текущего времени в качестве инициирующего значения.
- boolean nextBoolean() — возвращает следующее случайное значение типа boolean
- void nextBytes(byte[] buf) — заполняет массив случайно созданными значениями
- double nextDouble() — возвращает следующее случайное значение типа double
- float nextFloat() — возвращает следующее случайное значение типа float
- synchronized double nextGaussian() — возвращает следующее случайное значение гауссова случайного числа, т.е. значения, центрированное по 0.0 со стандартным отклонением в 1.0 (кривая нормального распределения)
- int nextInt(int n) — возвращает следующее случайное значение типа int в диапазоне от 0 до n
- int nextInt() — возвращает следующее случайное значение типа int
- long nextLong() — возвращает следующее случайное значение типа long
- synchronized void setSeeD(long seed) — устанавливает начальное значение
Пример для вывода случайного числа.
Случайные числа часто используются в играх. Допустим, мы хотим вывести случайные числа от 1 до 6 при бросании игрального кубика. Попробуем.
При проверке вы заметите две нестыковки. Во-первых, иногда выпадает число 0, которого нет на кубике, а во-вторых никогда не выпадает число 6. Когда вы помещаете число в параметр метода, то это означает, что выпадают числа в диапазоне от 0 до указанного числа, которое в этот диапазон не входит. Если вы будете использовать число 7, то шестёрка станет выпадать, но по-прежнему будет выпадать число 0. Поэтому пример следует немного отредактировать.
Для генерации 10 чисел типа int используйте код:
Генерация в определённом интервале
Нужны случайные числа от 100 до 200? Пишем код.
Случайные цвета
Работать с числами не слишком интересно. Давайте поработаем со цветом. В Android некоторые цвета имеют конкретные названия, но по сути они являются числами типа int, например, красный цвет имеет константу Color.RED. Вам не надо знать, какое число соответствует этому цвету, так как проще понять по его названию.
Щёлкая по кнопке, вы будете менять её цвет случайным образом.
Лотерея «6 из 49»
Сформируем шесть случайных чисел из 49 и занесём их в списочный массив.
SecureRandom
Стандартный класс Random обычно используют для простых задач, не связанных с шифрованием. Для криптографии следует использовать схожий класс java.security.SecureRandom.
Не забывайте, что в классе Math есть метод random(), возвращающий случайное число от 0 до 1 (единица в диапазон не входит).
# Random Number Generation
Java provides, as part of the utils package, a basic pseudo-random number generator, appropriately named Random . This object can be used to generate a pseudo-random value as any of the built-in numerical datatypes ( int , float , etc). You can also use it to generate a random Boolean value, or a random array of bytes. An example usage is as follows:
NOTE: This class only produces fairly low-quality pseudo-random numbers, and should never be used to generate random numbers for cryptographic operations or other situations where higher-quality randomness is critical (For that, you would want to use the SecureRandom class, as noted below). An explanation for the distinction between "secure" and "insecure" randomness is beyond the scope of this example.
# Pseudo Random Numbers in Specific Range
The method nextInt(int bound) of Random accepts an upper exclusive boundary, i.e. a number that the returned random value must be less than. However, only the nextInt method accepts a bound; nextLong , nextDouble etc. do not.
Starting in Java 1.7, you may also use ThreadLocalRandom (source
(opens new window) ). This class provides a thread-safe PRNG (pseudo-random number generator). Note that the nextInt method of this class accepts both an upper and lower bound.
(opens new window) states that nextInt(int bound) can do weird things when bound is near 2 30 +1 (emphasis added):
The algorithm is slightly tricky. It rejects values that would result in an uneven distribution (due to the fact that 2^31 is not divisible by n). The probability of a value being rejected depends on n. The worst case is n=2^30+1, for which the probability of a reject is 1/2, and the expected number of iterations before the loop terminates is 2.
In other words, specifying a bound will (slightly) decrease the performance of the nextInt method, and this performance decrease will become more pronounced as the bound approaches half the max int value.
# Generating cryptographically secure pseudorandom numbers
Random and ThreadLocalRandom are good enough for everyday use, but they have a big problem: They are based on a linear congruential generator
(opens new window) , an algorithm whose output can be predicted rather easily. Thus, these two classes are not suitable for cryptographic uses (such as key generation).
One can use java.security.SecureRandom in situations where a PRNG with an output that is very hard to predict is required. Predicting the random numbers created by instances of this class is hard enough to label the class as cryptographically secure.
Besides being cryptographically secure, SecureRandom has a gigantic period of 2 160 , compared to Random s period of 2 48 . It has one drawback of being considerably slower than Random and other linear PRNGs such as Mersenne Twister
Note that SecureRandom implementation is both platform and provider dependent. The default SecureRandom (given by SUN provider in sun.security.provider.SecureRandom ):
- on Unix-like systems, seeded with data from /dev/random and/or /dev/urandom .
- on Windows, seeded with calls to CryptGenRandom() in CryptoAPI
# Generating Random Numbers with a Specified Seed
Using the same seed to generate random numbers will return the same numbers every time, so setting a different seed for every Random instance is a good idea if you don’t want to end up with duplicate numbers.
A good method to get a Long that is different for every call is System.currentTimeMillis()
# Select random numbers without duplicates
The method works by looping though an array that has the size of the requested length and finds the remaining length of possible numbers. It sets a random number of those possible numbers newRandSpot and finds that number within the non taken number left. It does this by looping through the range and checking to see if that number has already been taken.
For example if the range is 5 and the length is 3 and we have already chosen the number 2. Then we have 4 remaining numbers so we get a random number between 1 and 4 and we loop through the range(5) skipping over any numbers that we have already used(2).
Now let’s say the next number chosen between 1 & 4 is 3. On the first loop we get 1 which has not yet been taken so we can remove 1 from 3 making it 2. Now on the second loop we get 2 which has been taken so we do nothing. We follow this pattern until we get to 4 where once we remove 1 it becomes 0 so we set the new randomNumber to 4.
# Generating Random number using apache-common lang3
We can use org.apache.commons.lang3.RandomUtils to generate random numbers using a single line.
The method nextInt(int startInclusive, int endExclusive) takes a range.
Apart from int, we can generate random long , double , float and bytes using this class.
RandomUtils class contains the following methods-
# Remarks
Nothing is really random and thus the javadoc calls those numbers pseudorandom. Those numbers are created with a pseudorandom number generator