TOC

Java - Aleatório Longo, Flutuante, Inteiro e Duplo

Java - Aleatório Longo, Flutuante, Inteiro e Duplo

Este tutorial rápido ilustra como gerar um longo primeiro usando Java simples e usando a biblioteca de matemática do Apache Commons.

Este artigo faz parte dethe “Java – Back to Basic” series aqui no exemplo.

1. Gerar um Long ilimitado

Vamos começar gerando um Long: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomLongUnbounded_thenCorrect() {
    long generatedLong = new Random().nextLong();
}

2. Gerar um longo dentro de um intervalo

2.1. Random Long com Plain Java

A seguir - vamos ver como criar um Long limitado aleatório - ou seja, um valor Long dentro de um determinado intervalo ou intervalo: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomLongBounded_thenCorrect() {
    long leftLimit = 1L;
    long rightLimit = 10L;
    long generatedLong = leftLimit + (long) (Math.random() * (rightLimit - leftLimit));
}

2.2. Random Long com Apache Commons Math

Vamos dar uma olhada na geração do Long aleatório com uma API mais limpa e Commons Math: 

@Test
public void givenUsingApacheCommons_whenGeneratingRandomLongBounded_thenCorrect() {
    long leftLimit = 10L;
    long rightLimit = 100L;
    long generatedLong = new RandomDataGenerator().nextLong(leftLimit, rightLimit);
}

3. Gerar um inteiro ilimitado

Vamos continuar gerando um número inteiro aleatório sem limites: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomIntegerUnbounded_thenCorrect() {
    int generatedInteger = new Random().nextInt();
}

Como você pode ver, está muito perto de gerar um longo.

4. Gerar um inteiro dentro de um intervalo

4.1. Random Integer com Plain Java

Próximo - um número inteiro aleatório dentro de um determinado intervalo: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomIntegerBounded_thenCorrect() {
    int leftLimit = 1;
    int rightLimit = 10;
    int generatedInteger = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit));
}

4.2. Número inteiro aleatório com Commons Math

E o mesmo com o Common Math: 

@Test
public void givenUsingApache_whenGeneratingRandomIntegerBounded_thenCorrect() {
    int leftLimit = 1;
    int rightLimit = 10;
    int generatedInteger = new RandomDataGenerator().nextInt(leftLimit, rightLimit);
}

5. Gerar um flutuador ilimitado

Agora, vamos gerar flutuações aleatórias - primeiro ilimitadas: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomFloatUnbouned_thenCorrect() {
    float generatedFloat = new Random().nextFloat();
}

6. Gerar um flutuador dentro de um intervalo

6.1. Flutuação Aleatória com Java Simples

E um flutuador aleatório limitado: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomFloatBouned_thenCorrect() {
    float leftLimit = 1F;
    float rightLimit = 10F;
    float generatedFloat = leftLimit + new Random().nextFloat() * (rightLimit - leftLimit);
}

6.2. Flutuação aleatória com Commons Math

Agora - uma flutuação aleatória limitada com o Commons Math: 

@Test
public void givenUsingApache_whenGeneratingRandomFloatBounded_thenCorrect() {
    float leftLimit = 1F;
    float rightLimit = 10F;
    float randomFloat = new RandomDataGenerator().getRandomGenerator().nextFloat();
    float generatedFloat = leftLimit + randomFloat * (rightLimit - leftLimit);
}

7. Gere um duplo ilimitado

7.1. Random Unbounded Double com Plain Java

Finalmente - vamos gerar valores duplos aleatórios - primeiro, com a API Java Math: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
    double generatedDouble = Math.random();
}

7.2. Random Unbounded Double com Commons Math

Além de um valor duplo aleatório na biblioteca de matemática do Apache Commons: 

@Test
public void givenUsingApache_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
    double generatedDouble = new RandomDataGenerator().getRandomGenerator().nextDouble();
}

8. Gerar um duplo dentro de um intervalo

8.1. Random Bounded Double com Plain Java

Neste exemplo, vamos dar uma olhada em um duplo aleatório gerado dentro de um intervalo - com Java: 

@Test
public void givenUsingPlainJava_whenGeneratingRandomDoubleBounded_thenCorrect() {
    double leftLimit = 1D;
    double rightLimit = 10D;
    double generatedDouble = leftLimit + new Random().nextDouble() * (rightLimit - leftLimit);
}

8.2. Random Bounded Double com Commons Math

E, por fim - um duplo aleatório dentro de um intervalo, usando a biblioteca de matemática Apache Commons: 

@Test
public void givenUsingApache_whenGeneratingRandomDoubleBounded_thenCorrect() {
    double leftLimit = 1D;
    double rightLimit = 100D;
    double generatedDouble = new RandomDataGenerator().nextUniform(leftLimit, rightLimit);
}

E aí está - exemplos rápidos e detalhados de como gerar valores ilimitados e limitados para as primitivas numéricas mais comuns em Java.

9. Conclusão

Este tutorial ilustrou como poderíamos gerar números aleatórios vinculados ou não, usando diferentes técnicas e bibliotecas.

Como sempre, a implementação de todos esses exemplos e snippets pode ser encontrada emGitHub project. Este é um projeto baseado em Maven, portanto deve ser fácil importar e executar.

Related