Na área da computação, muitas vezes, precisamos utilizar números aleatórios em nosso código. Para simplificar esse trabalho, diversas linguagens de programação fornecem métodos prontos para as pessoas desenvolvedoras utilizarem. Esse é o caso, por exemplo, da classe Java Random.
No entanto, apesar de fornecer métodos intuitivos e fáceis de aplicar no código, ainda é comum que iniciantes na área da programação sintam dificuldades em entender como cada um deles funciona e em que situações podemos usá-los. Sanar essas dúvidas é um passo importante para quem deseja trabalhar com desenvolvimento.
Afinal, tendo domínio sobre o uso da classe Java Random, você poderá utilizar seus métodos em variadas funções. Entre elas, gerar textos de campos captcha ou senhas fortes.
Por isso, neste artigo, você vai descobrir:
- O que é o Java.util.Random?
- O que é o Math.random()?
- Quais os 10 métodos da classe Java Random?
- Como usar o Java.util.Random na prática? Confira 3 exemplos!
- Como usar o Math.random() na prática:? Veja 3 exemplos!
Fique com a gente e aproveite a leitura!
O que é o Java.util.Random?
Random é uma das classes disponibilizadas pela linguagem Java que faz parte do pacote “java.util”. Como o próprio nome indica, essa classe apresenta métodos embutidos para gerar números aleatórios a partir de uma solicitação.
Além disso, tais métodos permitem gerar números de diversos tipos, como int, double, float e long. Quando precisamos utilizar essa classe em um programa, devemos incluir a seguinte declaração de importação no início do código:
import java.util.Random;O que é o Math.random()?
Já o Math.random() é um método estático disponibilizado pela classe Math da linguagem Java. Esse método retorna números aleatórios do tipo double, mas apenas aqueles incluídos no intervalo de 0.0 até 1.0.
Devido a isso, quando desejamos retornar números aleatórios em outra faixa de valores, precisamos realizar operações matemáticas com os retornos dados pelo método. Ademais, para utilizar o Math.random(), devemos incluir a declaração abaixo no código:
import java.lang.Math;Quais os 10 métodos da classe Java Random?
Como dissemos, a classe Random nos fornece vários métodos prontos para gerar valores aleatórios que simplificam a codificação. Na tabela abaixo, mostramos quais são eles. Confira!
| Método | Função do Método |
| next(int bits) | Retorna o próximo número pseudo aleatório do tipo int. |
| nextInt() | Retorna um valor pseudo aleatório do tipo int. |
| nextInt(int n) | Retorna um valor pseudo aleatório do tipo int entre 0 e o valor n especificado (incluindo o valor 0 e excluindo o valor n). |
| nextDouble() | Retorna um valor pseudo aleatório do tipo double maior ou igual a 0.0 e menor que 1.0. |
| nextFloat() | Retorna o próximo valor pseudo aleatório do tipo float distribuído uniformemente entre o intervalo de 0.0 e 1.0. |
| nextBoolean() | Retorna o próximo valor booleano pseudo aleatório distribuído uniformemente no intervalo. |
| nextGaussian() | Retorna o próximo valor pseudo aleatório do tipo double, normalmente, com distribuição gaussiana, com média 0.0 e desvio padrão 1.0. |
| setSeed(long seed) | Define um valor do tipo long para ser usado como semente do gerador de números aleatórios. |
| nextBytes(byte[] bytes) | Coloca os bytes aleatórios gerados em um array de bytes com tamanho fornecido pela pessoa usuária. |
| nextLong() | Retorna o próximo valor pseudo aleatório do tipo long distribuído uniformemente no intervalo. |
Como usar o Java.util.Random na prática? Confira 3 exemplos!
1. Gerando um número aleatório do tipo int
Para começar, vejamos um exemplo básico de utilização da classe Random, mostrado no código a seguir:
import java.util.Random;
class generateRandom {
public static void main(String[] args) {
//instância um objeto da classe Random
Random random = new Random();
//gera um valor aleatório qualquer do tipo int
int valor = random.nextInt();
//imprime o valor gerado na tela
System.out.println("O número aleatório gerado é: " + valor);
}
}Perceba que o que está sendo feito no código é bastante simples. Utilizamos o construtor padrão para instanciar um objeto da classe Random, em seguida, utilizamos o objeto para chamar o método nextInt() e gerar um valor aleatório. Por fim, imprimimos o valor retornado pelo método na tela.
2. Gerando uma sequência fixa de números aleatórios entre 0 e 50
A classe Random do Java também nos permite gerar uma sequência fixa de números aleatórios, como mostramos no exemplo abaixo:
import java.util.Random;
class generateRandom {
public static void main(String[] args) {
// instância um objeto da classe Random e específica a semente
Random random = new Random(5871293);
// imprime na tela uma sequência de 10 números inteiros aleatórios entre 0 e 50
for (int i = 0; i < 10; i++) {
System.out.println(random.nextInt(51));
}
}
}Observe que, no código acima, passamos o parâmetro “5871293” no construtor. Isso significa que estamos fornecendo a “semente” que o Java deve usar para gerar os valores, assim, teremos como resultado sempre a mesma sequência de números, todas as vezes que o código for executado.
3. Gerando um array de bytes aleatórios
Por fim, neste último exemplo, mostramos como o método nextBytes() pode ser usado para gerar um array de bytes aleatórios. Veja!
import java.util.Random;
class generateRandom {
public static void main(String[] args) {
// instância um objeto da classe Random
Random random = new Random();
// cria um array de bytes de tamanho 15
byte[] bytes = new byte[15];
// armazena os bytes gerados no array
random.nextBytes(bytes);
// imprime o array de bytes
System.out.print("O array de bytes aleatórios gerado é = [ ");
for (int i = 0; i < bytes.length; i++) {
System.out.printf("%d ", bytes[i]);
}
System.out.print("]");
}
}Perceba que, no código acima, instanciamos um objeto da classe Random e criamos um array de bytes de tamanho 15. Posteriormente, chamamos o método nextBytes(), passando o array criado no parâmetro. Finalmente, usamos um loop for para imprimir na tela os valores armazenados no array.
Como usar o Math.random() na prática? Veja 3 exemplos!
1. Gerando um número real aleatório entre 0.0 e 1.0
Como foi dito, o método Math.random() nos permite gerar números aleatórios do tipo double de uma maneira simples e rápida. Abaixo, mostramos como usá-lo corretamente:
import java.lang.Math;
class generateRandom {
public static void main(String args[]) {
// gera um número aleatório do tipo double
double numRandom = Math.random();
// imprime o número gerado na tela
System.out.println("O número gerado é: " + numRandom);
}
}No código apresentado, instanciamos a variável “numRandom”, que recebe o valor aleatório gerado pelo método Math.random(). Em seguida, esse valor é imprimido na tela junto da mensagem especificada na função.
2. Gerando 7 números inteiros aleatórios entre 1 e 20
Por padrão, o método Math.random() gera valores aleatórios entre 0.0 e 1.0. No entanto, usando operações matemáticas, podemos utilizá-lo para retornar números em diferentes faixas de valores, conforme mostramos a seguir.
import java.lang.Math;
class generateRandom {
public static void main(String args[]) {
// cria um loop para imprimir 7 valores aleatórios entre 1 e 20
for (int i = 0; i < 7; i++) {
int numRandom = (int)(Math.random() * 20 ) + 1;
System.out.println("Número: " + numRandom);
}
}
}Observe que, no código, usamos a fórmula “Math.random() * 20” para definir a faixa de valores que deve ser usada durante a execução. Vale lembrar que qualquer outro valor poderia ser usado no lugar do 20, uma vez que isso depende do intervalo de números com o qual queremos trabalhar.
3. Gerando 5 números inteiros aleatórios entre 20 e 50
No exemplo acima, mostramos como usar o Math.random() para gerar valores aleatórios em uma faixa de valores que vai de 1 até um valor n qualquer. Porém, em alguns casos, precisamos utilizar um intervalo que inicie com um valor maior que 1.
Nessas situações, podemos usar o seguinte método para especificar a faixa de valores desejada. Veja!
import java.lang.Math;
class generateRandom {
public static void main(String args[]){
// define o intervalo
int max = 50;
int min = 20;
int intervalo = max - min + 1;
// gera 5 números aleatórios entre o intervalo de 20 a 50 e os imprime na tela
for (int i = 0; i < 5; i++) {
int numRandom = (int)(Math.random() * intervalo) + min;
System.out.println(numRandom);
}
}
}Perceba que, neste exemplo, criamos as variáveis “max”, “min” e “intervalo” para definir a faixa de valores com a qual queremos trabalhar. Em seguida, usamos um loop for para imprimir na tela os 5 valores aleatórios gerados, usando a fórmula “(Math.random() * intervalo) + min”.
Ao longo do post, foi possível perceber a importância da classe Java Random para as pessoas programadoras. Afinal, ela fornece, ao todo, dez métodos para a geração de números aleatórios que podem ser aplicados em programas voltados para diferentes áreas da computação, como na área de segurança de informações.
Além disso, também foi mostrado como funciona o método Math.random() e como ele pode ser utilizado na prática, de diferentes formas. Contudo, cabe ressaltar que este artigo é uma introdução ao tema, sendo preciso prosseguir sempre estudando para ter sucesso em sua carreira.
Se as informações que apresentamos foram úteis para você, aproveite a visita ao blog para aprofundar ainda mais seus conhecimentos, e descubra tudo o que precisa saber sobre a linguagem Javascript!
