在前面的答案中有很多StringBuilder的用法。我想这很简单，但它需要每个字符调用一个函数，增加一个数组，等等。。。

如果使用字符串生成器，建议指定字符串所需的容量，即。，

new StringBuilder(int capacity);

这是一个不使用StringBuilder或字符串附加的版本，也没有字典。

public static String randomString(int length)
{
    SecureRandom random = new SecureRandom();
    char[] chars = new char[length];
    for(int i=0; i<chars.length; i++)
    {
        int v = random.nextInt(10 + 26 + 26);
        char c;
        if (v < 10)
        {
            c = (char)('0' + v);
        }
        else if (v < 36)
        {
            c = (char)('a' - 10 + v);
        }
        else
        {
            c = (char)('A' - 36 + v);
        }
        chars[i] = c;
    }
    return new String(chars);
}

此外，您可以通过ASCII表中的数据生成任何小写或大写字母，甚至特殊字符。例如，生成从A（DEC 65）到Z（DEC 90）的大写字母：

String generateRandomStr(int min, int max, int size) {
    String result = "";
    for (int i = 0; i < size; i++) {
        result += String.valueOf((char)(new Random().nextInt((max - min) + 1) + min));
    }
    return result;
}

generateRandomStr（65、90、100）的生成输出；：

TVLPFQJCYFXQDCQSLKUKKILKKHAUFYEXLUQFHDWNMRBIRRRWNXNNZQTINZPCTKLHGHVYWRKEOYNSOFPZBGEECFMCOKWHLHCEWLDZ

另一个解决方案。。。

public static String generatePassword(int passwordLength) {
    int asciiFirst = 33;
    int asciiLast = 126;
    Integer[] exceptions = { 34, 39, 96 };

    List<Integer> exceptionsList = Arrays.asList(exceptions);
    SecureRandom random = new SecureRandom();
    StringBuilder builder = new StringBuilder();
    for (int i=0; i<passwordLength; i++) {
        int charIndex;

        do {
            charIndex = random.nextInt(asciiLast - asciiFirst + 1) + asciiFirst;
        }
        while (exceptionsList.contains(charIndex));

        builder.append((char) charIndex);
    }
    return builder.toString();
}

使用美元应简单如下：

// "0123456789" + "ABCDE...Z"
String validCharacters = $('0', '9').join() + $('A', 'Z').join();

String randomString(int length) {
    return $(validCharacters).shuffle().slice(length).toString();
}

@Test
public void buildFiveRandomStrings() {
    for (int i : $(5)) {
        System.out.println(randomString(12));
    }
}

它输出的内容如下：

DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7

算法

要生成随机字符串，请连接从可接受符号集合中随机抽取的字符，直到字符串达到所需长度。

实施

这里有一些非常简单且非常灵活的代码，用于生成随机标识符。阅读以下信息，了解重要的应用注意事项。

public class RandomString {

    /**
     * Generate a random string.
     */
    public String nextString() {
        for (int idx = 0; idx < buf.length; ++idx)
            buf[idx] = symbols[random.nextInt(symbols.length)];
        return new String(buf);
    }

    public static final String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    public static final String lower = upper.toLowerCase(Locale.ROOT);

    public static final String digits = "0123456789";

    public static final String alphanum = upper + lower + digits;

    private final Random random;

    private final char[] symbols;

    private final char[] buf;

    public RandomString(int length, Random random, String symbols) {
        if (length < 1) throw new IllegalArgumentException();
        if (symbols.length() < 2) throw new IllegalArgumentException();
        this.random = Objects.requireNonNull(random);
        this.symbols = symbols.toCharArray();
        this.buf = new char[length];
    }

    /**
     * Create an alphanumeric string generator.
     */
    public RandomString(int length, Random random) {
        this(length, random, alphanum);
    }

    /**
     * Create an alphanumeric strings from a secure generator.
     */
    public RandomString(int length) {
        this(length, new SecureRandom());
    }

    /**
     * Create session identifiers.
     */
    public RandomString() {
        this(21);
    }

}

用法示例

为8个字符的标识符创建一个不安全的生成器：

RandomString gen = new RandomString(8, ThreadLocalRandom.current());

为会话标识符创建安全生成器：

RandomString session = new RandomString();

创建一个带有易于阅读的代码的生成器，以便打印。字符串比完整的字母数字字符串长，以补偿使用更少的符号：

String easy = RandomString.digits + "ACEFGHJKLMNPQRUVWXYabcdefhijkprstuvwx";
RandomString tickets = new RandomString(23, new SecureRandom(), easy);

用作会话标识符

生成可能是唯一的会话标识符还不够好，或者您可以只使用一个简单的计数器。攻击者在使用可预测标识符时劫持会话。

长度和安全性之间存在紧张关系。更短的标识符更容易猜测，因为可能性更小。但较长的标识符消耗更多的存储和带宽。较大的符号集有帮助，但如果URL中包含标识符或手动重新输入标识符，则可能会导致编码问题。

会话标识符的随机性或熵的潜在来源应该来自为密码学设计的随机数生成器。然而，初始化这些生成器有时会在计算上很昂贵或很慢，因此应尽可能重新使用它们。

用作对象标识符

并非每个应用程序都需要安全性。随机分配可以是多个实体在共享空间中生成标识符的有效方式，而无需任何协调或分区。协调可能会很慢，特别是在集群或分布式环境中，如果实体最终共享的空间太小或太大，则拆分空间会导致问题。

如果攻击者能够查看和操纵标识符，则应通过其他方式保护未采取措施使其不可预测的标识符，这在大多数web应用程序中都会发生。应该有一个单独的授权系统来保护攻击者在没有访问权限的情况下可以猜测其标识符的对象。

考虑到预期的标识符总数，还必须注意使用足够长的标识符，以避免冲突。这被称为“生日悖论”。冲突的概率p约为n2/（2qx），其中n是实际生成的标识符的数量，q是字母表中不同符号的数量，x是标识符的长度。这应该是一个非常小的数字，比如2‑50或更少。

计算结果表明，500k15个字符的标识符之间发生冲突的可能性约为2-52，这可能比宇宙射线等未检测到的错误更不可能。

与UUID的比较

根据他们的规范，UUID不是设计为不可预测的，不应该用作会话标识符。

标准格式的UUID占用了大量空间：36个字符只代表122位熵。（并非“随机”UUID的所有位都是随机选择的。）随机选择的字母数字字符串仅在21个字符中包含更多的熵。

UUID不灵活；它们具有标准化的结构和布局。这是他们的主要优点，也是他们的主要弱点。与外部合作时，UUID提供的标准化可能会有所帮助。对于纯内部使用，它们可能效率低下。

最佳随机字符串生成器方法

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;
    }   

}