Java

Содержание:

Core team and contributors
- - Awesome contributors
ints(long streamSize)
- Syntax
- Example 3 – ints(streamSize)
How to generate secure random number
Игра в кости с использованием модуля random в Python
ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
Random Numbers Using the Math Class
- Random Numbers Within a Given Range
  - Random Double Within a Given Range
  - Random Integer Within a Given Range
Модуль random
Java Random Number Generator
Генерация случайных чисел в заданном диапазоне
ints(randomNumberOrigin, randomNumberBound)
- Syntax
- Example 2 – ints(randomNumberOrigin, randomNumberBound)
Core team and contributors
- - Awesome contributors
Using Java API
How can this be useful ?
Генерация случайных чисел с помощью класса Math
Using Apache Common lang
- Create AlphaNumericString
- Create random Alphabetic String

Core team and contributors

Awesome contributors

Adriano Machado
Alberto Lagna
Andrew Neal
Arne Zelasko
dadiyang
Dovid Kopel
Eric Taix
euZebe
Fred Eckertson
huningd
Johan Kindgren
Joren Inghelbrecht
Jose Manuel Prieto
kermit-the-frog
Lucas Andersson
Michael Düsterhus
Nikola Milivojevic
nrenzoni
Oleksandr Shcherbyna
Petromir Dzhunev
Rebecca McQuary
Rodrigue Alcazar
Ryan Dunckel
Sam Van Overmeire
Valters Vingolds
Vincent Potucek
Weronika Redlarska
Konstantin Lutovich
Steven_Van_Ophem
Jean-Michel Leclercq
Marian Jureczko
Unconditional One
JJ1216
Sergey Chernov

Thank you all for your contributions!

ints(long streamSize)

Random.ints() returns a stream producing the given streamSize number of pseudorandom int values.

Syntax

The syntax of ints() method with stream size is

Random.ints(long streamSize)

where

Parameter	Description
streamSize	The number of values to generate in the stream.

Returns

The method returns IntStream object.

Example 3 – ints(streamSize)

In this example, we will generate eight random integers using ints(streamSize) method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;  

public class Example {  
	public static void main(String[] args) {  
		int streamSize = 8;
		Random random = new Random();  
		IntStream ds = random.ints(streamSize);  

		ds.forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		});
	}  
}

Output

790793602
-445498747
-322809516
1575745272
732465345
586364815
1791511337
-1366525847

How to generate secure random number

Generally, random number generation depends on a source of entropy (randomness) such as signals, devices, or hardware inputs. In Java, The java.security.SecureRandom class is widely used for generating cryptographically strong random numbers.

Deterministic random numbers have been the source of many software security breaches. The idea is that an adversary (hacker) should not be able to determine the original seed given several samples of random numbers. If this restriction is violated, all future random numbers may be successfully predicted by the adversary.

import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;

public class Main 
{
	public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchProviderException 
	{
		SecureRandom secureRandomGenerator = SecureRandom.getInstance("SHA1PRNG", "SUN");
		
		// Get 128 random bytes
		byte[] randomBytes = new byte;
		secureRandomGenerator.nextBytes(randomBytes);
		
		//Get random integer
		int r = secureRandomGenerator.nextInt();
		
		//Get random integer in range
		int randInRange = secureRandomGenerator.nextInt(999999);
	}
}

Игра в кости с использованием модуля random в Python

Далее представлен код простой игры в кости, которая поможет понять принцип работы функций модуля random. В игре два участника и два кубика.

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

Код программы для игры в кости Python:

Python

import random

PlayerOne = «Анна»
PlayerTwo = «Алекс»

AnnaScore = 0
AlexScore = 0

# У каждого кубика шесть возможных значений
diceOne =
diceTwo =

def playDiceGame():
«»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»»

for i in range(5):
#оба кубика встряхиваются 5 раз
random.shuffle(diceOne)
random.shuffle(diceTwo)
firstNumber = random.choice(diceOne) # использование метода choice для выбора случайного значения
SecondNumber = random.choice(diceTwo)
return firstNumber + SecondNumber

print(«Игра в кости использует модуль random\n»)

#Давайте сыграем в кости три раза
for i in range(3):
# определим, кто будет бросать кости первым
AlexTossNumber = random.randint(1, 100) # генерация случайного числа от 1 до 100, включая 100
AnnaTossNumber = random.randrange(1, 101, 1) # генерация случайного числа от 1 до 100, не включая 101

if( AlexTossNumber > AnnaTossNumber):
print(«Алекс выиграл жеребьевку.»)
AlexScore = playDiceGame()
AnnaScore = playDiceGame()
else:
print(«Анна выиграла жеребьевку.»)
AnnaScore = playDiceGame()
AlexScore = playDiceGame()

if(AlexScore > AnnaScore):
print («Алекс выиграл игру в кости. Финальный счет Алекса:», AlexScore, «Финальный счет Анны:», AnnaScore, «\n»)
else:
print(«Анна выиграла игру в кости. Финальный счет Анны:», AnnaScore, «Финальный счет Алекса:», AlexScore, «\n»)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

importrandom

PlayerOne=»Анна»

PlayerTwo=»Алекс»

AnnaScore=

AlexScore=

# У каждого кубика шесть возможных значений

diceOne=1,2,3,4,5,6

diceTwo=1,2,3,4,5,6

defplayDiceGame()

«»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»»

foriinrange(5)

#оба кубика встряхиваются 5 раз

random.shuffle(diceOne)

random.shuffle(diceTwo)

firstNumber=random.choice(diceOne)# использование метода choice для выбора случайного значения

SecondNumber=random.choice(diceTwo)

returnfirstNumber+SecondNumber

print(«Игра в кости использует модуль random\n»)

#Давайте сыграем в кости три раза

foriinrange(3)

# определим, кто будет бросать кости первым

AlexTossNumber=random.randint(1,100)# генерация случайного числа от 1 до 100, включая 100

AnnaTossNumber=random.randrange(1,101,1)# генерация случайного числа от 1 до 100, не включая 101

if(AlexTossNumber>AnnaTossNumber)

print(«Алекс выиграл жеребьевку.»)

AlexScore=playDiceGame()

AnnaScore=playDiceGame()

else

print(«Анна выиграла жеребьевку.»)

AnnaScore=playDiceGame()

AlexScore=playDiceGame()

if(AlexScore>AnnaScore)

print(«Алекс выиграл игру в кости. Финальный счет Алекса:»,AlexScore,»Финальный счет Анны:»,AnnaScore,»\n»)

else

print(«Анна выиграла игру в кости. Финальный счет Анны:»,AnnaScore,»Финальный счет Алекса:»,AlexScore,»\n»)

Вывод:

Shell

Игра в кости использует модуль random

Анна выиграла жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 5 Финальный счет Алекса: 2

Анна выиграла жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 2

Алекс выиграл жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 8

1
2
3
4
5
6
7
8
9
10

Игравкостииспользуетмодульrandom

Аннавыигралажеребьевку.

Аннавыигралаигрувкости.ФинальныйсчетАнны5ФинальныйсчетАлекса2

Аннавыигралажеребьевку.

Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса2

Алексвыигралжеребьевку.

Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса8

Вот и все. Оставить комментарии можете в секции ниже.

ints(long streamSize, int randomNumberOrigin, int randomNumberBound)

Random.ints() Returns a stream producing the given streamSize number of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).

Syntax

The syntax of ints() method with stream size, random number origin and random number bound is

Random.ints(long streamSize, int randomNumberOrigin, int randomNumberBound)

where

Parameter	Description
streamSize	The number of values to generate in the Stream.
randomNumberOrigin	The origin (inclusive) of each random value in the Stream.
randomNumberBound	The bound (exclusive) of each random value in the Stream.

Returns

The method returns IntStream object.

Example 4 – ints(streamSize, randomNumberOrigin, randomNumberBound)

In this example, we will generate eight random integers which are limited by an origin and bound using ints() method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;  

public class Example {  
	public static void main(String[] args) {  
		int streamSize = 8;
		int randomNumberOrigin = 1;  
		int randomNumberBound = 7;  
		Random random = new Random();  
		IntStream ds = random.ints(streamSize, randomNumberOrigin, randomNumberBound);  

		ds.forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		});
	}  
}

Output

Conclusion

In this Java Tutorial, we have learnt the syntax of Java Random.ints() method, and also learnt how to use this method with the help of Java Examples.

Random Numbers Using the Math Class

Java provides the Math class in the java.util package to generate random numbers.

The Math class contains the static Math.random() method to generate random numbers of the double type.

The random() method returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0. When you call Math.random(), under the hood, a java.util.Random pseudorandom-number generator object is created and used.

You can use the Math.random() method with or without passing parameters. If you provide parameters, the method produces random numbers within the given parameters.

The code to use the Math.random() method:

The getRandomNumber() method uses the Math.random() method to return a positive double value that is greater than or equal to 0.0 and less than 1.0.

The output of running the code is:

Random Numbers Within a Given Range

For generating random numbers between a given a range, you need to specify the range. A standard expression for accomplishing this is:

Let us break this expression into steps:

First, multiply the magnitude of the range of values you want to cover by the result that Math.random() produces.returns a value in the range ,max–min where max is excluded. For example, if you want 5,10], you need to cover 5 integer values so you can use Math.random()*5. This would return a value in the range ,5, where 5 is not included.
Next, shift this range up to the range that you are targeting. You do this by adding the min value.

But this still does not include the maximum value.

To get the max value included, you need to add 1 to your range parameter (max — min). This will return a random double within the specified range.

There are different ways of implementing the above expression. Let us look at a couple of them.

Random Double Within a Given Range

By default, the Math.random() method returns a random number of the type double whenever it is called. The code to generate a random double value between a specified range is:

You can call the preceding method from the main method by passing the arguments like this.

The output is this.

Random Integer Within a Given Range

The code to generate a random integer value between a specified range is this.

The preceding getRandomIntegerBetweenRange() method produces a random integer between the given range. As Math.random() method generates random numbers of double type, you need to truncate the decimal part and cast it to int in order to get the integer random number. You can call this method from the main method by passing the arguments as follows:

The output is this.

Note: You can pass a range of negative values to generate a random negative number within the range.

Модуль random

Для того, чтобы полноценно использовать эту опцию в своей работе, необходимо ознакомится с главными ее составляющими. Они выступают некими методами, позволяющими выполнять определенные действия. Основная стандартная библиотека Рython состоит из таких компонентов со следующими параметрами:

random () – может вернуть число в промежуток значений от 0 до 1;
seed (a) – производит настройку генератора на новую последовательность а;
randint (a,b) – возвращает значение в диапазон данных от а до b;
randrange (a, b, c) – выполняет те же функции, что и предыдущая, только с шагом с;
uniform (a, b) – производит возврат вещественного числа в диапазон от а до b;
shuffle (a) – миксует значения, находящиеся в перечне а;
choice (a) – восстанавливает обратно случайный элемент из перечня а;
sample (a, b) – возвращает на исходную позицию последовательность длиной b из перечня а;
getstate () – обновляет внутреннее состояние генератора;
setstate (a) – производит восстановление внутреннего состояния генератора а;
getrandbits (a) – восстанавливает а при выполнении случайного генерирования бит;
triangular (a, b, c) – показывает изначальное значение числа от а до b с шагом с.

Если вам необходимо применить для задания инициализирующееся число псевдо случайной последовательности, то не обойтись без функции seed. После ее вызова без применения параметра, используется значение системного таймера. Эта опция доступна в конструкторе класса Random.

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

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

Модуль оснащен одноименной функцией random. Она более активно используется в Питоне, чем остальные. Эта функция позволяет произвести возврат числа в промежуток значений от 0 до 1. Вот пример трех основных переменных:

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

0.5479332865190.456436031781

Целые числа

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

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

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

Использование в такой ситуации метода randage поможет сгенерировать целочисленные значения, благодаря сотрудничеству с тремя основными параметрами:

минимальное значение;
максимальное;
длина шага.

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

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

952

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

Генерация вещественных чисел происходит при использовании функции под названием uniform. Она регулируется всего двумя параметрами: минимальным и максимальным значением. Пример создания демонстрации с переменными a, b и c.

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

4.856873750913.66695202551

Java Random Number Generator

Let’s look at some examples to generate a random number in Java. Later on, we will also look at ThreadLocalRandom and SecureRandom example program.

1. Generate Random integer

Yes, it’s that simple to generate a random integer in java. When we create the Random instance, it generates a long seed value that is used in all the method calls. We can set this seed value in the program, however, it’s not required in most of the cases.

2. Java Random number between 1 and 10

Sometimes we have to generate a random number between a range. For example, in a dice game possible values can be between 1 to 6 only. Below is the code showing how to generate a random number between 1 and 10 inclusive.

The argument in the is excluded, so we have to provide argument as 11. Also, 0 is included in the generated random number, so we have to keep calling nextInt method until we get a value between 1 and 10. You can extend the above code to generate the random number within any given range.

7. Generate Random byte array

We can generate random bytes and place them into a user-supplied byte array using Random class. The number of random bytes produced is equal to the length of the byte array.

8. ThreadLocalRandom in multithreaded environment

Here is a simple example showing ThreadLocalRandom usage in a multithreaded environment.

Below is a sample output of my execution of the above program.

We can’t set seed value for ThreadLocalRandom instance, it will throw .

ThreadLocalRandom class also has some extra utility methods to generate a random number within a range. For example, to generate a random number between 1 and 10, we can do it like below.

ThreadLocalRandom has similar methods for generating random long and double values.

9. SecureRandom Example

You can use SecureRandom class to generate more secure random numbers using any of the listed providers. A quick SecureRandom example code is given below.

That’s all about generating a random number in Java program.

You can download the example code from our GitHub Repository.

Генерация случайных чисел в заданном диапазоне

Существует несколько способов генерации случайного (псевдослучайного) числа:

Использование метода random() из класса математических функций Math , находящемся в пакете java.lang.

Использование метода random() из класса Random , находящемся в пакете java.util.Random.

Использование генератора случайных чисел класса SecureRandom , предназначенного для целей криптографии и, находящегося в пакете java.security. SecureRandom (здесь не рассматривается).

Рассмотрим методы генерации случайных чисел.

Класс Math. Метод random()

Метод random() класса Math возвращает псевдослучайное число типа double в диапазоне 0 ≤ Math.random()

Пример 1. Несколько случайных чисел

Случайное число № 1: 0.9161994380531232 Случайное число № 2: 0.24340742865928744 Случайное число № 3: 0.9783627451986034

Пример 2. Случайное число x в диапазоне a ≤ x ≤ b

Для генерации целого случайного числа x в заданном диапазоне a ≤ x ≤ b, обычно используется следующая зависимость:

x = a + (int)(Math.random()*((b — a) + 1)).

Получим случайное число x в диапазоне: 10 ≤ x ≤ 20 (a=10, b=20).

Результат.Случайное число x: 19

Класс Random. Метод random()

Это наиболее часто используемый класс для генерации псевдослучайный чисел с равномерной функцией распределения. Имеется метод nextGaussian() , который моделирует функцию нормального распределения.

Основными методами этого класса являются:

int nextInt( ) — возвращает следующее случайное значение ix типа int в диапазоне -2147483648 ≤ ix
int nextInt(int n) — возвращает следующее случайное значение ix типа int в диапазоне 0 ≤ ix
float nextFloat() — возвращает следующее случайное значение fx типа float в диапазоне 0.0 ≤ fx
double nextDouble() — возвращает следующее случайное значение dx типа double в диапазоне 0.0 ≤ dx
boolean nextBoolean() — возвращает следующее случайное значение типа boolean

Для получения случайных чисел необходимо:

Подключить библиотеку случайных чисел. Пишем до определения класса. import java.util.Random;
В классе создать объект rand случайных чисел Random rand = new Random();
Далее использовать необходимые методы объекта rand.

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

Случайное число ix: 1438841988 Случайное число dx: 0.6120986135409442 Случайное число fx: 0.103119016 Случайное число bx: true

Пример 2. Случайное число x в диапазоне a ≤ x ≤ b.

тип int int x = a + rand.nextInt(b — a + 1).

тип double double y = a + rand.nextInt(b — a).

Случайное число x: 12 Случайное число dx: 17.505847041626733

Для типа double будет выведено случайное число в виде:

что неудобно. Для приемлемого представления используется форматный вывод, позволяющий выводить числа с заданной точностью.

Форматный вывод

Пакет java.io содержит класс PrintStream , который содержит методы printf и forma t, позволяющие выводить числа с заданной точностью. Рассмотрим метод format(). Синтаксис метода

System.out.format(String format, Object. args),

format — это строка — шаблон, согласно которому будет происходить форматирование, args — это список переменных, для вывода по заданному шаблону.

Строка — шаблон содержит обычный текст и специальные форматирующие символы. Эти символы начинаются со знака процента (%) и заканчиваются конвертором — символом, который определяет тип переменной для форматирования. Вот некоторые конверторы:

Источник

ints(randomNumberOrigin, randomNumberBound)

Random.ints() returns an effectively unlimited stream of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).

Syntax

The syntax of ints() method with random number origin and random number bound is

Random.ints(int randomNumberOrigin, int randomNumberBound)

where

Parameter	Description
randomNumberOrigin	The origin (inclusive) of each random value.
randomNumberBound	The bound (exclusive) of each random value.

Returns

The method returns IntStream object.

Example 2 – ints(randomNumberOrigin, randomNumberBound)

In this example, we will generate an unlimited sequence of random integers which are limited by an origin and bound using ints() method and print out five of these numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;  

public class Example {  
	public static void main(String[] args) {  
		int randomNumberOrigin = 1;  
		int randomNumberBound = 7;  
		Random random= new Random();  
		IntStream ds = random.ints(randomNumberOrigin, randomNumberBound);  

		ds.limit(5).forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		});
	}  
}

Output

Core team and contributors

Awesome contributors

Adriano Machado
Alberto Lagna
Andrew Neal
Aurélien Mino
Arne Zelasko
dadiyang
Dovid Kopel
Eric Taix
euZebe
Fred Eckertson
huningd
Johan Kindgren
Joren Inghelbrecht
Jose Manuel Prieto
kermit-the-frog
Lucas Andersson
Michael Düsterhus
Nikola Milivojevic
nrenzoni
Oleksandr Shcherbyna
Petromir Dzhunev
Rebecca McQuary
Rodrigue Alcazar
Ryan Dunckel
Sam Van Overmeire
Valters Vingolds
Vincent Potucek
Weronika Redlarska
Konstantin Lutovich
Steven_Van_Ophem
Jean-Michel Leclercq
Marian Jureczko
Unconditional One
JJ1216
Sergey Chernov

Thank you all for your contributions!

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.

How can this be useful ?

Sometimes, the test fixture does not really matter to the test logic. For example, if we want to test the result of a new sorting algorithm, we can generate random input data and assert the output is sorted, regardless of the data itself:

@org.junit.Test
public void testSortAlgorithm() {

   // Given
   int[] ints = easyRandom.nextObject(int[].class);

   // When
   int[] sortedInts = myAwesomeSortAlgo.sort(ints);

   // Then
   assertThat(sortedInts).isSorted(); // fake assertion

}

Another example is testing the persistence of a domain object, we can generate a random domain object, persist it and assert the database contains the same values:

@org.junit.Test
public void testPersistPerson() throws Exception {
   // Given
   Person person = easyRandom.nextObject(Person.class);

   // When
   personDao.persist(person);

   // Then
   assertThat("person_table").column("name").value().isEqualTo(person.getName()); // assretj db
}

There are many other uses cases where Easy Random can be useful, you can find a non exhaustive list in the wiki.

Генерация случайных чисел с помощью класса 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

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

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

(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

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

Using Apache Common lang

You can use Apache Common lang to generate random String. It is quite easy to generate random String as you can use straight forward APIs to create random String.

Create AlphaNumericString

You can use RandomStringUtils.randomAlphanumeric method to generate alphanumeric random strn=ing.

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

packageorg.arpit.java2blog;

import org.apache.commons.lang3.RandomStringUtils;

publicclassApacheRandomStringMain{

publicstaticvoidmain(Stringargs){

System.out.println(«Generating String of length 10: «+RandomStringUtils.randomAlphanumeric(10));

}

Output:

Generating String of length 10: Wvxj2x385N
Generating String of length 10: urUnMHgAq9
Generating String of length 10: 8TddXvnDOV

Create random Alphabetic String

You can use RandomStringUtils.randomAlphabetic method to generate alphanumeric random strn=ing.

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

packageorg.arpit.java2blog;

import org.apache.commons.lang3.RandomStringUtils;

publicclassApacheRandomStringMain{

publicstaticvoidmain(Stringargs){

System.out.println(«Generating String of length 10: «+RandomStringUtils.randomAlphabetic(10));

}

Output:

Generating String of length 10: zebRkGDuNd
Generating String of length 10: RWQlXuGbTk
Generating String of length 10: mmXRopdapr

That’s all about generating Random String in java.