O que é o Random Number Generator em Java?
Os números aleatórios são comumente usados na criação de aplicativos como o Dice para um jogo de tabuleiro, um programa de jogo, etc. Normalmente, a geração de números aleatórios leva muito tempo. Mas, na linguagem de programação Java, isso pode ser alcançado usando três maneiras. Eles são abordados na seção abaixo, Funções de gerador de números aleatórios em Java.
Funções de gerador de números aleatórios em Java
Em Java, os números aleatórios podem ser gerados usando três maneiras:
- Método Math.random
- classe java.util.Random
- Classe ThreadLocalRandom
1. Método Math.random ()
A classe Java Math oferece vários métodos para trabalhar em cálculos como logaritmos, média, exponenciação, etc. random () é um dos métodos dentre eles que retorna um valor duplo positivo no intervalo de 0, 0 e 1, 0, em que 0, 0 é inclusivo e 1.0 é exclusivo. Este método pode ser usado com ou sem o uso de parâmetros. Se parâmetros forem fornecidos, o número aleatório gerado estará dentro do intervalo do parâmetro especificado.
Exemplo 1
Código:
public class RandomNumber (
double num; //Declare a variable num
//Method which generates a random number
public double randnum()
(
num=Math.random();
return num;
)
// Main Method of a program
public static void main(String() args) (
//Printing a random number
System.out.println("Random Number generated inside main method: "+Math.random());
//Create an object of the class RandomNumber
RandomNumber randomobj=new RandomNumber();
//Store the return value obtained from randnum method in a variable randomval
double randomval=randomobj.randnum();
//Printing the random number stored in variable randomval
System.out.println("Random Number generated inside randomnumber method: "+randomval);
)
)
Resultado:
No exemplo acima, o Número aleatório é gerado usando o método Math.random () de duas maneiras: aplicando-o diretamente no método principal e chamando um método que contém Math.random () usando o objeto. Como mencionado na explicação acima, podemos ver que 2 números aleatórios são gerados no intervalo de 0, 0 e 1, 0.
Para gerar um número aleatório dentro do intervalo de parâmetros, a expressão geral usada é mencionada abaixo:
Math.random () * ((maxvalue - minvalue) +1) + minvalue
Exemplo 2
Onde maxvalue é o limite superior do intervalo e o valor min é o limite inferior do intervalo. Por exemplo, para gerar um número aleatório entre 10 e 20, defina o valor máximo como 20 e o valor mínimo como 10.
Código:
public class RandomNumParameters (
public double randomnum(double x, double y)//max value-y, min value-x
(
double z =(Math.random()*((yx)+1)+x); //Formula for random number generation within a range
return z;
)
public static void main(String() args)
(
RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters
double num=ran.randomnum(3.0, 10.0); //Call the Method
System.out.println("Random number generated within the range of 3 and 10: "+num );
) )
Resultado:
2. Classe java.util.Random
A classe Java.util.Random gera números aleatórios de diferentes tipos de dados, como float, long, número inteiro, duplo, booleano etc. Também é possível passar o intervalo de números como argumentos para que um número aleatório seja gerado dentro desse intervalo . Para usar essa classe, a classe Random de java.util deve ser importada (java.util.Random). Depois que essa classe for importada, crie uma instância e chame os métodos como next long (), nextInt () etc. usando essa instância.
Exemplo 1
Código:
//Java program to generate Random numbers using Random class
package Sample;
import java.util.Random; //import Random Class
public class RandomNum (
public static void main(String() args) (
Random rand=new Random(); //Create instance of Random class
double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable
System.out.println("Random Double value: "+ randomnum);
)
)
Resultado:
No programa acima, um valor duplo aleatório é gerado usando o método nextDouble ().
3. Classe ThreadLocalRandom
A classe ThreadLocalRandom é um tipo especializado de classe Random que é introduzido no Java versão 1.7. ThreadLocalRandom.current (). NextInt () é um dos métodos comuns usados para gerar números aleatórios. É normalmente usado em aplicativos multithread.
Exemplo 1
Código:
//Java Program to generate random numbers using ThreadLocalRandom Class
import java.util.concurrent.ThreadLocalRandom;
public class RandomNumThread (
public static void main(String() args) (
//print a random double
System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble());
)
)
Resultado:
Geração de Inteiros
Inteiros aleatórios podem ser gerados usando as classes ThreadLocalRandom e Random Class. Nos dois casos, um método nextInt () é usado para o mesmo:
Exemplo 1
Código:
//Java program to generate Random integer numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomInteger (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
int randomnum1=rnd.nextInt(); //Random Integer value using Random Class
int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30
int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class
System.out.println("Random Integer value using Random Class: "+ randomnum1);
System.out.println("Random Integer value within the range of 30: "+ randomnum2);
System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3);
)
)
Resultado:
No exemplo acima, três números aleatórios do tipo inteiro são gerados onde um do método nextInt () tem 30 como argumento. Portanto, ao gerar um número aleatório, 30 será definido como o limite superior e zero (limite inferior padrão) será definido como o limite inferior.
Gerando números de ponto flutuante
Semelhante à geração de números inteiros, números de ponto flutuante podem ser gerados usando o método nextFloat (). Este método pode ser usado nas classes Random Class e ThreadLocalRandom:
Exemplo 1
Código:
//Java program to generate Random Float numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomFloat (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
float randomnum1=rnd.nextFloat(); //Random Float value using Random Class
float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class
System.out.println("Random float value using Random Class: "+ randomnum1);
System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2);
)
)
Resultado:
Conclusão
Java contém uma infinidade de funções que podem ser usadas em programas. Isso ajuda a reduzir o tempo de processamento e as linhas de código. Geração de número aleatório é uma tarefa em que podemos usar algumas dessas funções. Este documento aborda os diferentes métodos para conseguir isso.
Artigos recomendados
Este é um guia para o Random Number Generator em Java. Aqui discutimos funções em java com exemplos e dois geradores diferentes. Você também pode consultar nossos outros artigos relacionados para saber mais -
- Gerador de número aleatório em Python
- Gerador de número aleatório em C
- Gerador de número aleatório em R
- Recursão em Java
- Gerador de número aleatório no Matlab
- Gerador de número aleatório em c #
- Matrizes na programação Java
- Gerador de número aleatório em JavaScript
- Gerador de número aleatório em PHP