GERADOR DE SENHA Alfanumerico

Muito obrigado amigo… era o que estavo procurando…

polpou bastante tempo de nao precisar digitar o Array

Abraços

Com base no código dele fiz algumas alterações…

public static String getRandomPass(int len){
char[] chart ={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};

char[] senha= new char[len];

int chartLenght = chart.lenght;
Random rdm = new Random();

for (int x=0; x<len; x++)
senha[i] = chart[rdm.nextInt(chartLenght)];

return new String(senha);
}

Fiz um codigo parecido tambem.. é como se fosse um que nem o seu, mas em vez de enviar o numero de caracteres por parametro, achei melhor colocar tudo no metodo main mesmo :)

import java.util.Scanner;
import java.util.Random;

class Gerador_de_Senhas {
   public static void main(String args[]){
      Scanner scan = new Scanner(System.in);
      Random ran = new Random();
	  
      String[] letras ={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
	  String b = "";
	  
	  System.out.print("Digite o numero de caracteres para sua senha: ");
	  int num = scan.nextInt();
	  
	  for ( int i = 0; i < num; i++){
	    int a = ran.nextInt(letras.length);
		b += letras[a];
	  }
	  
	  System.out.print("Senha gerada: " + b);
   }
}

Abraços

Que tal:

import java.util.Random;

public class PasswordGenerator {

	private static final char[] ALL_CHARS = new char[62];
	private static final Random RANDOM = new Random();

	static {
		for (int i = 48, j = 0; i < 123; i++) {
			if (Character.isLetterOrDigit(i)) {
				ALL_CHARS[j] = (char) i;
				j++;
			}
		}
	}

	public static String getRandomPassword(final int length) {
		final char[] result = new char[length];
		for (int i = 0; i < length; i++) {
			result[i] = ALL_CHARS[RANDOM.nextInt(ALL_CHARS.length)];
		}
		return new String(result);
	}

	public static String getRandomPassword() {
		return getRandomPassword(8);
	}

	private PasswordGenerator() {
	}

}

Funciona bem com até um milhão de caracteres. A partir disso fica lento e com mais de 10 milhões trava. Mas é bem divertido.

static {  
         for (int i = 48, j = 0; i < 123; i++) {  
             if (Character.isLetterOrDigit(i)) {  
                 ALL_CHARS[j] = (char) i;  
                 j++;  
             }  
         }  
     }

A unica parte interessante que tava faltando no que postei…

Eu tava pensando em como fazer isso mas sem compilador fica difiçil e nem fui olhar na API XD

Se o número de letras e dígitos for limitado a no máximo 12 e você não fizer diferença entre minúsculas e maiúsculas, pode usar o fato que a base 36 usa os dígitos de 0 a 9 e as letras de a até z, e gerar um número aleatório (usando a classe java.util.Random, método nextLong) que vá de 0 a 4738381338321616895. Converta o número para base-36 usando Long.toString (número, 36).

public class RandomAlphaNumeric {

    private static final Random random = new Random();

    //não faz sentido instanciar essa classe
    private RandomAlphaNumeric() {}

    //[0 - 9] =  0-9
    //[A - Z] = 10-35
    //[a - z] = 36-61
    private static char toChar(int index) {
        if (index < 10)
            return (char)(index + 48); //os chars 48 a 57 representam [0 - 9]
        else if (index < 36)
            return (char)(index + 55); //os chars 65 a 90 representam [A - Z]
        else
            return (char)(index + 61); //os chars 97 a 122 representam [a - z]
    }

    //char randomico entre [0 - 9], [A - Z] e [a - z]
    public static char randomChar() {
        return toChar(random.nextInt(62));
    }

    //String randomica de tamanho length, contendo apenas caracters alfanumericos
    public static String randomString(int length) {
        return new String(randomCharSequence(length));
    }

    //sequencia de caracters randomicos de tamanho length, contendo apenas alfanumericos
    public static char[] randomCharSequence(int length) {
        if (length < 0)
            throw new IllegalArgumentException("O tamanho da string não pode ser negativo");
        if (length == 0)
            return new char[0];
        
        char[] charSequence = new char[length];
        for (int i = 0; i<length; i++)
            charSequence[i] = randomChar();
        return charSequence;
    }

    //sequencia de caracters randomicos de tamanho entre minLength e maxLength, contendo apenas carcters alfanumericos
    public static String randomString(int minLength, int maxLength) {
        if (minLength ><0 || maxLength < 0)
            throw new IllegalArgumentException("O tamanho da string não pode ser negativo");
        if (minLength > maxLength)
            throw new IllegalArgumentException("O tamanho maximo da String não pode ser menor que o minimo");

        if (minLength == maxLength)
            return randomString(maxLength);
        int size = minLength + random.nextInt(maxLength-minLength+1);
        return randomString(size);
    }
}

public class NewMain {
    public static void main(String[] args) {
        System.out.println(RandomAlphaNumeric.randomString(100));
    }
}

resposta do console foi

"jYKXavayOno4K20p7VHWKVe92H7BvBMOIRy4N8RhI9ZJVDdLMzG4ah9RoUHTH6fkdmoYO6YBwDEffoKldiw3mvncVhP19TjPTdw3"

adcionei o método

public static String randomString(int minLength, int maxLength)

e fiz um pequeno teste

public static void main(String ... args) { for (int i = 0; i < 10; i++) System.out.println("\"" + randomString(0,8) + "\""); }

o resultado obtido no console foi

"k" "gj35" "" "FU2mqXdH" "t7P9" "UL" "r7AUEH" "1t" "mJo4BzX" "V6lclw"

Galera, olhem meu codigo fazendo favor:

import java.util.Scanner;
import java.util.Random;

public class Gerador {
   public static void main(String args[]){
      Scanner scan = new Scanner(System.in);
	  Random ran = new Random();
	  
	  System.out.print("1 - Escrever os caracteres para gerar a senha\n2 - Escolher o numero de caracteres para gerar a senha\n3 - Gerar senha de 8 digitos\n\n");
	  System.out.print("Escolha sua opcao: ");
	  int opcao = scan.nextInt();
	  
	  switch ( opcao ) {

	  case 1: {
	     String senha = "";
		 int i;
	     System.out.print("Escreva os caracteres que deseja gerar a senha: ");
		 String car = scan.next();
		 
		 String[] carac = car.split("");
		 
		 for ( i = 0; i < carac.length; i++) {
		    int a = ran.nextInt(carac.length);
			senha += carac[a];
		 }
		 
		 System.out.println("A senha gerada e: " + senha);
		 break;
	  }
	  
	  case 2: {
	     String[] letras_mai ={"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
	     String[] letras_min ={"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
	     String[] numeros = {"0","1","2","3","4","5","6","7","8","9"};
	     
	     System.out.print("Digite o numero de letras maisculas: ");
	     int str1 = scan.nextInt();
	     System.out.print("Digite o numero de letras minusculas: ");
	     int str2 = scan.nextInt();
	     System.out.print("Digite o numero de numeros: ");
	     int str3 = scan.nextInt();
	     
	     int i;
	     String ger1 = "",ger2 = "",ger3 = "",str = "", tot = "";
		 
	     for (i = 0; i < str1; i++ ){
	        int a = ran.nextInt(letras_mai.length);
		    ger1 += letras_mai[a];
	     }
		 
		 for (i = 0; i < str2; i++) {
		    int a = ran.nextInt(letras_min.length);
			ger2 += letras_min[a];
		 }
		 
		 for (i = 0; i < str3;i++){
		    int a = ran.nextInt(numeros.length);
			ger3 += numeros[a];
		 }
		 
		 str = ger1 + ger2 + ger3;
		 String[] total = str.split("");
		 
		 for (i = 0; i < total.length; i++){
		    int a = ran.nextInt(total.length);
			tot += total[a];
		 }
		 
		 System.out.println("A senha gerada e: " + tot);
         break;
	  }
	  
	  case 3: {
	     String[] letras ={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
		 String b = "";
	     for (int i = 0; i < 8; i++){
		    int a = ran.nextInt(letras.length);
			b += letras[a];
		 }
		 
		 System.out.print("A senha gerada e: " + b);
		 break;
	  }
	  
      }
   }
}

Esta dando erro no case 1 e 2. Quem conseguir resolver, se for possivel, poderia explicar aonde estava o erro e porque mudou para tal coisa..

Obrigado pela ajuda.

Abraços

Em ambos os casos você usa o Random para pegar uma posição num array. Mas isso não garante que todos os valores serão escolhidos, nem que os valores não se repetirão. Por causa disso obtem-se valores repetidos e nem todos funcionam bem. A lógica deve ser revista levando isso em consideração.

Para quem estiver interessado no meu blog tem um exemplo de gerador de senhas com codigo fonte, usa um interface swing.
Está na parte de downloads.

[]'s

Porque nao garantem que todos valores serao escolhidos?

Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?

Entendi… mas o que isso tem haver com os erros que estao ocorrendo com o codigo?

Obrigado pela ajuda galera!

Abraços

marcobiscaro2112:

Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?

e o que isso tem a ver marco ?? a chance é de 1/10 de um número ser escolhido… isso não quer dizer que é um evento sem reposição, onde quando 1 é escolhido, a chance passa a ser de 1/9 para os outros…

acho que essa sua especulação, que em um for de 10 de rnd.nextInt(10) deve aparecer todos os números é algo totalmente equivocado…

lembre-se… a chance é de 1/10 para cada vez que vc roda o evento… quando vc passa pela segunda vez no for, é como se o 1° evento não tivesse ocorrido, a chace continua sendo de 1/10 para qualquer número, sendo assim em 10 vezes a chance de um número se repetir é extremamente alta… e a chance de os números nunca se repetirem, e de aparecer os 10 números na sequencia é extremamente baixa

A probabilidade de os números não se repetirem no programa proposto (10 iterações de nextInt (10)), supondo que o gerador de números aleatórios seja perfeito, é de:

10! / 10^10 = 0,00036288 , ou seja, 0,036%.

a conta do thingol esta correta, apenas para não deixar dúvidas

10! / (10 ^ 10)

pois

• para o 1° evento a chance de não c repetir é de 10 em 10 ou seja 10/10 visto que pode ocorrer qualquer número, pois nenhum número foi tirado anteriormente
• para o 2° evento a chance de não c repetir é de 9 em 10 ou seja 9/10, visto que podem ocorrer todos os números menos o anterior
• para o 3° evento a chance de não c repetir é de 8 em 10 ou seja 8/10, visto que podem ocorrer todos os números menos os 2 números anteriores
• …
• para o 10° evento a chance de não c repetir é de 1 em 10 ou seja 1/10, visto que não pode ocorrer os 9 números anteriores

como queremos que o 1° evento não se repita, e o 2° e o 3° … e o 10° devemos multiplicar as probabilidades de cada evendo, tendo então
10/10 * 9/10 * 8/10 * 7/10 … 1/10 = 10! / (10 ^ 10)

o que da 00,0363% de chance dos números não se repetirem
e 99,9647% de chance de haver repetição de números

Você está obtendo algum erro de compilação ou somente inconsistência de dados?

Se for só problema com os dados, é por causa dos números repetidos. Por exemplo, você manda gerar uma senha com 3 letras maiúsculas e 5 números. Se a lógica anterior for usada, valores irão repetir e seu resultado dificilmente terá 3 letras maiúsculas e 5 números de fato.

Lavieri:

marcobiscaro2112:

Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?

e o que isso tem a ver marco ?? a chance é de 1/10 de um número ser escolhido… isso não quer dizer que é um evento sem reposição, onde quando 1 é escolhido, a chance passa a ser de 1/9 para os outros…

acho que essa sua especulação, que em um for de 10 de rnd.nextInt(10) deve aparecer todos os números é algo totalmente equivocado…

lembre-se… a chance é de 1/10 para cada vez que vc roda o evento… quando vc passa pela segunda vez no for, é como se o 1° evento não tivesse ocorrido, a chace continua sendo de 1/10 para qualquer número, sendo assim em 10 vezes a chance de um número se repetir é extremamente alta… e a chance de os números nunca se repetirem, e de aparecer os 10 números na sequencia é extremamente baixa

Mas foi exatamente isso que eu disse!!! Ele estava com problemas na senha gerada e eu disse que não necessariamente obteremos todos os números, e que há a possibilidade de obter-se números repetidos. Não disse que “em um for de 10 de rnd.nextInt(10) deve aparecer todos os números”. Disse exatamente o contrário: que isso é incerto.

marcobiscaro2112:

Você está obtendo algum erro de compilação ou somente inconsistência de dados?

Se for só problema com os dados, é por causa dos números repetidos. Por exemplo, você manda gerar uma senha com 3 letras maiúsculas e 5 números. Se a lógica anterior for usada, valores irão repetir e seu resultado dificilmente terá 3 letras maiúsculas e 5 números de fato.

Cara, se possivel rode a aplicaçao e veja o resultado.

Roda o case 1 e o case 2 e veja que nao é obtido o esperado. Nao sei qual é o erro, se alguem souber por favor apenas fale o erro e de os passos para um futuro concerto do programa, mas sem falar como arrumar a falha…

Obrigado galera pela ajuda

Abraços

ja que vc esta com a duvida poderia ajudar e colocar essas respostas

1° diga para nos qual o resultado que vc espera…
2° rode o programa… escolha 1, e posta aqui o resultado
3° rode novamente… escolha 2, e posta aqui o resultado

fazendo isso, vc vai ajudar a todos entender o seu problema, o que vc esperava, o que esta ocorrendo… assim fica mais facil para todos, fica ai a sugestão…

String[] carac = car.split("");

         for ( i = 0; i < carac.length; i++) {
            int a = ran.nextInt(carac.length);
            senha += carac[a];
         }

esse trecho do código simplismente sorteia (ou seja escolhe valores aleatorios que podem se repetir) entre os caracters digitados, e não embaralha (ou seja mantem o mesmo número de caracter apenas troca as suas posições) eles....

para embaralhar use o trecho abaixo

List<String> carac = Arrays.asList(car.split(""));
         Collections.shuffle(carac);
         for (String s : carac)
            senha += s;

Collections.shuffle(List) faz exatamente isso, embarralhas os elementos de 1 lista, depois de embaralhar através do for seguinte caracter a caracter é colocado na String senha.

Ps.: stringbuffs são melhor para esse tipo de coisa...

...........

String[] total = str.split("");

         for (i = 0; i < total.length; i++){
            int a = ran.nextInt(total.length);
            tot += total[a];
         }

List<String> carac = Arrays.asList(str.split(""));
         Collections.shuffle(carac);
         for (String s : carac)
            tot += s;

.......................

Enfim, não tenho como precisar o que vc ker, pois não sei o que vc espera dos eventos 1 e 2... porem saiba... random.nextInt() como vc tava usando é um sorteio com reposição, ou seja... vc sorteia N vezes um elemento, porem, ele pode se repetir pois a mesma lista estava sempre la..

existem varias formas de fazer um sortei sem reposição... quando vc ker um sorteio de todos os elementos sem reposição a forma mais rapida (pois já esta pronta) é usar a função shuffle de collections... porem existem outras formas... como por exemplo, colocar todos os elementos em 1 lista, e ir dando REMOVE randomicamente na lista, e ir guardado em outra lista cada elemento do remove, quando a lista acaba, a lista nova vai ser igual a entiga embaralhada....

marcobiscaro2112:

Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?

Mas o que isso tem a ver com não se repetir?

Se quiser que não se repita crie um HashSet vá adicionando os valores lá até o HashSet ter o tamanho esperado do resultado… então um for each juntara o resultado e retornara ao usuario.

Mark_Ameba:

Mas o que isso tem a ver com não se repetir?

Se quiser que não se repita crie um HashSet vá adicionando os valores lá até o HashSet ter o tamanho esperado do resultado… então um for each juntara o resultado e retornara ao usuario.

depois de ler o código dele, ate entendi o que tinha ver… pelo o que pude notar, o cara esava fazendo um sorteio com reposição, que é o caso deste FOR, mais queria na verdade um embaralhamento dos elementos…

essa sua solução do HashSet funciona, porem ao meu ver é lenta, pois vai ficar no loop mais vezes que o necessario, pois ate o random não pegar um número que ainda não esteja na lista ele continuará lá… quando a String tiver 200 caracters por exemplo, pode se tornar uma grande complicação esperar que ele encontre os 200 caracters em um loop através de random, pode demorar bastante pra ocorrer…

Se tiver que fazer de modo manual, meu conselho é… adcionar os caracters a um List, e usar o comando remove com um número random… algo assim

int tamanho = listaNormal.size(); List listaEmberalhada = new ArrayList(tamanho); for (int i = 0; i < tamanho; i++) listaEmbaralhada.add(listaNormal.remove(rnd.nextInt(listaNormal.size()));
ele vai fazer um loop com a quantidade exata, e vai fazer o embaralhamento

Isso ainda não garante não repetir o numero… por que da primeira vez voce pode ter 10 elementos na segunda 9, terceira 8,… mas todos os numeros inferiores ainda podem ser sorteados.

E a solução do HashMap eu passei por que não existe um gerador de numeros randomicos que não se repitam(Até onde sei).

Mark_Ameba:

Lavieri:

Se tiver que fazer de modo manual, meu conselho é… adcionar os caracters a um List, e usar o comando remove com um número random… algo assim

int tamanho = listaNormal.size(); List listaEmberalhada = new ArrayList(tamanho); for (int i = 0; i < tamanho; i++) listaEmbaralhada.add(listaNormal.remove(rnd.nextInt(listaNormal.size()));
ele vai fazer um loop com a quantidade exata, e vai fazer o embaralhamento

Isso ainda não garante não repetir o numero… por que da primeira vez voce pode ter 10 elementos na segunda 9, terceira 8,… mas todos os numeros inferiores ainda podem ser sorteados.

E a solução do HashMap eu passei por que não existe um gerador de numeros randomicos que não se repitam(Até onde sei).

obvio que garante… vou te dar um exemplo…

digamos que eu tenha uma lista…

List cores
onde contenha os elementos nessa sequencia {vermelho, laranja, azul, marrom, verde}

quando vc faz um outra lista Lost coresEmbaralhadas
int randomico = rdn.nextInt(cores.size());

ele fara um sorteio de 0 ate 4 suponha que foir sorteado o numero 2… no momento que vc faz

coresEmbaralhadas.add(cores.remove(randomico));

vc vai retirar a cor azul da lista cores, e vai adciona-la a lista coresEmbaralhadas…

agora a lista cores = {vermelho, laranja, marrom, verde}
e a lista coresEmbaralhadas = {azul}

quando vc rodar a sequencia denovo… não tem como ele escolher a cor azul, pois ela não existe + na 1° lista, e ja esta na segunda

… seguindo o mesmo reciocinio, supondo que depois o número sorteado foram 3,1,0,0 teriamos o seguinte

cores = {}
coresEmbaralhadas = {azul,verde,laranja,vermelho,marrom}

como vc vê, mesmo saindo número repetido, saiu o zero 2 vezes, as cores não se repetem

…

apenas detalhando…

quando o sorteio for o 3 ficariamos com

agora a lista cores = {vermelho, laranja, marrom}

e a lista coresEmbaralhadas = {azul, verde}

quando o sorteio for o 1 ficariamos com

agora a lista cores = {vermelho, marrom}

e a lista coresEmbaralhadas = {azul, verde,laranja}

quando o sorteio for o 0 ficariamos com

agora a lista cores = {marrom}

e a lista coresEmbaralhadas = {azul, verde,laranja,vermelho}

quando o sorteio for o 0 ficariamos com

agora a lista cores = {}

e a lista coresEmbaralhadas = {azul, verde,laranja,vermelho,marrom}

Lavieri, muito obrigado cara!

Muito obrigado mesmo, pois alem de me explicar aonde tinha errado deu uma grande dica sobre o List… nunca usei List, ate onde eu sei é tipo um array ne… estou voltando a info agora e estudando array… irei ver sobre esse List jaja, mas o seu exemplo ficou bem explicado cara!

Galera, obrigado a todos…

Abraços

blackfalcon:

Lavieri, muito obrigado cara!

Muito obrigado mesmo, pois alem de me explicar aonde tinha errado deu uma grande dica sobre o List… nunca usei List, ate onde eu sei é tipo um array ne… estou voltando a info agora e estudando array… irei ver sobre esse List jaja, mas o seu exemplo ficou bem explicado cara!

Galera, obrigado a todos…

Abraços

• ou - … digamos que List é uma array um pouco + avançado, é como se fosse uma extensão de array, ela faz parte da Java Collection Framework …

uma List na essencia usa array, so que ela não tem necessariamente um tamanho fixo, vc pode colocar itens infinitamente dentro de uma List… a list é capaz de remover itens tb… internamente ela usa array, faz copia de uma array pra outra e vai trocando os dados dentro dela, para manter sua interface em ordem para o usuario… vc não precisa entender como ela funciona internamente, mais apenas a intarface que ela se propoem…

saiba de antimão, que nem todas as List tem todos os seus métodos funcionando… por exemplo… Arrays.asList(array) retorna uma list que não tem os métodos remove implementado, acredito que nem ADD ela faz… se vc usar uma ArrayList() vai ter todas as funcionalidade de List…

existem outras opções tb… boa sorte ai nos estudos

Mark_Ameba:

Se quiser que não se repita crie um HashSet vá adicionando os valores lá até o HashSet ter o tamanho esperado do resultado.. então um for each juntara o resultado e retornara ao usuario.

ahh outra coisa que lembrei, se na lista que a pessoa digitar houver itens duplicados... por exemplo.... caso a pessoa escolha 1 e digite "abadsec" .... caso vc use HashSet para embaralhar, nunca dará certo, visto que existem 2 "a" nessa lista, não vai dar pra embaralhar...

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        for (int i = 0 ; i<10; i++)
            rodar();
        
        rodar2();
    }

    public static void rodar() {
        Random rdn = new Random();
        int count = 0;
        List<Integer> numeros = new ArrayList<Integer>();
        for(int i = 0; i < 200; i++)
            numeros.add(i);
        Set<Integer> numerosRandomicos = new HashSet<Integer>();
        while(numerosRandomicos.size() < numeros.size()) {
            numerosRandomicos.add(numeros.get(rdn.nextInt(numeros.size())));
            count ++;
        }
        System.out.println(count);
    }

    public static void rodar2() {
        Random rdn = new Random();
        List<Integer> numeros = new ArrayList<Integer>();
        for(int i = 0; i < 10; i++)
            numeros.add(i);
        String numerosEmbralhados = "";
        for(int i = 0; i<10; i++) {
            numerosEmbralhados += numeros.remove(rdn.nextInt(numeros.size())) + ",";
        }
        System.out.println(numerosEmbralhados);
    }
}

1362
1294
1142
1282
812
1103
1285
1490
1049
1125
6,7,3,5,4,9,2,1,0,8,

como vc ve, com HashSet ha iterações bem além das 200 necessarias....
e com remove, fiz um pequeno exemplo só com 0 a 9, so pra ver que não há repetições

Ahh… erro meu mesmo… eu não li a parte do remove…

sorry

.

O gerador de senha do “marcobiscaro2112” ficou muito bom rsrs. Gostei

(+1)

abraços.