java中的自定义长度唯一密码

可能重复：

我需要生成唯一的随机密码。
所以我想做一些类似于

MD5（计数器+随机字符串+timeInMills）

的事情，但它有32个字符的输出。
我需要8个字符的密码。
如何生成唯一的自定义长度人类可读密码

更新：
我每次生成N（少于30）个密码，我需要这些N个密码是非冗余的。独特性的需要不是绝对的。

---

另外，检查生成的密码是否存在重复值并重新生成它可能会导致无限循环

创建一个字符数组并用随机字母填充它

Random r = new Random();
char[] pass = new char[8];
for (int i = 0; i < pass.length; ++i)
{
    pass[i] = r.nextInt(26) + 'a';
}
String passStr = new String(pass);

Random r=new Random（）；
char[]pass=新字符[8]；
对于（int i=0；i

创建一个字符数组并用随机字母填充

Random r = new Random();
char[] pass = new char[8];
for (int i = 0; i < pass.length; ++i)
{
    pass[i] = r.nextInt(26) + 'a';
}
String passStr = new String(pass);

Random r=new Random（）；
char[]pass=新字符[8]；
对于（int i=0；i

保证随机生成字符串唯一性的暴力方法是存储所有字符串并在冲突时重新生成：

protectedcollection generatedPasswords=new HashSet（）；
公共字符串生成器密码（整数长度）{
字符串密码=null；
做{
StringBuilder buf=新的StringBuilder（）；
//将“长度”随机密码字符附加到“buf”。
密码=buf.toString（）；
}while（this.generatedPasswords.contains（password））；
返回密码；
}

---

然而，如果您只是试图为最终用户生成“合理”的随机密码，并且您可以偶尔使用（非常罕见）冲突-然后您可以简单地获取MD5方案的前N个字符。

保证随机生成字符串唯一性的暴力方法是存储所有字符串，并在冲突时重新生成：

protectedcollection generatedPasswords=new HashSet（）；
公共字符串生成器密码（整数长度）{
字符串密码=null；
做{
StringBuilder buf=新的StringBuilder（）；
//将“长度”随机密码字符附加到“buf”。
密码=buf.toString（）；
}while（this.generatedPasswords.contains（password））；
返回密码；
}

但是，如果您只是尝试为最终用户生成“合理”的随机密码，并且您对偶尔发生的（非常罕见的）冲突没有意见，那么您可以简单地使用MD5方案的前N个字符。

这里有一个想法：使用类

UUID类提供了一个静态工厂方法来生成伪随机生成的UUID

可以将UUID转换为字符串

不要忘记，如果要保证唯一性，就不能截断/子串UUID的值：

关于MSDN的文章：

这里有一个想法：利用课堂

UUID类提供了一个静态工厂方法来生成伪随机生成的UUID

可以将UUID转换为字符串

不要忘记，如果要保证唯一性，就不能截断/子串UUID的值：

---

关于MSDN的文章：

我已经为我创建了一个随机字符串/密码生成器程序，希望这也适用于您

public class RandomStringGenerator{

    private static int randomStringLength = 25 ;
    private static boolean allowSpecialCharacters = true ;
    private static String specialCharacters = "!@$%*-_+:";
    private static boolean allowDuplicates = false ;

    private static boolean isAlphanum = false;
    private static boolean isNumeric = false;
    private static boolean isAlpha = false;
    private static final String alphabet = "abcdefghijklmnopqrstuvwxyz";
    private static boolean mixCase = false;
    private static final String capAlpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String num = "0123456789";

    public static String getRandomString() {
        String returnVal = "";
        int specialCharactersCount = 0;
        int maxspecialCharacters = randomStringLength/4;

        try {
            StringBuffer values = buildList();
            for (int inx = 0; inx < randomStringLength; inx++) {
                int selChar = (int) (Math.random() * (values.length() - 1));
                if (allowSpecialCharacters)
                {
                    if (specialCharacters.indexOf("" + values.charAt(selChar)) > -1)
                    {
                        specialCharactersCount ++;
                        if (specialCharactersCount > maxspecialCharacters)
                        {
                            while (specialCharacters.indexOf("" + values.charAt(selChar)) != -1)
                            {
                                selChar = (int) (Math.random() * (values.length() - 1));
                            }
                        }
                    }
                }
                returnVal += values.charAt(selChar);
                if (!allowDuplicates) {
                    values.deleteCharAt(selChar);
                }
            }
        } catch (Exception e) {
            returnVal = "Error While Processing Values";
        }
        return returnVal;
    }

    private static StringBuffer buildList() {
        StringBuffer list = new StringBuffer(0);
        if (isNumeric || isAlphanum) {
            list.append(num);
        }
        if (isAlpha || isAlphanum) {
            list.append(alphabet);
            if (mixCase) {
                list.append(capAlpha);
            }
        }
        if (allowSpecialCharacters)
        {
            list.append(specialCharacters);
        }
        int currLen = list.length();
        String returnVal = "";
        for (int inx = 0; inx < currLen; inx++) {
            int selChar = (int) (Math.random() * (list.length() - 1));
            returnVal += list.charAt(selChar);
            list.deleteCharAt(selChar);
        }
        list = new StringBuffer(returnVal);
        return list;
    }   

}

公共类随机字符串生成器{
私有静态int randomStringLength=25；
私有静态布尔allowSpecialCharacters=true；
私有静态字符串specialCharacters=“！@$%*-\：”；
私有静态布尔allowDuplicates=false；
私有静态布尔值isAlphanum=false；
私有静态布尔值isNumeric=false；
私有静态布尔值isAlpha=false；
私有静态最终字符串字母表=“abcdefghijklmnopqrstuvwxyz”；
私有静态布尔mixCase=false；
私有静态最终字符串capAlpha=“ABCDEFGHIJKLMNOPQRSTUVWXYZ”；
私有静态最终字符串num=“0123456789”；
公共静态字符串getRandomString（）{
字符串returnVal=“”；
int SpecialCharacterScont=0；
int maxspecialCharacters=randomStringLength/4；
试一试{
StringBuffer值=buildList（）；
对于（int-inx=0；inx-1）
{
SpecialCharacterScont++；
如果（specialCharactersCount>maxspecialCharacters）
{
while（specialCharacters.indexOf（“+values.charAt（selChar））！=-1）
{
selChar=（int）（Math.random（）*（values.length（）-1））；
}
}
}
}
returnVal+=values.charAt（selChar）；
如果（！allowDuplicates）{
value.deleteCharAt（selChar）；
}
}
}捕获（例外e）{
returnVal=“处理值时出错”；
}
返回值；
}
私有静态StringBuffer构建列表（）{
StringBuffer列表=新的StringBuffer（0）；
if（isNumeric | | isAlphanum）{
list.append（num）；
}
if（isAlpha | | isAlphanum）{
列表。附加（字母表）；
if（mixCase）{
列表。附加（capAlpha）；
}
}
如果（允许特殊字符）
{
list.append（特殊字符）；
}
int currLen=list.length（）；
字符串returnVal=“”；
对于（int-inx=0；inx