Gerando numeros aleatorios seguidamente

leobarnaud:

pessoal, preciso gerar 2 numeros aleatorios para uso imediato, por exemplo numa operação de soma entre esses dois numeros.

O problema é que, quando gero os dois numeros ( usando a classe Random ), os mesmos saem com o mesmo valor, ja que são criados no mesmo milisegundo. Como resolver isso e fazer com o que o proximo numero gerado seja diferente?

Lembrando, não há obrigatoriedade que os numeros sejam diferentes. Eles só não podem sempre sair os mesmos (devido ao problema citado a cima)

Qualquer coisa que puderem me ajudar… agradeço

OBS.: Não posso usar o match.random por que não funciona no Java ME.

Cara na boa faz o seguinte:

import java.util.Random;

public class Desenho{
	
		
	public static void main(String[] args) {
		
		Random random = new Random();
		
               //For usado para gerar dois números
		for(int i=0;i<2;i++)
                        //usa-se assim para gerar numeros entre 1 e 10.
			System.out.println(1+ random.nextInt(10));
	}
}

Fiz simplesmente isso e não deu problema, são gerados números diferentes:

public static void main(String[] args) { //são gerados números aleatórios de 0 a 100 Random num1 = new Random(); System.out.println(num1.nextInt(100)); Random num2 = new Random(); System.out.println(num2.nextInt(100)); }

Opa obrigado!

Segundo seu exemplo, vc usou a mesma instancia da classe Random para gerar os dois números.

Eu estava errando por que estava usando 2 instancias diferentes da classe Random, encapsuladas numa classe a parte para pegar elementos aleatorios de um vetor.

Como eu estava chamando instancias distintas, o metodo nextInt() não era capaz de saber do que se tratava, gerando assim um novo numero baseado no tempo novamente, no mesmo milisegundo.

Resolvi tudo simplesmente definindo uma variavel de atributo static Random randomizador, assim, não importando a instancia, sempre será usado o mesmo “randomizador”.

leobarnaud:

Opa obrigado!

Segundo seu exemplo, vc usou a mesma instancia da classe Random para gerar os dois números.

Eu estava errando por que estava usando 2 instancias diferentes da classe Random, encapsuladas numa classe a parte para pegar elementos aleatorios de um vetor.

Como eu estava chamando instancias distintas, o metodo nextInt() não era capaz de saber do que se tratava, gerando assim um novo numero baseado no tempo novamente, no mesmo milisegundo.

Resolvi tudo simplesmente definindo uma variavel de atributo static Random randomizador, assim, não importando a instancia, sempre será usado o mesmo “randomizador”.

Luzales na boa cara, não precisa você criar dois objetos random. Apenas um e pronto. Desperdício de memória. Talvez em uma aplicação pequena não sinta a diferença, mas se fizer isso em outra terá problemas. Principalmente quando se trabalha com JAVA ME!

jacobis:

Luzales na boa cara, não precisa você criar dois objetos random. Apenas um e pronto. Desperdício de memória. Talvez em uma aplicação pequena não sinta a diferença, mas se fizer isso em outra terá problemas. Principalmente quando se trabalha com JAVA ME!

Ok, sua solução também é viável. Mas para gerar apenas dois números aleatórios o gasto de memória é tão insignificante quem nem vale a pena quebrar a cabeça, rs. (mesmo pra JME)

luzales:

jacobis:

Luzales na boa cara, não precisa você criar dois objetos random. Apenas um e pronto. Desperdício de memória. Talvez em uma aplicação pequena não sinta a diferença, mas se fizer isso em outra terá problemas. Principalmente quando se trabalha com JAVA ME!

Ok, sua solução também é viável. Mas para gerar apenas dois números aleatórios o gasto de memória é tão insignificante quem nem vale a pena quebrar a cabeça, rs. (mesmo pra JME)

Concordo neste ponto, mas pra que usar dois se podemos usar um… é como o caso de uma String se podemos usar um StringBuilder ou um StringBuffer. Vai depender da situação!!!

O problema não é o desperdício de memória.
É que o construtor de java.util.Random, sem argumentos, obtém o estado inicial do gerador de números aleatórios do relógio do sistema, em milissegundos.
Se você tiver dois objetos java.util.Random que foram inicializados mais ou menos no mesmo instante, provavelmente eles serão inicializados com o mesmo valor em milissegundos, e então eles começarão a retornar resultados iguais.
Uma forma de impedir esse problema em Java SE e EE (mas não em Java ME) é usar java.security.SecureRandom, que em vez de obter o estado inicial do gerador a partir do relógio, faz uma coisa muito mais complexa (e lenta) para ter uma geração de números aleatórios com melhor qualidade.
(Como essa geração chama as APIs criptográficas do seu sistema operacional - no caso do Linux, lê a partir de /dev/random, e no caso do Windows, chama algumas APIs da CryptoAPI, a inicialização pode ser muito lenta).
Uma outra forma é simplesmente reaproveitar o mesmo objeto, como sugerido (usá-lo como singleton ou estático).
Dá para imaginar outras formas de se fazer isso (por exemplo, ter um SecureRandom que serve apenas para inicializar outras instâncias de java.util.Random).