Генерируем случайное число java

Random Date

Up until now, we generated random temporals containing both date and time components. Similarly, we can use the concept of epoch days to generate random temporals with just date components.

An epoch day is equal to the number of days since the 1 January 1970. So in order to generate a random date, we just have to generate a random number and use that number as the epoch day.

3.1. Bounded

We need a temporal abstraction containing only date components, so java.time.LocalDate seems a good candidate:

Here we’re using the  method to convert each LocalDate to its corresponding epoch day. Similarly, we can verify that this approach is correct:

3.2. Unbounded

In order to generate random dates regardless of any range, we can simply generate a random epoch day:

Our random date generator chooses a random day from 100 years before and after the epoch. Again, the rationale behind this is to generate reasonable date values:

Node.js Series Overview

Prev
|
Next

1. Increase the Memory Limit for Your Process

2. Why You Should Add “node” in Your Travis Config

3. Create a PDF from HTML with Puppeteer and Handlebars

4. Create Your Own Custom Error

5. Retrieve a Request’s IP Address in Node.js

6. Detect the Node.js Version in a Running Process or App

Prev
|
Next

1. String Replace All Appearances

2. Remove All Whitespace From a String in JavaScript

3. Generate a Random String in Node.js or JavaScript

4. Remove Extra Spaces From a String in JavaScript or Node.js

5. Remove Numbers From a String in JavaScript or Node.js

6. Get the Part Before a Character in a String in JavaScript or Node.js

7. Get the Part After a Character in a String in JavaScript or Node.js

8. How to Check if a Value is a String in JavaScript or Node.js

9. Check If a String Includes All Strings in JavaScript/Node.js/TypeScript

10. Check if a Value is a String in JavaScript and Node.js

11. Limit and Truncate a String to a Given Length in JavaScript and Node.js

Prev
|
Next

1. Filter Data in Streams

Prev
|
Next

1. Get Number of Seconds Since Epoch in JavaScript

2. Get Tomorrow’s Date in JavaScript

3. Increase a Date in JavaScript by One Week

4. Add Seconds to a Date in Node.js and JavaScript

5. Add Month(s) to a Date in JavaScript or Node.js

Prev
|
Next

1. How to Run an Asynchronous Function in Array.map()

2. How to Reset and Empty an Array

3. for…of vs. for…in Loops

4. Clone/Copy an Array in JavaScript and Node.js

5. Get an Array With Unique Values (Delete Duplicates)

6. Sort an Array of Integers in JavaScript and Node.js

7. Sort a Boolean Array in JavaScript, TypeScript, or Node.js

8. Check If an Array Contains a Given Value in JavaScript or Node.js

9. Add an Item to the Beginning of an Array in JavaScript or Node.js

10. Append an Item at the End of an Array in JavaScript or Node.js

11. How to Exit and Stop a for Loop in JavaScript and Node.js

12. Split an Array Into Smaller Array Chunks in JavaScript and Node.js

13. How to Get an Index in a for…of Loop in JavaScript and Node.js

14. How to Exit, Stop, or Break an Array#forEach Loop in JavaScript or Node.js

Prev
|
Next

1. Callback and Promise Support in your Node.js Modules

2. Run Async Functions/Promises in Sequence

3. Run Async Functions/Promises in Parallel

4. Run Async Functions in Batches

5. How to Fix “Promise resolver undefined is not a function” in Node.js or JavaScript

6. Detect if Value Is a Promise in Node.js and JavaScript

Prev
|
Next

1. Human-Readable JSON.stringify() With Spaces and Line Breaks

2. Write a JSON Object to a File

3. Create a Custom “toJSON” Function in Node.js and JavaScript

Prev
|
Next

1. Extend Multiple Classes (Multi Inheritance)

2. Retrieve the Class Name at Runtime in JavaScript and Node.js

Prev
|
Next

1. Generate a Random Number in Range With JavaScript/Node.js

Prev
|
Next

1. How to Merge Objects

2. How to Check if an Object is Empty in JavaScript or Node.js

3. How to CamelCase Keys of an Object in JavaScript or Node.js

Prev
|
Next

1. Get a File’s Created Date

2. Get a File’s Last Modified/Updated Date

3. How to Create an Empty File

4. Check If a Path or File Exists

5. How to Rename a File

6. Check If a Path Is a Directory

7. Check If a Path Is a File

8. Retrieve the Path to the User’s Home Directory

9. How to Touch a File

Зачем нужны функции getstate() и setstate() ?

Если вы получили предыдущее состояние и восстановили его, тогда вы сможете оперировать одними и теми же случайными данными раз за разом. Помните, что использовать другую функцию random в данном случае нельзя. Также нельзя изменить значения заданных параметров. Сделав это, вы измените значение состояния .

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

Python

import random

number_list =

print(«Первая выборка «, random.sample(number_list,k=5))

# хранит текущее состояние в объекте state
state = random.getstate()

print(«Вторая выборка «, random.sample(number_list,k=5))

# Восстанавливает состояние state, используя setstate
random.setstate(state)

#Теперь будет выведен тот же список второй выборки
print(«Третья выборка «, random.sample(number_list,k=5))

# Восстанавливает текущее состояние state
random.setstate(state)

# Вновь будет выведен тот же список второй выборки
print(«Четвертая выборка «, random.sample(number_list,k=5))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

importrandom number_list=3,6,9,12,15,18,21,24,27,30 print(«Первая выборка «,random.sample(number_list,k=5))   # хранит текущее состояние в объекте state state=random.getstate() print(«Вторая выборка «,random.sample(number_list,k=5))   # Восстанавливает состояние state, используя setstate random.setstate(state)   #Теперь будет выведен тот же список второй выборки print(«Третья выборка «,random.sample(number_list,k=5))   # Восстанавливает текущее состояние state random.setstate(state)   # Вновь будет выведен тот же список второй выборки print(«Четвертая выборка «,random.sample(number_list,k=5))

Вывод:

Shell

Первая выборка
Вторая выборка
Третья выборка
Четвертая выборка

1 2 3 4

Перваявыборка18,15,30,9,6 Втораявыборка27,15,12,9,6 Третьявыборка27,15,12,9,6 Четвертаявыборка27,15,12,9,6

Как можно заметить в результате вывода — мы получили одинаковые наборы данных. Это произошло из-за сброса генератора случайных данных.

Using Java API

The Java API provides us with several ways to achieve our purpose. Let’s see some of them.

2.1. java.lang.Math

The random method of the Math class will return a double value in a range from 0.0 (inclusive) to 1.0 (exclusive). Let’s see how we’d use it to get a random number in a given range defined by min and max:

2.2. java.util.Random

Before Java 1.7, the most popular way of generating random numbers was using nextInt. There were two ways of using this method, with and without parameters. The no-parameter invocation returns any of the int values with approximately equal probability. So, it’s very likely that we’ll get negative numbers:

If we use the netxInt invocation with the bound parameter, we’ll get numbers within a range:

This will give us a number between 0 (inclusive) and parameter (exclusive). So, the bound parameter must be greater than 0. Otherwise, we’ll get a java.lang.IllegalArgumentException.

Java 8 introduced the new ints methods that return a java.util.stream.IntStream. Let’s see how to use them.

The ints method without parameters returns an unlimited stream of int values:

We can also pass in a single parameter to limit the stream size:

And, of course, we can set the maximum and minimum for the generated range:

2.3. java.util.concurrent.ThreadLocalRandom

Java 1.7 release brought us a new and more efficient way of generating random numbers via the ThreadLocalRandom class. This one has three important differences from the Random class:

• We don’t need to explicitly initiate a new instance of ThreadLocalRandom. This helps us to avoid mistakes of creating lots of useless instances and wasting garbage collector time
• We can’t set the seed for ThreadLocalRandom, which can lead to a real problem. If we need to set the seed, then we should avoid this way of generating random numbers
• Random class doesn’t perform well in multi-threaded environments

Now, let’s see how it works:

With Java 8 or above, we have new possibilities. Firstly, we have two variations for the nextInt method:

Secondly, and more importantly, we can use the ints method:

2.4. java.util.SplittableRandom

Java 8 has also brought us a really fast generator — the SplittableRandom class.

As we can see in the JavaDoc, this is a generator for use in parallel computations. It’s important to know that the instances are not thread-safe. So, we have to take care when using this class.

We have available the nextInt and ints methods. With nextInt we can set directly the top and bottom range using the two parameters invocation:

This way of using checks that the max parameter is bigger than min. Otherwise, we’ll get an IllegalArgumentException. However, it doesn’t check if we work with positive or negative numbers. So, any of the parameters can be negative. Also, we have available one- and zero-parameter invocations. Those work in the same way as we have described before.

We have available the ints methods, too. This means that we can easily get a stream of int values. To clarify, we can choose to have a limited or unlimited stream. For a limited stream, we can set the top and bottom for the number generation range:

2.5. java.security.SecureRandom

If we have security-sensitive applications, we should consider using SecureRandom. This is a cryptographically strong generator. Default-constructed instances don’t use cryptographically random seeds. So, we should either:

• Set the seed — consequently, the seed will be unpredictable
• Set the java.util.secureRandomSeed system property to true

This class inherits from java.util.Random. So, we have available all the methods we saw above. For example, if we need to get any of the int values, then we’ll call nextInt without parameters:

On the other hand, if we need to set the range, we can call it with the bound parameter:

We must remember that this way of using it throws IllegalArgumentException if the parameter is not bigger than zero.

The Rolling Dice Game

In this section, we will create a really simple mini dice game. Two players enter their name and will roll the dice. The player whose dice has a higher number will win the round.

First, create a function that simulates the action for rolling the dice.

Inside the function body, call the function with and as the arguments. This will give you any random number between 1 and 6 (both inclusive) just like how real dice would work.

Next, create two input fields and a button as shown below:

When the ‘Roll Dice’ button is clicked, get the player names from the input fields and call the function for each player.

You can validate the players’ name fields and prettify the markup with some CSS. For the purpose of brevity, I’m keeping it simple for this guide.

That is it. You can check out the demo here.

Usage

ES6

Each method has signature, where is optional.

import {
  generateIntegers,
  generateDecimalFractions,
  generateGaussians,
  generateStrings,
  generateUUIDs,
  generateBlobs,
  getUsage,
  generateSignedIntegers,
  generateSignedDecimalFractions,
  generateSignedGaussians,
  generateSignedStrings,
  generateSignedUUIDs,
  generateSignedBlobs,
  verifySignature,

  // special
  request,
  RandomOrg
} from 'randomorg-js'

CommonJS / Node.JS

Notice that Node > 4 is required for feature.

const {
  generateIntegers,
  generateDecimalFractions,
  generateGaussians,
  generateStrings,
  // ...
  generateSignedBlobs,
  verifySignature,

  // special
  request,
  RandomOrg
} = require('randomorg-js')

So you simply can just use old way

var randomorg = require('randomorg-js')

console.log(randomorg)
console.log(randomorg.generateIntegers)
console.log(randomorg.generateDecimalFractions)
console.log(randomorg.verifySignature)
console.log(randomorg.request)
console.log(randomorg.RandomOrg)
// and etc.

Example

const params = {
  apiKey: 'your api key',
  n: 6,
  min: 1,
  max: 6
}

generateIntegers(params, (err, response) => {
  // there may have `err` or `response.error`
  console.log(err || response.error)

  // response is exactly what the API spec
  // defines as response object
  console.log(response)
  console.log(response.id)
  console.log(response.result)
})

Or using the method

request('generateSignedStrings', {
  n: 8,
  length: 10,
  characters: 'ab!~cdefg+_-hijk@lmn#$%opqr^stuvwxyz',
}, (err, response) => {
  console.log(err, response)
})

By default the package exports all methods with randomly generated . To change that, the onoe way can be to add as first argument to each method e.g. ; or the second variant is to call the which returns the same methods and they will use the defined from the constructor.

const { RandomOrg } = require('randomorg-js')

const random = RandomOrg(123555)

random.generateSignedBlobs({
 apiKey: 'your api key here',
 and: 'other params for that method'
}, (er, { id, result }) => {
  // response always has the same ID what
  // user has provided
  console.log(id) // => 123555
  console.log(result) // => random Signed Blobs
})

// but you still can provide
// different `id` to same method
random.generateSignedBlobs(4444, params, (e, { id }) => {
  console.log(id) // => 4444
})

// or to some other method
random.generateIntegers(2938742, params, (e, { id }) => {
  console.log(id) // => 2938742
})

Примеры

Чтобы воспользоваться возможностями генерации случайных чисел в Python 3, следует произвести импорт библиотеки random, вынеся ее в начало исполняемого файла при помощи ключевого слова import.

Вещественные числа

В модуле есть одноименная функция random. В Python она используется чаще, чем другие функции этого модуля. Функция возвращает вещественное число в промежутке от 0 до 1. В следующем примере демонстрируется создание трех разных переменных a, b и c.

import random
a = random.random()
b = random.random()
print(a)
print(b)

0.547933286519
0.456436031781

Целые числа

Для получения случайных целых чисел в определенном диапазоне используется функция randint, принимающая два аргумента: минимальное и максимальное значение. Программа, показанная ниже отображает генерацию трех разных значений в промежутке от 0 до 9.

import random
a = random.randint(0, 9)
b = random.randint(0, 9)
print(a)
print(b)

4
7

Диапазоны целых

Метод randrange позволяет генерировать целочисленные значения, благодаря работе с тремя параметрами: минимальная и максимальная величина, а также длина шага. Вызвав функцию с одним аргументом, начальная граница получит значение 0, а интервал станет равен 1. Для двух аргументов автоматически инициализируется только длина шага. Работа данного метода с трема разными наборами параметров показана в следующем примере.

import random
a = random.randrange(10)
b = random.randrange(2, 10)
c = random.randrange(2, 10, 2)
print(a)
print(b)
print(c)

9
5
2

Диапазоны вещественных

Сгенерировать вещественное число поможет метод под названием uniform. Он принимает всего два аргумента, обозначающих минимальное и максимальное значения. Демонстрация его работы располагается в следующем примере кода, где создаются переменные a, b и c.

import random
a = random.uniform(0, 10)
b = random.uniform(0, 10)
print(a)
print(b)

4.85687375091
3.66695202551

Использование в генераторах

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

import random
a = 
print(a)

Перемешивание

Метод shuffle дает возможность перемешать содержимое уже созданного списка. Таким образом, все его элементы будут находиться в абсолютно случайном порядке. Пример, где отображается работа этой функции со списком a из 10 значений, располагается дальше.

import random
a = 
random.shuffle(a)
print(a)

Случайный элемент списка

При помощи функции choice можно извлечь случайный элемент из существующего набора данных. В следующем примере переменная b получает некое целое число из списка a.

import random
a = 
b = random.choice(a)
print(b)

7

Несколько элементов списка

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

import random
a = 
a = random.sample(a, 5)
print(a)

Генерация букв

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

import random
import string
a = random.choice(string.letters)
b = random.choice(string.letters)
c = random.choice(string.letters)
print(a)
print(b)
print(c)

J
i
L

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

SystemRandom

Как уже говорилось ранее, SystemRandom основана на os.urandom. Она выдает так же псевдослучайные данные, но они зависят дополнительно и от операционной системы. Результаты используются в криптографии. Есть недостаток — то что функции SystemRandom отрабатывают в несколько раз дольше. Рассмотрим пример использования:

import random
sr = random.SystemRandom()
a = sr.random()
b = sr.randint(0, 9)
c = sr.randrange(2, 10, 2)
print(a)
print(b)
print(c)

0.36012464614815465
2
8

Генерация случайных чисел с помощью класса Math

Чтобы сгенерировать случайное число Java предоставляет класс Math, доступный в пакете java.util. Этот класс содержит статичный метод Math.random(), предназначенный для генерации случайных чисел типа double .

Метод random( ) возвращает положительное число большее или равное 0,0 и меньшее 1,0. При вызове данного метода создается объект генератора псевдослучайных чисел java.util.Random.

Math.random() можно использовать с параметрами и без. В параметрах задается диапазон чисел, в пределах которого будут генерироваться случайные значения.

Пример использования Math.random():

public static double getRandomNumber(){
    double x = Math.random();
    return x;
}

Метод getRandomNumber( ) использует Math.random() для возврата положительного числа, которое больше или равно 0,0 или меньше 1,0 .

Результат выполнения кода:

Double between 0.0 and 1.0: SimpleRandomNumber = 0.21753313144345698

Случайные числа в заданном диапазоне

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

(Math.random() * ((max - min) + 1)) + min

Разобьем это выражение на части:

1. Сначала умножаем диапазон значений на результат, который генерирует метод random().Math.random() * (max — min)возвращает значение в диапазоне , где max не входит в заданные рамки. Например, выражение Math.random()*5 вернет значение в диапазоне , в который 5 не входит.
2. Расширяем охват до нужного диапазона. Это делается с помощью минимального значения.

(Math.random() * ( max - min )) + min

Но выражение по-прежнему не охватывает максимальное значение.

Чтобы получить максимальное значение, прибавьте 1 к параметру диапазона (max — min). Это вернет случайное число в указанном диапазоне.

double x = (Math.random()*((max-min)+1))+min;

Существуют различные способы реализации приведенного выше выражения. Рассмотрим некоторые из них.

Случайное двойное число в заданном диапазоне

По умолчанию метод Math.random() при каждом вызове возвращает случайное число типа double . Например:

public static double getRandomDoubleBetweenRange(double min, double max){
    double x = (Math.random()*((max-min)+1))+min;
    return x;
}

Вы можете вызвать предыдущий метод из метода main, передав аргументы, подобные этому.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber = 
"+getRandomDoubleBetweenRange(5.0, 10.00));

Результат.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber = 
"+getRandomDoubleBetweenRange(5.0, 10.00));

Случайное целое число в заданном диапазоне

Пример генерации случайного целочисленного значения в указанном диапазоне:

public static double getRandomIntegerBetweenRange(double min, double max){
    double x = (int)(Math.random()*((max-min)+1))+min;
    return x;
}

Метод getRandomIntegerBetweenRange() создает случайное целое число в указанном диапазоне. Так как Math.random() генерирует случайные числа с плавающей запятой, то нужно привести полученное значение к типу int. Этот метод можно вызвать из метода main, передав ему аргументы следующим образом:

System.out.println("Integer between 2 and 6: RandomIntegerNumber 
= "+getRandomIntegerBetweenRange(2,6));

Результат.

Integer between 2 and 6: RandomIntegerNumber = 5

Примечание. В аргументах также можно передать диапазон отрицательных значений, чтобы сгенерировать случайное отрицательное число в этом диапазоне.

Вопрос 1. Что такое случайные числа?

Сложность: 1/3

Что нужно помнить: случайные числа — это математическое понятие, и их не следует путать с обыденными, произвольными числами. Случайное число в математике и программировании — это:

• число из определённого диапазона,
• у которого есть определённая вероятность выпадения.

Другими словами, существует закон или правило, которое называется «функцией распределения» или просто «распределением». И это самое распределение «раздаёт» каждому числу из диапазона определённую вероятность выпадения.

В качестве диапазона значений математикам и программистам привычнее всего использовать диапазон действительных чисел от 0 до 1, но это могут быть и целые числа от 1 до 6, как в игральном кубике, или от 100 до 1 000 000 — и так далее. Главное, что и распределение, и диапазон известны заранее, а само число нет.

Итого: случайные числа — это искусственно полученная последовательность чисел из определённого диапазона, которая подчиняется одному из законов распределения случайной величины.

Random Number Generation Using the Random Class

You can use the java.util.Random class to generate random numbers of different types, such as int, float, double, long, and boolean.

To generate random numbers, first, create an instance of the Random class and then call one of the random value generator methods, such as nextInt(), nextDouble(), or nextLong().

The nextInt() method of Random accepts a bound integer and returns a random integer from 0 (inclusive) to the specified bound (exclusive).

The code to use the nextInt() method is this.

The code to use the nextInt() method to generate an integer within a range is:

The nextFloat() and nextDouble() methods allow generating float and double values between 0.0 and 1.0.

The code to use both the methods is:

Random Number Generation Features in Java 8

Java 8 introduced a new method, ints(), in the java.util.Random class. The ints() method returns an unlimited stream of pseudorandom int values. You can limit the random numbers between a specified range by providing the minimum and the maximum values.

The code to use the Random.ints() method to generate random integer values within a specified range is this.

The getRandomNumberInts() method generates a stream of random integers between the min (inclusive) and max (exclusive). As ints() method produces an IntStream, the code calls the findFirst() method that returns an OptionalInt object that describes the first element of this stream. The code then calls the getAsInt()method to return the int value in OptionalInt.

The code to use the Random.ints() method to generate a stream of specified random integer values is:

The code to call the preceding method is:

The output of the preceding code is:

The code to use the Random.ints() method to generate a stream of a specified number of random integer values between a range is:

The code to call the preceding method is:

The output of the preceding code is:

In addition to ints(), some other frequently used methods that Java 8 introduced to the Random class — which can return a sequential stream of random numbers — are:

• LongStream longs()
• DoubleStream doubles()

Класс Random

В качестве генератора псевдослучайных чисел можно также использовать класс java.util.Random, имеющий два
конструктора :

public Random();
public Random(long);

Поскольку Random создаёт псевдослучайное число, то определив начальное число, устанавливается начальная точка
случайной последовательности, способствующая получению одинаковых случайных последовательностей. Чтобы избежать такого
совпадения, обычно применяют второй конструктор с использованием в качестве инициирующего значения текущего времени.
В таблице представлены наиболее часто используемые методы генератора Random :

Метод	Описание
boolean nextBoolean()	получение следующего случайного значения типа boolean
double nextDouble()	получение следующего случайного значения типа double
float nextFloat()	получение следующего случайного значения типа float
int nextInt()	получение следующего случайного значения типа int
int nextInt(int n)	получение следующего случайного значения типа int в диапазоне от 0 до n
long nextLong()	получение следующего случайного значения типа long
void nextBytes(byte[] buf)	формирование массива из случайно генерируемых значений

Пример получения псевдослучайного целочисленного значения с использованием класса Random :

Random random = new Random();

int i = random.nextInt();

С классом Random алгоритм получения псевдослучайного числа такой же, как и у метода random классаMath. Допустим, что нам необходимо получить случайное число в диапазоне , 100 включительно. В этом случае
код может выглядеть следующим образом :

int min = 5;
int max = 100;
int diff = max - min;
Random random = new Random();
int i = random.nextInt(diff + 1) + min;

Класс SecureRandom

В следующем примере формируется массив псевдослучайных значений типа byte :

SecureRandom random = new SecureRandom();
byte bytes[] = new byte;
random.nextBytes(bytes);

Этот же массив можно сформировать методом generateSeed :

 byte seed[] = random.generateSeed(8);

Пример использования SecureRandom представлен на странице
Симметричного шифрования.

Класс ThreadLocalRandom

В JDK 7 включен класс ThreadLocalRandom из многопоточного пакета
java.util.concurrent, который следует использовать для получения псевдослучайных
значений в многопоточных приложениях. Для получения экземпляра ThreadLocalRandom следует использовать
статический метод current() данного класса. Пример :

ThreadLocalRandom random = ThreadLocalRandom.current();

System.out.println("Random values : ");
System.out.println("boolean : " + random.nextBoolean());
System.out.println("int : "     + random.nextInt    ());
System.out.println("float : "   + random.nextFloat  ());
System.out.println("long : "    + random.nextLong   ());

System.out.println("int from 0 to 5 : "   + 
                                  random.nextInt(5));
System.out.println("long from 5 to 15 : " + 
                                  random.nextLong(5, 15));

Alternate API

There is an alternate API which may be easier to use, but may be less performant. In scenarios where performance is paramount, it is recommended to use the aforementioned API.

constrandom=newRandom(MersenneTwister19937.seedWithArray(0x12345678,0x90abcdef));constvalue=r.integer(,99);constotherRandom=newRandom();

This abstracts the concepts of engines and distributions.

• : Produce an integer within the inclusive range . can be at its minimum -9007199254740992 (2 ** 53). can be at its maximum 9007199254740992 (2 ** 53). The special number is never returned.
• : Produce a floating point number within the range . Uses 53 bits of randomness.
• : Produce a boolean with a 50% chance of it being .
• : Produce a boolean with the specified chance causing it to be .
• : Produce a boolean with / chance of it being true.
• : Return a random value within the provided within the sliced bounds of and .
• : Shuffle the provided (in-place). Similar to .
• : From the array, produce an array with elements that are randomly chosen without repeats.
• : Same as
• : Produce an array of length with as many rolls.
• : Produce a random string using numbers, uppercase and lowercase letters, , and of length .
• : Produce a random string using the provided string as the possible characters to choose from of length .
• or : Produce a random string comprised of numbers or the characters of length .
• : Produce a random string comprised of numbers or the characters of length .
• : Produce a random within the inclusive range of . and must both be s.

How to generate random numbers in Java?

Use the  static method of the Math class to generate random numbers in Java.

1	publicstaticdoublerandom()

This method returns a double number greater than or equal to 0.0 and less than 1.0 (Note that the 0.0 is inclusive while 1.0 is exclusive so that 0 <= n < 1)

a) How to generate a random number between 0 and 1?

1 2 3 4 5 6 7 8 9 10 11 12 13

packagecom.javacodeexamples.mathexamples; publicclassGenerateRandomNumberExample{ publicstaticvoidmain(Stringargs){ System.out.println(«Random numbers between 0 and 1»); for(inti=;i<10;i++){ System.out.println(Math.random()); } } }

Output (could be different for you as these are random numbers)

1 2 3 4 5 6 7 8 9 10 11

Random numbers between 0 and 1 0.12921328590853476 0.7936354242494305 0.08878870565069197 0.12470497778455492 0.1738593303254422 0.6793228890529989 0.5948655601179271 0.9910316469070309 0.1867838198026388 0.6630122474512686

b) Between 0 and 100

It is fairly easy task to generate random numbers between 0 and 100. Since method returns a number between 0.0 and 1.0, multiplying it with 100 and casting the result to an integer will give us a random number between 0 and 100 (where 0 is inclusive while 100 is exclusive).

1 2	intrandomNumber=(int)(Math.random()*100); System.out.println(«Random Number: «+randomNumber);

c) Between a specific range

Since the  method returns a double value between 0.0 and 1.0, we need to derive a formula so that we can generate numbers in the specific range.

Let’s do that step by step. Suppose you want to generate random numbers between 10 and 20. So the minimum number it should generate is 10 and the maximum number should be 20.

Step 1:

First of all, we need to multiply the  method result with the maximum number so that it returns value between 0 to max value (in this case 20) like given below.

1	intrandomNumber=(int)(Math.random()*20);

The above statement will return us a random number between 0.0 and 19. That is because multiplying 0.0 – 0.99 with 20 and casting the result back to int will give us range of the 0 to 19.

Step 2:

Step 1 gives us a random number between 0 and 19. But we want a random number starting from 10, not 0. Let’s add that number to the result.

1	intrandomNumber=10+(int)(Math.random()*20);

Step 3:

Now the number starts from 10 but it goes up to 30. That is because adding 10 to 0-19 will give us 10-29. So let’s subtract 10 from 20 before multiplication operation.

1	intrandomNumber=10+(int)(Math.random()*(20-10));

Step 4:

The random number generated by the above formula gives us a range between 10 and 19 (both inclusive). The number range we wanted was between 10 and 20 (both inclusive). So let’s add 1 to the equation.

1	intrandomNumber=10+(int)(Math.random()*((20-10)+1));

A final result is a random number in the range of 10 to 20.