2

我写了一个随机密码生成的代码。有一个字符串我必须从中输入密码。所以我尝试根据大写数组、小写数组和数字数组对字符串进行分类。但是当..

         for(int k=0;k<Length;k++){
        if(asc[k]>=65 && asc[k]<=90){
            UpperCase[k]=(char)asc[k];
        }
        else if(asc[k]>=48 && asc[k]<=57){
            Digit[k]=(char)asc[k];
        }
        else {
            Mixed[k]=(char)asc[k];
        }
    }

执行它会计算一些我不想要的空间。对于我糟糕的编码来说，编码看起来很丑陋。我知道有更多的方法可以解决它，但我想通过这个。这是我的代码。这是我的代码 

import java.util.Random;

   public class Randompassgeneration
   {

final int MAX_LENGTH = 20;
final int MIN_LENGTH = 3;

char[] password=new char[25];
int [] asc=new int[18];
char[] UpperCase=new char[25];
char[] Digit=new char[25];
char[] Mixed=new char[25];
public void generate(String allowedCharacters)
{
    int Length=allowedCharacters.length();


    for (int i=0;i<Length;i++)
    {
        asc[i]=(int)allowedCharacters.charAt(i);

    }
    for (int k=0;k<Length;k++)
    {
        if (asc[k]>=65 && asc[k]<=90)
        {
            UpperCase[k]=(char)asc[k];
        }
        else if (asc[k]>=48 && asc[k]<=57)
        {
            Digit[k]=(char)asc[k];
        }
        else
        {
            Mixed[k]=(char)asc[k];
        }
    }

    String rp=null;
    StringBuilder Strbld=new StringBuilder();
    Random rnd=new Random();
    int ranStrLen=rnd.nextInt(MAX_LENGTH - MIN_LENGTH + 1) + MIN_LENGTH;
    Strbld.append(UpperCase[rnd.nextInt(UpperCase.length)]);
    Strbld.append(Digit[rnd.nextInt(Digit.length)]);

    for (int m=0; m<ranStrLen-2; m++)
    {
        Strbld.append(Mixed[rnd.nextInt(Mixed.length)]);

    }

    System.out.print(ranStrLen +"->"+ Strbld.toString());


}

public static void main(String[] args)
{
    String allowedCharacters = "weakPasSWorD1234$*";
    Randompassgeneration t=new Randompassgeneration();
    t.generate(allowedCharacters);
}
}

有什么建议吗？

4

4 回答 4

2

我会生成最少数量的字符、数字和符号。随机填充其他字符并将结果随机排列。这样，它将以最少的努力满足您的最低要求。

public static String passwordGenerator() {
    List<Character> chars = new ArrayList<>();
    Random rand = new Random();
    // min number of digits
    for (int i = 0; i < 1; i++) chars.add((char) ('0' + rand.nextInt(10)));
    // min number of lower case
    for (int i = 0; i < 2; i++) chars.add((char) ('a' + rand.nextInt(26)));
    // min number of upper case
    for (int i = 0; i < 1; i++) chars.add((char) ('A' + rand.nextInt(26)));
    // min number of symbols
    String symbols = "!\"$%^&*()_+{}:@~<>?,./;'#][=-\\|'";
    for (int i = 0; i < 1; i++) chars.add(symbols.charAt(rand.nextInt(symbols.length())));
    // fill in the rest
    while (chars.size() < 8) chars.add((char) ('!' + rand.nextInt(93)));
    // appear in a random order
    Collections.shuffle(chars);
    // turn into a String
    char[] arr = new char[chars.size()];
    for (int i = 0; i < chars.size(); i++) arr[i] = chars.get(i);
    return new String(arr);
}

public static void main(String... args) {
    for (int i = 0; i < 100; i++)
        System.out.println(passwordGenerator());
}
于 2013-01-22T12:56:50.020 回答
1

“执行它会计算一些我不想要的空间”

空白是因为你For loop

您对所有数组都使用了该变量k，这导致k每次的值都增加。所以，这在您的数组之间产生了“间隙”。

将其更改为：

int point1=0,point2=0,point3=0;
for (int k=0;k<Length;k++)
{
    if (asc[k]>=65 && asc[k]<=90)
    {
        UpperCase[point1]=(char)asc[k];point1++;
        continue;
    }
    else if (asc[k]>=48 && asc[k]<=57)
    {
        Digit[point2]=(char)asc[k];point2++;
        continue;
    }
    else
    {
        Mixed[point3]=(char)asc[k];point3++;
    }

}
System.out.println(UpperCase);
System.out.println(Digit);
System.out.println(Mixed);

输出：

PSWD
1234
weakasor$*
于 2013-01-22T13:23:47.527 回答
1

好的，如果没记错的话，您想解析生成的密码并将它们放在单独的数组中。这是大写的片段。

ArrayList<Character> uppercase = new ArrayList<Character>();

char pass[] = password.toCharArray();
for(char c: pass){
   if(Character.isUpperCase(c))
         uppercase.add(c);
}
于 2013-01-22T13:25:48.900 回答
1

如果你想要一个随机字符串，你可以这样做：

public String getRandomString(){
    return UUID.randomUUID().toString();
}

如果你想让它与一些源字符串一致，你可以这样做：

public String getConsistentHash(String source){
    return UUID.nameUUIDFromBytes(source.getBytes()).toString();
}

后一种方法将为相同的源字符串返回相同的字符串。

如果您只想使用一组有限的字符，您可以替换不需要的字符。假设您已经像上面那样创建了“randomString”，您创建了“randomString1”：

randomString1 = UUID.fromString(randomString);

现在用“randomString1”中的字符替换“randomString”中不需要的字符。如有必要，您可以重复此操作。

如果您不关心最小尺寸/传播，您可以删除字符。

祝你好运。

于 2013-01-22T13:26:58.147 回答