GERADOR DE SENHA Alfanumerico

este é um exemplo bem simples de gerador de senhas alfanumeros…
se alguem quizer melhorar fique a vontade, mas posta aqui pra gnt conferir…

package senha;

/**
*

  • @author Walfrides Marçal
    Academico do 3º ano de Sistemas de Informação - FIMES - Mineiros - GO
    */
    public class Main {

    public Main() {
    }

    public static void main(String[] args) {

     String[] carct ={"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 senha="";
    
    
     for (int x=0; x<10; x++){
         int j = (int) (Math.random()*carct.length);
         senha += carct[j];
    

}

    System.out.println("A SENHA GERADA É: "+senha);

}

}

falowssssss

:smiley:

2 curtidas

Muito obrigado amigo… era o que estavo procurando…

polpou bastante tempo de nao precisar digitar o Array :slight_smile:

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 :slight_smile:

[code]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);

}
}[/code]

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. :smiley:

 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).

minha solução foi a seguinte

[code]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);
}

}[/code]

um exemplo de uso

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:

[code]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;
  }
  
  }

}
}[/code]

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

[quote=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?[/quote]

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.

[quote=Lavieri][quote=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?[/quote]

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[/quote]

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.