blocks|key|1122887|text|这里是用Java编写的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1122888|import+static+java.lang.Math.round;
import+static+java.lang.Math.random;
import+static+java.lang.Math.pow;
import+static+java.lang.Math.abs;
import+static+java.lang.Math.min;
import+static+org.apache.commons.lang.StringUtils.leftPad

public+class+RandomAlphaNum+{
++public+static+String+gen(int+length)+{
++++StringBuffer+sb+=+new+StringBuffer();
++++for+(int+i+=+length;+i+>+0;+i+-=+12)+{
++++++int+n+=+min(12,+abs(i));
++++++sb.append(leftPad(Long.toString(round(random()+*+pow(36,+n)),+36),+n,+'0'));
++++}
++++return+sb.toString();
++}
}|code-block|syntax|javascript|1122889|下面是一个示例运行：|1122890|scala>+RandomAlphaNum.gen(42)
res3:+java.lang.String+=+uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy|1122891|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here it is in Java:

<pre><code>import static java.lang.Math.round;
import static java.lang.Math.random;
import static java.lang.Math.pow;
import static java.lang.Math.abs;
import static java.lang.Math.min;
import static org.apache.commons.lang.StringUtils.leftPad

public class RandomAlphaNum {
 public static String gen(int length) {
 StringBuffer sb = new StringBuffer();
 for (int i = length; i &gt; 0; i -= 12) {
 int n = min(12, abs(i));
 sb.append(leftPad(Long.toString(round(random() * pow(36, n)), 36), n, '0'));
 }
 return sb.toString();
 }
}
</code></pre>

Here's a sample run:

<pre><code>scala&gt; RandomAlphaNum.gen(42)
res3: java.lang.String = uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy
</code></pre>

blocks|key|123614|text|Java提供了一种直接这样做的方法。如果你不想要破折号，它们很容易被去掉。只需使用uuid.replace("-",+"")|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|123615|import+java.util.UUID;

public+class+randomStringGenerator+{
++++public+static+void+main(String[]+args)+{
++++++++System.out.println(generateString());
++++}

++++public+static+String+generateString()+{
++++++++String+uuid+=+UUID.randomUUID().toString();
++++++++return+"uuid+=+"+%2B+uuid;
++++}
}|code-block|syntax|javascript|123616|输出|123617|uuid+=+2d7428a6-b58c-4008-8575-f05549f16316|123618|entityMap^0|15|L|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Java supplies a way of doing this directly. If you don't want the dashes, they are easy to strip out. Just use <code>uuid.replace(&quot;-&quot;, &quot;&quot;)</code>
<pre><code>import java.util.UUID;

public class randomStringGenerator {
 public static void main(String[] args) {
 System.out.println(generateString());
 }

 public static String generateString() {
 String uuid = UUID.randomUUID().toString();
 return &quot;uuid = &quot; + uuid;
 }
}
</code></pre>
<h3>Output</h3>
<pre class="lang-none prettyprint-override"><code>uuid = 2d7428a6-b58c-4008-8575-f05549f16316
</code></pre>

blocks|key|828713|text|我找到了一个能产生随机十六进制编码字符串的解决方案。所提供的单元测试似乎支持我的主要用例。虽然，它比提供的一些其他答案略复杂一些。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828714|/**
+*+Generate+a+random+hex+encoded+string+token+of+the+specified+length
+*++
+*+@param+length
+*+@return+random+hex+string
+*/
public+static+synchronized+String+generateUniqueToken(Integer+length){+
++++byte+random[]+=+new+byte[length];
++++Random+randomGenerator+=+new+Random();
++++StringBuffer+buffer+=+new+StringBuffer();

++++randomGenerator.nextBytes(random);

++++for+(int+j+=+0;+j+<+random.length;+j%2B%2B)+{
++++++++byte+b1+=+(byte)+((random[j]+&+0xf0)+>>+4);
++++++++byte+b2+=+(byte)+(random[j]+&+0x0f);
++++++++if+(b1+<+10)
++++++++++++buffer.append((char)+('0'+%2B+b1));
++++++++else
++++++++++++buffer.append((char)+('A'+%2B+(b1+-+10)));
++++++++if+(b2+<+10)
++++++++++++buffer.append((char)+('0'+%2B+b2));
++++++++else
++++++++++++buffer.append((char)+('A'+%2B+(b2+-+10)));
++++}
++++return+(buffer.toString());
}

@Test
public+void+testGenerateUniqueToken(){
++++Set+set+=+new+HashSet();
++++String+token+=+null;
++++int+size+=+16;

++++/*+Seems+like+we+should+be+able+to+generate+500K+tokens+
+++++*+without+a+duplicate+
+++++*/
++++for+(int+i=0;+i<500000;+i%2B%2B){
++++++++token+=+Utility.generateUniqueToken(size);

++++++++if+(token.length()+!=+size+*+2){
++++++++++++fail("Incorrect+length");
++++++++}+else+if+(set.contains(token))+{
++++++++++++fail("Duplicate+token+generated");
++++++++}+else{
++++++++++++set.add(token);
++++++++}
++++}
}|code-block|syntax|javascript|828715|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I found this solution that generates a random hex encoded string. The provided unit test seems to hold up to my primary use case. Although, it is slightly more complex than some of the other answers provided.

<pre><code>/**
 * Generate a random hex encoded string token of the specified length
 * 
 * @param length
 * @return random hex string
 */
public static synchronized String generateUniqueToken(Integer length){ 
 byte random[] = new byte[length];
 Random randomGenerator = new Random();
 StringBuffer buffer = new StringBuffer();

 randomGenerator.nextBytes(random);

 for (int j = 0; j &lt; random.length; j++) {
 byte b1 = (byte) ((random[j] &amp; 0xf0) &gt;&gt; 4);
 byte b2 = (byte) (random[j] &amp; 0x0f);
 if (b1 &lt; 10)
 buffer.append((char) ('0' + b1));
 else
 buffer.append((char) ('A' + (b1 - 10)));
 if (b2 &lt; 10)
 buffer.append((char) ('0' + b2));
 else
 buffer.append((char) ('A' + (b2 - 10)));
 }
 return (buffer.toString());
}

@Test
public void testGenerateUniqueToken(){
 Set set = new HashSet();
 String token = null;
 int size = 16;

 /* Seems like we should be able to generate 500K tokens 
 * without a duplicate 
 */
 for (int i=0; i&lt;500000; i++){
 token = Utility.generateUniqueToken(size);

 if (token.length() != size * 2){
 fail("Incorrect length");
 } else if (set.contains(token)) {
 fail("Duplicate token generated");
 } else{
 set.add(token);
 }
 }
}
</code></pre>

blocks|key|1123047|text|如果您喜欢使用Apache类，可以使用org.apache.commons.text.RandomStringGenerator+(Apache共用文本)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1123048|示例：|1123049|RandomStringGenerator+randomStringGenerator+=
++++++++new+RandomStringGenerator.Builder()
++++++++++++++++.withinRange('0',+'z')
++++++++++++++++.filteredBy(CharacterPredicates.LETTERS,+CharacterPredicates.DIGITS)
++++++++++++++++.build();
randomStringGenerator.generate(12);+//+toUpperCase()+if+you+want|code-block|syntax|javascript|1123050|自从阿帕奇公域朗+3.6以来，就不再推荐RandomStringUtils了。|1123051|entityMap|0|LINK|mutability|MUTABLE|url|https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/RandomStringGenerator.html|1|https://en.wikipedia.org/wiki/Apache_Commons#Commons_Proper|2^0|J|19|J|19|0|1U|A|1|0|0|0|K|H|2|6|2|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]|$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|6|7|18|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|O|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]|Y|$5|R|S|T|E|$U|X]]]]

If you're happy to use Apache classes, you could use <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/RandomStringGenerator.html" rel="noreferrer"><code>org.apache.commons.text.RandomStringGenerator</code></a> (<a href="https://en.wikipedia.org/wiki/Apache_Commons#Commons_Proper" rel="noreferrer">Apache Commons Text</a>).
Example:
<pre><code>RandomStringGenerator randomStringGenerator =
 new RandomStringGenerator.Builder()
 .withinRange('0', 'z')
 .filteredBy(CharacterPredicates.LETTERS, CharacterPredicates.DIGITS)
 .build();
randomStringGenerator.generate(12); // toUpperCase() if you want
</code></pre>
Since <a href="https://en.wikipedia.org/wiki/Apache_Commons#Commons_Proper" rel="noreferrer">Apache Commons Lang</a> 3.6, <code>RandomStringUtils</code> is deprecated.

blocks|key|1123106|text|我已经开发了一个应用程序来为我的项目开发一个自动生成的幻影字符串。在这个字符串中，前三个字符是字母，后面七个是整数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123107|public+class+AlphaNumericGenerator+{

++++public+static+void+main(String[]+args)+{
++++++++java.util.Random+r+=+new+java.util.Random();
++++++++int+i+=+1,+n+=+0;
++++++++char+c;
++++++++String+str+=+"";
++++++++for+(int+t+=+0;+t+<+3;+t%2B%2B)+{
++++++++++++while+(true)+{
++++++++++++++++i+=+r.nextInt(10);
++++++++++++++++if+(i+>+5+&&+i+<+10)+{

++++++++++++++++++++if+(i+==+9)+{
++++++++++++++++++++++++i+=+90;
++++++++++++++++++++++++n+=+90;
++++++++++++++++++++++++break;
++++++++++++++++++++}
++++++++++++++++++++if+(i+!=+90)+{
++++++++++++++++++++++++n+=+i+*+10+%2B+r.nextInt(10);
++++++++++++++++++++++++while+(n+<+65)+{
++++++++++++++++++++++++++++n+=+i+*+10+%2B+r.nextInt(10);
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}
++++++++++++c+=+(char)n;

++++++++++++str+=+String.valueOf(c)+%2B+str;
++++++++}

++++++++while(true){
++++++++++++i+=+r.nextInt(10000000);
++++++++++++if(i+>+999999)
++++++++++++++++break;
++++++++}
++++++++str+=+str+%2B+i;
++++++++System.out.println(str);
++++}
}|code-block|syntax|javascript|1123108|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I have developed an application to develop an autogenerated alphanumberic string for my project. In this string, the first three characters are alphabetical and the next seven are integers.
<pre><code>public class AlphaNumericGenerator {

 public static void main(String[] args) {
 java.util.Random r = new java.util.Random();
 int i = 1, n = 0;
 char c;
 String str = &quot;&quot;;
 for (int t = 0; t &lt; 3; t++) {
 while (true) {
 i = r.nextInt(10);
 if (i &gt; 5 &amp;&amp; i &lt; 10) {

 if (i == 9) {
 i = 90;
 n = 90;
 break;
 }
 if (i != 90) {
 n = i * 10 + r.nextInt(10);
 while (n &lt; 65) {
 n = i * 10 + r.nextInt(10);
 }
 }
 break;
 }
 }
 c = (char)n;

 str = String.valueOf(c) + str;
 }

 while(true){
 i = r.nextInt(10000000);
 if(i &gt; 999999)
 break;
 }
 str = str + i;
 System.out.println(str);
 }
}
</code></pre>

blocks|key|1123121|text|使用美元应该非常简单，如：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1123122|//+"0123456789"+%2B+"ABCDE...Z"
String+validCharacters+=+$('0',+'9').join()+%2B+$('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));
++++}
}|code-block|syntax|javascript|1123123|它输出如下内容：|1123124|DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7|1123125|entityMap|0|LINK|mutability|MUTABLE|url|https://bitbucket.org/adamldavis/dollar/^0|2|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Using <a href="https://bitbucket.org/adamldavis/dollar/" rel="nofollow noreferrer">Dollar</a> should be as simple as:
<pre><code>// &quot;0123456789&quot; + &quot;ABCDE...Z&quot;
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));
 }
}
</code></pre>
It outputs something like this:
<pre class="lang-none prettyprint-override"><code>DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7
</code></pre>

blocks|key|828807|text|import+java.util.*;
import+javax.swing.*;

public+class+alphanumeric+{
++++public+static+void+main(String+args[])+{
++++++++String+nval,+lenval;
++++++++int+n,+len;

++++++++nval+=+JOptionPane.showInputDialog("Enter+number+of+codes+you+require:+");
++++++++n+=+Integer.parseInt(nval);

++++++++lenval+=+JOptionPane.showInputDialog("Enter+code+length+you+require:+");
++++++++len+=+Integer.parseInt(lenval);

++++++++find(n,+len);
++++}

++++public+static+void+find(int+n,+int+length)+{
++++++++String+str1+=+"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
++++++++StringBuilder+sb+=+new+StringBuilder(length);
++++++++Random+r+=+new+Random();

++++++++System.out.println("\n\t+Unique+codes+are+\n\n");
++++++++for(int+i=0;+i<n;+i%2B%2B)+{
++++++++++++for(int+j=0;+j<length;+j%2B%2B)+{
++++++++++++++++sb.append(str1.charAt(r.nextInt(str1.length())));
++++++++++++}
++++++++++++System.out.println("++"+%2B+sb.toString());
++++++++++++sb.delete(0,+length);
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|828808|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.util.*;
import javax.swing.*;

public class alphanumeric {
 public static void main(String args[]) {
 String nval, lenval;
 int n, len;

 nval = JOptionPane.showInputDialog(&quot;Enter number of codes you require: &quot;);
 n = Integer.parseInt(nval);

 lenval = JOptionPane.showInputDialog(&quot;Enter code length you require: &quot;);
 len = Integer.parseInt(lenval);

 find(n, len);
 }

 public static void find(int n, int length) {
 String str1 = &quot;0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
 StringBuilder sb = new StringBuilder(length);
 Random r = new Random();

 System.out.println(&quot;\n\t Unique codes are \n\n&quot;);
 for(int i=0; i&lt;n; i++) {
 for(int j=0; j&lt;length; j++) {
 sb.append(str1.charAt(r.nextInt(str1.length())));
 }
 System.out.println(&quot; &quot; + sb.toString());
 sb.delete(0, length);
 }
 }
}
</code></pre>

blocks|key|828840|text|您提到了“简单”，但万一其他人正在寻找满足更严格的安全要求的东西，您可能想看看jpwgen。jpwgen是以Unix中的普根为模型的，并且是非常可配置的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|828841|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/zhelev/jpwgen|1|http://sourceforge.net/projects/pwgen/^0|13|6|0|1O|2|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

You mention "simple", but just in case anyone else is looking for something that meets more stringent security requirements, you might want to take a look at <a href="https://github.com/zhelev/jpwgen" rel="nofollow noreferrer">jpwgen</a>. jpwgen is modeled after <a href="http://sourceforge.net/projects/pwgen/" rel="nofollow noreferrer">pwgen</a> in Unix, and is very configurable.

blocks|key|124054|text|import+java.util.Random;

public+class+passGen{
++++//+Version+1.0
++++private+static+final+String+dCase+=+"abcdefghijklmnopqrstuvwxyz";
++++private+static+final+String+uCase+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
++++private+static+final+String+sChar+=+"!@#$%25%5E&*";
++++private+static+final+String+intChar+=+"0123456789";
++++private+static+Random+r+=+new+Random();
++++private+static+StringBuilder+pass+=+new+StringBuilder();

++++public+static+void+main+(String[]+args)+{
++++++++System.out.println+("Generating+pass...");
++++++++while+(pass.length+()+!=+16){
++++++++++++int+rPick+=+r.nextInt(4);
++++++++++++if+(rPick+==+0){
++++++++++++++++int+spot+=+r.nextInt(26);
++++++++++++++++pass.append(dCase.charAt(spot));
++++++++++++}+else+if+(rPick+==+1)+{
++++++++++++++++int+spot+=+r.nextInt(26);
++++++++++++++++pass.append(uCase.charAt(spot));
++++++++++++}+else+if+(rPick+==+2)+{
++++++++++++++++int+spot+=+r.nextInt(8);
++++++++++++++++pass.append(sChar.charAt(spot));
++++++++++++}+else+{
++++++++++++++++int+spot+=+r.nextInt(10);
++++++++++++++++pass.append(intChar.charAt(spot));
++++++++++++}
++++++++}
++++++++System.out.println+("Generated+Pass:+"+%2B+pass.toString());
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|124055|这只会把密码加到字符串里然后..。是啊，效果很好。看看它..。这很简单，是我写的。|unstyled|124056|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import java.util.Random;

public class passGen{
 // Version 1.0
 private static final String dCase = &quot;abcdefghijklmnopqrstuvwxyz&quot;;
 private static final String uCase = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
 private static final String sChar = &quot;!@#$%^&amp;*&quot;;
 private static final String intChar = &quot;0123456789&quot;;
 private static Random r = new Random();
 private static StringBuilder pass = new StringBuilder();

 public static void main (String[] args) {
 System.out.println (&quot;Generating pass...&quot;);
 while (pass.length () != 16){
 int rPick = r.nextInt(4);
 if (rPick == 0){
 int spot = r.nextInt(26);
 pass.append(dCase.charAt(spot));
 } else if (rPick == 1) {
 int spot = r.nextInt(26);
 pass.append(uCase.charAt(spot));
 } else if (rPick == 2) {
 int spot = r.nextInt(8);
 pass.append(sChar.charAt(spot));
 } else {
 int spot = r.nextInt(10);
 pass.append(intChar.charAt(spot));
 }
 }
 System.out.println (&quot;Generated Pass: &quot; + pass.toString());
 }
}
</code></pre>
This just adds the password into the string and... yeah, it works well. Check it out... It is very simple; I wrote it.

blocks|key|824755|text|一个简短而简单的解决方案，但它只使用小写和数字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|824756|Random+r+=+new+java.util.Random+();
String+s+=+Long.toString+(r.nextLong+()+&+Long.MAX_VALUE,+36);|code-block|syntax|javascript|824757|尺寸大约是12位到基数36，不能进一步改进，这样。当然，您可以附加多个实例。|824758|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A short and easy solution, but it uses only lowercase and numerics:
<pre><code>Random r = new java.util.Random ();
String s = Long.toString (r.nextLong () &amp; Long.MAX_VALUE, 36);
</code></pre>
The size is about 12 digits to base 36 and can't be improved further, that way. Of course you can append multiple instances.

blocks|key|1123328|text|最佳随机串发生器法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123329|public+class+RandomStringGenerator{

++++private+static+int+randomStringLength+=+25+;
++++private+static+boolean+allowSpecialCharacters+=+true+;
++++private+static+String+specialCharacters+=+"!@$%25*-_%2B:";
++++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%2B%2B)+{
++++++++++++++++int+selChar+=+(int)+(Math.random()+*+(values.length()+-+1));
++++++++++++++++if+(allowSpecialCharacters)
++++++++++++++++{
++++++++++++++++++++if+(specialCharacters.indexOf(""+%2B+values.charAt(selChar))+>+-1)
++++++++++++++++++++{
++++++++++++++++++++++++specialCharactersCount+%2B%2B;
++++++++++++++++++++++++if+(specialCharactersCount+>+maxspecialCharacters)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++while+(specialCharacters.indexOf(""+%2B+values.charAt(selChar))+!=+-1)
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++selChar+=+(int)+(Math.random()+*+(values.length()+-+1));
++++++++++++++++++++++++++++}
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++returnVal+%2B=+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+%7C%7C+isAlphanum)+{
++++++++++++list.append(num);
++++++++}
++++++++if+(isAlpha+%7C%7C+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%2B%2B)+{
++++++++++++int+selChar+=+(int)+(Math.random()+*+(list.length()+-+1));
++++++++++++returnVal+%2B=+list.charAt(selChar);
++++++++++++list.deleteCharAt(selChar);
++++++++}
++++++++list+=+new+StringBuffer(returnVal);
++++++++return+list;
++++}+++

}|code-block|syntax|javascript|1123330|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Best Random String Generator Method

<pre><code>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 &lt; randomStringLength; inx++) {
 int selChar = (int) (Math.random() * (values.length() - 1));
 if (allowSpecialCharacters)
 {
 if (specialCharacters.indexOf("" + values.charAt(selChar)) &gt; -1)
 {
 specialCharactersCount ++;
 if (specialCharactersCount &gt; 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 &lt; currLen; inx++) {
 int selChar = (int) (Math.random() * (list.length() - 1));
 returnVal += list.charAt(selChar);
 list.deleteCharAt(selChar);
 }
 list = new StringBuffer(returnVal);
 return list;
 } 

}
</code></pre>

blocks|key|124151|text|您可以为此使用阿帕奇公域库，RandomStringUtils|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|124152|RandomStringUtils.randomAlphanumeric(20).toUpperCase();|code-block|syntax|javascript|124153|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Apache_Commons|1|http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/RandomStringUtils.html^0|7|5|0|E|H|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

You can use an <a href="https://en.wikipedia.org/wiki/Apache_Commons" rel="noreferrer">Apache Commons</a> library for this, <a href="http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/RandomStringUtils.html" rel="noreferrer">RandomStringUtils</a>:
<pre><code>RandomStringUtils.randomAlphanumeric(20).toUpperCase();
</code></pre>

blocks|key|828928|text|这里是Scala解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828929|(for+(i+<-+0+until+rnd.nextInt(64))+yield+{+
++('0'+%2B+rnd.nextInt(64)).asInstanceOf[Char]+
})+mkString("")|code-block|syntax|javascript|828930|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here it is a Scala solution:

<pre><code>(for (i &lt;- 0 until rnd.nextInt(64)) yield { 
 ('0' + rnd.nextInt(64)).asInstanceOf[Char] 
}) mkString("")
</code></pre>

blocks|key|124183|text|public+static+String+generateSessionKey(int+length){
++++String+alphabet+=
++++++++new+String("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");+//+9

++++int+n+=+alphabet.length();+//+10

++++String+result+=+new+String();
++++Random+r+=+new+Random();+//+11

++++for+(int+i=0;+i<length;+i%2B%2B)+//+12
++++++++result+=+result+%2B+alphabet.charAt(r.nextInt(n));+//13

++++return+result;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|124184|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static String generateSessionKey(int length){
 String alphabet =
 new String(&quot;0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&quot;); // 9

 int n = alphabet.length(); // 10

 String result = new String();
 Random r = new Random(); // 11

 for (int i=0; i&lt;length; i++) // 12
 result = result + alphabet.charAt(r.nextInt(n)); //13

 return result;
}
</code></pre>

blocks|key|124223|text|使用阿帕奇公域库，可以在一行中完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|124224|import+org.apache.commons.lang.RandomStringUtils;
RandomStringUtils.randomAlphanumeric(64);|code-block|syntax|javascript|124225|文档|124226|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Apache_Commons|1|http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/RandomStringUtils.html^0|2|5|0|0|0|0|2|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

Using an <a href="https://en.wikipedia.org/wiki/Apache_Commons" rel="nofollow noreferrer">Apache Commons</a> library, it can be done in one line:
<pre><code>import org.apache.commons.lang.RandomStringUtils;
RandomStringUtils.randomAlphanumeric(64);
</code></pre>
<a href="http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/RandomStringUtils.html" rel="nofollow noreferrer">Documentation</a>

blocks|key|124241|text|令人惊讶的是，这里没有人提出这个建议，但是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|124242|import+java.util.UUID

UUID.randomUUID().toString();|code-block|syntax|javascript|124243|很简单。|124244|这样做的好处是UUID很好，很长，并且保证几乎不可能发生冲突。|124245|维基百科有很好的解释：|offset|length|124246|“在接下来的100年中，...only每秒产生10亿UUID之后，只创建一个副本的概率大约为50%25。”|blockquote|124247|前四位是版本类型，两位是变体，所以你可以得到122位随机数据。因此，如果需要，可以从末端截断以减小UUID的大小。这是不推荐的，但你仍然有大量的随机性，足以使你的500+K记录容易。|124248|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates^0|0|0|0|0|5|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|15|8|@]|9|@$M|16|N|17|1|18]]|A|$]]|$1|O|3|P|5|Q|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1A|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Surprising, no one here has suggested it, but:
<pre><code>import java.util.UUID

UUID.randomUUID().toString();
</code></pre>
Easy.
The benefit of this is UUIDs are nice, long, and guaranteed to be almost impossible to collide.
Wikipedia has <a href="http://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates" rel="nofollow noreferrer">a good explanation</a> of it:
<blockquote>
&quot; ...only after generating 1 billion UUIDs every second for the next 100 years, the probability of creating just one duplicate would be about 50%.&quot;
</blockquote>
The first four bits are the version type and two for the variant, so you get 122 bits of random. So if you want to, you can truncate from the end to reduce the size of the UUID. It's not recommended, but you still have loads of randomness, enough for your 500k records easy.

blocks|key|1123521|text|如果密码强制包含数字和字母特殊字符，则可以使用以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123522|private+static+final+String+NUMBERS+=+"0123456789";
private+static+final+String+UPPER_ALPHABETS+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private+static+final+String+LOWER_ALPHABETS+=+"abcdefghijklmnopqrstuvwxyz";
private+static+final+String+SPECIALCHARACTERS+=+"@#$%25&*";
private+static+final+int+MINLENGTHOFPASSWORD+=+8;

public+static+String+getRandomPassword()+{
++++StringBuilder+password+=+new+StringBuilder();
++++int+j+=+0;
++++for+(int+i+=+0;+i+<+MINLENGTHOFPASSWORD;+i%2B%2B)+{
++++++++password.append(getRandomPasswordCharacters(j));
++++++++j%2B%2B;
++++++++if+(j+==+3)+{
++++++++++++j+=+0;
++++++++}
++++}
++++return+password.toString();
}

private+static+String+getRandomPasswordCharacters(int+pos)+{
++++Random+randomNum+=+new+Random();
++++StringBuilder+randomChar+=+new+StringBuilder();
++++switch+(pos)+{
++++++++case+0:
++++++++++++randomChar.append(NUMBERS.charAt(randomNum.nextInt(NUMBERS.length()+-+1)));
++++++++++++break;
++++++++case+1:
++++++++++++randomChar.append(UPPER_ALPHABETS.charAt(randomNum.nextInt(UPPER_ALPHABETS.length()+-+1)));
++++++++++++break;
++++++++case+2:
++++++++++++randomChar.append(SPECIALCHARACTERS.charAt(randomNum.nextInt(SPECIALCHARACTERS.length()+-+1)));
++++++++++++break;
++++++++case+3:
++++++++++++randomChar.append(LOWER_ALPHABETS.charAt(randomNum.nextInt(LOWER_ALPHABETS.length()+-+1)));
++++++++++++break;
++++}
++++return+randomChar.toString();
}|code-block|syntax|javascript|1123523|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use the following code, if your password mandatory contains numbers and alphabetic special characters:
<pre><code>private static final String NUMBERS = &quot;0123456789&quot;;
private static final String UPPER_ALPHABETS = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
private static final String LOWER_ALPHABETS = &quot;abcdefghijklmnopqrstuvwxyz&quot;;
private static final String SPECIALCHARACTERS = &quot;@#$%&amp;*&quot;;
private static final int MINLENGTHOFPASSWORD = 8;

public static String getRandomPassword() {
 StringBuilder password = new StringBuilder();
 int j = 0;
 for (int i = 0; i &lt; MINLENGTHOFPASSWORD; i++) {
 password.append(getRandomPasswordCharacters(j));
 j++;
 if (j == 3) {
 j = 0;
 }
 }
 return password.toString();
}

private static String getRandomPasswordCharacters(int pos) {
 Random randomNum = new Random();
 StringBuilder randomChar = new StringBuilder();
 switch (pos) {
 case 0:
 randomChar.append(NUMBERS.charAt(randomNum.nextInt(NUMBERS.length() - 1)));
 break;
 case 1:
 randomChar.append(UPPER_ALPHABETS.charAt(randomNum.nextInt(UPPER_ALPHABETS.length() - 1)));
 break;
 case 2:
 randomChar.append(SPECIALCHARACTERS.charAt(randomNum.nextInt(SPECIALCHARACTERS.length() - 1)));
 break;
 case 3:
 randomChar.append(LOWER_ALPHABETS.charAt(randomNum.nextInt(LOWER_ALPHABETS.length() - 1)));
 break;
 }
 return randomChar.toString();
}
</code></pre>

blocks|key|124261|text|public+static+String+getRandomString(int+length)
{
++++String+randomStr+=+UUID.randomUUID().toString();
++++while(randomStr.length()+<+length)+{
++++++++randomStr+%2B=+UUID.randomUUID().toString();
++++}
++++return+randomStr.substring(0,+length);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|124262|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static String getRandomString(int length)
{
 String randomStr = UUID.randomUUID().toString();
 while(randomStr.length() &lt; length) {
 randomStr += UUID.randomUUID().toString();
 }
 return randomStr.substring(0, length);
}
</code></pre>

blocks|key|124264|text|在以前的回答中有很多使用StringBuilder的方法。我想这很容易，但是它需要每个字符调用一个函数，生成一个数组，等等.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|124265|如果使用字符串生成器，则建议指定字符串的所需容量，即，|124266|new+StringBuilder(int+capacity);|code-block|syntax|javascript|124267|这里有一个版本，不使用StringBuilder或字符串附加，也不使用字典。|124268|public+static+String+randomString(int+length)
{
++++SecureRandom+random+=+new+SecureRandom();
++++char[]+chars+=+new+char[length];
++++for(int+i=0;+i<chars.length;+i%2B%2B)
++++{
++++++++int+v+=+random.nextInt(10+%2B+26+%2B+26);
++++++++char+c;
++++++++if+(v+<+10)
++++++++{
++++++++++++c+=+(char)('0'+%2B+v);
++++++++}
++++++++else+if+(v+<+36)
++++++++{
++++++++++++c+=+(char)('a'+-+10+%2B+v);
++++++++}
++++++++else
++++++++{
++++++++++++c+=+(char)('A'+-+36+%2B+v);
++++++++}
++++++++chars[i]+=+c;
++++}
++++return+new+String(chars);
}|124269|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

There are lots of use of StringBuilder in previous answers. I guess it's easy, but it requires a function call per character, growing an array, etc...
If using the stringbuilder, a suggestion is to specify the required capacity of the string, i.e.,
<pre><code>new StringBuilder(int capacity);
</code></pre>
Here's a version that doesn't use a StringBuilder or String appending, and no dictionary.
<pre><code>public static String randomString(int length)
{
 SecureRandom random = new SecureRandom();
 char[] chars = new char[length];
 for(int i=0; i&lt;chars.length; i++)
 {
 int v = random.nextInt(10 + 26 + 26);
 char c;
 if (v &lt; 10)
 {
 c = (char)('0' + v);
 }
 else if (v &lt; 36)
 {
 c = (char)('a' - 10 + v);
 }
 else
 {
 c = (char)('A' - 36 + v);
 }
 chars[i] = c;
 }
 return new String(chars);
}
</code></pre>

blocks|key|124271|text|public+static+String+randomSeriesForThreeCharacter()+{
++++Random+r+=+new+Random();
++++String+value+=+"";
++++char+random_Char+;
++++for(int+i=0;+i<10;+i%2B%2B)
++++{
++++++++random_Char+=+(char)+(48+%2B+r.nextInt(74));
++++++++value+=+value+%2B+random_char;
++++}
++++return+value;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|124272|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static String randomSeriesForThreeCharacter() {
 Random r = new Random();
 String value = &quot;&quot;;
 char random_Char ;
 for(int i=0; i&lt;10; i++)
 {
 random_Char = (char) (48 + r.nextInt(74));
 value = value + random_char;
 }
 return value;
}
</code></pre>

blocks|key|824895|text|您可以创建一个包含所有字母和数字的字符数组，然后可以从这个字符数组中随机选择并创建您自己的字符串密码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|824896|char[]+chars+=+new+char[62];+//+Sum+of+letters+and+numbers

int+i+=+0;

for(char+c+=+'a';+c+<=+'z';+c%2B%2B)+{+//+For+letters
++++chars[i%2B%2B]+=+c;
}

for(char+c+=+'0';+c+<=+'9';c%2B%2B)+{+//+For+numbers
++++chars[i%2B%2B]+=+c;
}

for(char+c+=+'A';+c+<=+'Z';c%2B%2B)+{+//+For+capital+letters
++++chars[i%2B%2B]+=+c;
}

int+numberOfCodes+=+0;
String+code+=+"";
while+(numberOfCodes+<+1)+{+//+Enter+how+much+you+want+to+generate+at+one+time
++++int+numChars+=+8;+//+Enter+how+many+digits+you+want+in+your+password

++++for(i+=+0;+i+<+numChars;+i%2B%2B)+{
++++++++char+c+=+chars[(int)(Math.random()+*+chars.length)];
++++++++code+=+code+%2B+c;
++++}
++++System.out.println("Code+is:"+%2B+code);
}|code-block|syntax|javascript|824897|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can create a character array which includes all the letters and numbers, and then you can randomly select from this character array and create your own string password.
<pre><code>char[] chars = new char[62]; // Sum of letters and numbers

int i = 0;

for(char c = 'a'; c &lt;= 'z'; c++) { // For letters
 chars[i++] = c;
}

for(char c = '0'; c &lt;= '9';c++) { // For numbers
 chars[i++] = c;
}

for(char c = 'A'; c &lt;= 'Z';c++) { // For capital letters
 chars[i++] = c;
}

int numberOfCodes = 0;
String code = &quot;&quot;;
while (numberOfCodes &lt; 1) { // Enter how much you want to generate at one time
 int numChars = 8; // Enter how many digits you want in your password

 for(i = 0; i &lt; numChars; i++) {
 char c = chars[(int)(Math.random() * chars.length)];
 code = code + c;
 }
 System.out.println(&quot;Code is:&quot; + code);
}
</code></pre>

blocks|key|124322|text|您可以使用UUID类及其getLeastSignificantBits()消息获取64位随机数据，然后将其转换为基36数字(即包含0-9，and的字符串)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|124323|Long.toString(Math.abs(+UUID.randomUUID().getLeastSignificantBits(),+36));|code-block|syntax|javascript|124324|这会产生长达13个字符的字符串。我们使用Math.abs()来确保没有负号潜入。|124325|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use the UUID class with its getLeastSignificantBits() message to get 64 bit of random data, and then convert it to a radix 36 number (i.e. a string consisting of 0-9,A-Z):
<pre><code>Long.toString(Math.abs( UUID.randomUUID().getLeastSignificantBits(), 36));
</code></pre>
This yields a string up to 13 characters long. We use Math.abs() to make sure there isn't a minus sign sneaking in.

blocks|key|1123636|text|根据需要更改字符串字符。|type|ordered-list-item|depth|inlineStyleRanges|entityRanges|data|1123637|字符串是不可变的。在这里，StringBuilder.append比字符串级联更有效。|offset|length|style|CODE|1123638|​|unstyled|1123639|public+static+String+getRandomString(int+length)+{
++++final+String+characters+=+"abcdefghijklmnopqrstuvwxyzABCDEFGHIJLMNOPQRSTUVWXYZ1234567890!@#$%25%5E&*()_%2B";
++++StringBuilder+result+=+new+StringBuilder();

++++while(length+>+0)+{
++++++++Random+rand+=+new+Random();
++++++++result.append(characters.charAt(rand.nextInt(characters.length())));
++++++++length--;
++++}
++++return+result.toString();
}|code-block|syntax|javascript|1123640|entityMap^0|0|D|K|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|W|8|@]|9|@]|A|$N|O]]|$1|P|3|-4|5|J|7|X|8|@]|9|@]|A|$]]]|Q|$]]

<ol>
<li>Change String characters as per as your requirements.
</li>
<li>String is immutable. Here <code>StringBuilder.append</code> is more efficient than string concatenation.
</li>
</ol>
 
<pre><code>public static String getRandomString(int length) {
 final String characters = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJLMNOPQRSTUVWXYZ1234567890!@#$%^&amp;*()_+&quot;;
 StringBuilder result = new StringBuilder();

 while(length &gt; 0) {
 Random rand = new Random();
 result.append(characters.charAt(rand.nextInt(characters.length())));
 length--;
 }
 return result.toString();
}
</code></pre>

blocks|key|1123647|text|Java+8中的另一种选择是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123648|static+final+Random+random+=+new+Random();+//+Or+SecureRandom
static+final+int+startChar+=+(int)+'!';
static+final+int+endChar+=+(int)+'~';

static+String+randomString(final+int+maxLength)+{
++final+int+length+=+random.nextInt(maxLength+%2B+1);
++return+random.ints(length,+startChar,+endChar+%2B+1)
++++++++.collect(StringBuilder::new,+StringBuilder::appendCodePoint,+StringBuilder::append)
++++++++.toString();
}|code-block|syntax|javascript|1123649|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

An alternative in Java 8 is:

<pre><code>static final Random random = new Random(); // Or SecureRandom
static final int startChar = (int) '!';
static final int endChar = (int) '~';

static String randomString(final int maxLength) {
 final int length = random.nextInt(maxLength + 1);
 return random.ints(length, startChar, endChar + 1)
 .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
 .toString();
}
</code></pre>

blocks|key|829063|text|另一个解决办法..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829064|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%2B%2B)+{
++++++++int+charIndex;

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

++++++++builder.append((char)+charIndex);
++++}
++++return+builder.toString();
}|code-block|syntax|javascript|829065|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yet another solution...
<pre><code>public static String generatePassword(int passwordLength) {
 int asciiFirst = 33;
 int asciiLast = 126;
 Integer[] exceptions = { 34, 39, 96 };

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

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

 builder.append((char) charIndex);
 }
 return builder.toString();
}
</code></pre>

blocks|key|124427|text|使用UUID是不安全的，因为UUID的一部分根本不是随机的。埃里克森程序非常整洁，但它不会创建相同长度的字符串。以下片段应该足够了：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|124428|/*
+*+The+random+generator+used+by+this+class+to+create+random+keys.
+*+In+a+holder+class+to+defer+initialization+until+needed.
+*/
private+static+class+RandomHolder+{
++++static+final+Random+random+=+new+SecureRandom();
++++public+static+String+randomKey(int+length)+{
++++++++return+String.format("%25"%2Blength%2B"s",+new+BigInteger(length*5/*base+32,2%5E5*/,+random)
++++++++++++.toString(32)).replace('\u0020',+'0');
++++}
}|code-block|syntax|javascript|124429|为什么选择length*5？让我们假设一个长度为1的随机字符串的简单情况，所以是一个随机字符。要获得包含所有数字0-9和字符and的随机字符，我们需要一个0到35之间的随机数才能得到每个字符中的一个。|style|CODE|124430|BigInteger提供了一个构造函数来生成一个随机数，该随机数均匀分布在0+to+(2%5EnumBits+-+1)范围内。不幸的是，35不是一个可以被2%5EnumBits+-+1接收的数字。|124431|因此，我们有两个选择:要么使用2%5E5-1=31，要么使用2%5E6-1=63。如果我们选择2%5E6，我们将得到许多“不必要”/“更长”的数字。因此，2%5E5是更好的选择，即使我们失去了四个字符(w-z)。现在要生成一定长度的字符串，我们可以简单地使用一个2%5E(length*numBits)-1数字。最后一个问题，如果我们想要一个具有一定长度的字符串，随机可以生成一个小的数字，所以长度不能满足，所以我们必须将字符串放置到它所需的长度前置零。|124432|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/41107/how-to-generate-a-random-alpha-numeric-string/41156#41156^0|U|6|0|0|0|5|8|0|0|A|11|K|0|F|8|S|8|17|3|1Z|3|3F|K|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@$A|14|B|15|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|16|8|@$A|17|B|18|K|L]|$A|19|B|1A|K|L]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1B|8|@$A|1C|B|1D|K|L]|$A|1E|B|1F|K|L]|$A|1G|B|1H|K|L]|$A|1I|B|1J|K|L]|$A|1K|B|1L|K|L]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Using UUIDs is insecure, because parts of the UUID aren't random at all. The <a href="https://stackoverflow.com/questions/41107/how-to-generate-a-random-alpha-numeric-string/41156#41156">procedure of erickson</a> is very neat, but it does not create strings of the same length. The following snippet should be sufficient:
<pre><code>/*
 * The random generator used by this class to create random keys.
 * In a holder class to defer initialization until needed.
 */
private static class RandomHolder {
 static final Random random = new SecureRandom();
 public static String randomKey(int length) {
 return String.format(&quot;%&quot;+length+&quot;s&quot;, new BigInteger(length*5/*base 32,2^5*/, random)
 .toString(32)).replace('\u0020', '0');
 }
}
</code></pre>
Why choose <code>length*5</code>? Let's assume the simple case of a random string of length 1, so one random character. To get a random character containing all digits 0-9 and characters a-z, we would need a random number between 0 and 35 to get one of each character.
<code>BigInteger</code> provides a constructor to generate a random number, uniformly distributed over the range <code>0 to (2^numBits - 1)</code>. Unfortunately 35 is not a number which can be received by 2^numBits - 1.
So we have two options: Either go with <code>2^5-1=31</code> or <code>2^6-1=63</code>. If we would choose <code>2^6</code> we would get a lot of &quot;unnecessary&quot; / &quot;longer&quot; numbers. Therefore <code>2^5</code> is the better option, even if we lose four characters (w-z). To now generate a string of a certain length, we can simply use a <code>2^(length*numBits)-1</code> number. The last problem, if we want a string with a certain length, random could generate a small number, so the length is not met, so we have to pad the string to its required length prepending zeros.

blocks|key|824952|text|也许这是有帮助的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|824953|package+password.generater;

import+java.util.Random;

/**
+*
+*+@author+dell
+*/
public+class+PasswordGenerater+{

++++/**
+++++*+@param+args+the+command+line+arguments
+++++*/
++++public+static+void+main(String[]+args)+{
++++++++int+length=+11;
++++++++System.out.println(generatePswd(length));

++++++++//+TODO+code+application+logic+here
++++}
++++static+char[]+generatePswd(int+len){
++++++++System.out.println("Your+Password+");
++++++++String+charsCaps="ABCDEFGHIJKLMNOPQRSTUVWXYZ";+
++++++++String+Chars="abcdefghijklmnopqrstuvwxyz";
++++++++String+nums="0123456789";
++++++++String+symbols="!@#$%25%5E&*()_%2B-=.,/';:?><~*/-%2B";
++++++++String+passSymbols=charsCaps+%2B+Chars+%2B+nums+%2Bsymbols;
++++++++Random+rnd=new+Random();
++++++++char[]+password=new+char[len];

++++++++for(int+i=0;+i<len;i%2B%2B){
++++++++++++password[i]=passSymbols.charAt(rnd.nextInt(passSymbols.length()));
++++++++}
++++++return+password;

++++}
}|code-block|syntax|javascript|824954|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Maybe this is helpful

<pre><code>package password.generater;

import java.util.Random;

/**
 *
 * @author dell
 */
public class PasswordGenerater {

 /**
 * @param args the command line arguments
 */
 public static void main(String[] args) {
 int length= 11;
 System.out.println(generatePswd(length));

 // TODO code application logic here
 }
 static char[] generatePswd(int len){
 System.out.println("Your Password ");
 String charsCaps="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
 String Chars="abcdefghijklmnopqrstuvwxyz";
 String nums="0123456789";
 String symbols="!@#$%^&amp;*()_+-=.,/';:?&gt;&lt;~*/-+";
 String passSymbols=charsCaps + Chars + nums +symbols;
 Random rnd=new Random();
 char[] password=new char[len];

 for(int i=0; i&lt;len;i++){
 password[i]=passSymbols.charAt(rnd.nextInt(passSymbols.length()));
 }
 return password;

 }
}
</code></pre>

blocks|key|824965|text|这是AbacusUtil的一条线|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|824966|String.valueOf(CharStream.random('0',+'z').filter(c+->+N.isLetterOrDigit(c)).limit(12).toArray())|code-block|syntax|javascript|824967|随机并不意味着它一定是独一无二的。要获得唯一的字符串，请使用：|824968|N.uuid()+//+E.g.:+"e812e749-cf4c-4959-8ee1-57829a69a80f".+length+is+36.
N.guid()+//+E.g.:+"0678ce04e18945559ba82ddeccaabfcd".+length+is+32+without+'-'|824969|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/landawn/AbacusUtil^0|2|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here is the one-liner by <a href="https://github.com/landawn/AbacusUtil" rel="nofollow noreferrer">AbacusUtil</a>:
<pre><code>String.valueOf(CharStream.random('0', 'z').filter(c -&gt; N.isLetterOrDigit(c)).limit(12).toArray())
</code></pre>
Random doesn't mean it must be unique. To get unique strings, use:
<pre><code>N.uuid() // E.g.: &quot;e812e749-cf4c-4959-8ee1-57829a69a80f&quot;. length is 36.
N.guid() // E.g.: &quot;0678ce04e18945559ba82ddeccaabfcd&quot;. length is 32 without '-'
</code></pre>

blocks|key|1123757|text|此外，您还可以通过ASCII表中的数据生成任何小写或大写字母，甚至是特殊字符。例如，从A+(DEC+65)到Z+(DEC+90)生成大写字母：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123758|String+generateRandomStr(int+min,+int+max,+int+size)+{
++++String+result+=+"";
++++for+(int+i+=+0;+i+<+size;+i%2B%2B)+{
++++++++result+%2B=+String.valueOf((char)(new+Random().nextInt((max+-+min)+%2B+1)+%2B+min));
++++}
++++return+result;
}|code-block|syntax|javascript|1123759|generateRandomStr(65,+90,+100));的生成输出|offset|length|style|CODE|1123760|TVLPFQJCYFXQDCQSLKUKKILKKHAUFYEXLUQFHDWNMRBIRRRWNXNNZQTINZPCTKLHGHVYWRKEOYNSOFPZBGEECFMCOKWHLHCEWLDZ|1123761|entityMap^0|0|0|0|W|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Also, you can generate any lowercase or uppercase letters or even special characters through data from the ASCII table. For example, generate upper case letters from A (DEC 65) to Z (DEC 90):
<pre><code>String generateRandomStr(int min, int max, int size) {
 String result = &quot;&quot;;
 for (int i = 0; i &lt; size; i++) {
 result += String.valueOf((char)(new Random().nextInt((max - min) + 1) + min));
 }
 return result;
}
</code></pre>
Generated output for <code>generateRandomStr(65, 90, 100));</code>:
<pre><code>TVLPFQJCYFXQDCQSLKUKKILKKHAUFYEXLUQFHDWNMRBIRRRWNXNNZQTINZPCTKLHGHVYWRKEOYNSOFPZBGEECFMCOKWHLHCEWLDZ
</code></pre>

blocks|key|829136|text|我真的不喜欢这些关于“简单”解决方案的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829137|我会选择一个简单的;)，纯Java，一个线性(熵基于随机字符串长度和给定的字符集)：|829138|public+String+randomString(int+length,+String+characterSet)+{
++++return+IntStream.range(0,+length).map(i+->+new+SecureRandom().nextInt(characterSet.length())).mapToObj(randomInt+->+characterSet.substring(randomInt,+randomInt+%2B+1)).collect(Collectors.joining());
}

@Test
public+void+buildFiveRandomStrings()+{
++++for+(int+q+=+0;+q+<+5;+q%2B%2B)+{
++++++++System.out.println(randomString(10,+"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));+//+The+character+set+can+basically+be+anything
++++}
}|code-block|syntax|javascript|829139|或者(更易读的旧方式)|829140|public+String+randomString(int+length,+String+characterSet)+{
++++StringBuilder+sb+=+new+StringBuilder();+//+Consider+using+StringBuffer+if+needed
++++for+(int+i+=+0;+i+<+length;+i%2B%2B)+{
++++++++int+randomInt+=+new+SecureRandom().nextInt(characterSet.length());
++++++++sb.append(characterSet.substring(randomInt,+randomInt+%2B+1));
++++}
++++return+sb.toString();
}

@Test
public+void+buildFiveRandomStrings()+{
++++for+(int+q+=+0;+q+<+5;+q%2B%2B)+{
++++++++System.out.println(randomString(10,+"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));+//+The+character+set+can+basically+be+anything
++++}
}|829141|但另一方面，您也可以使用UUID，它具有相当好的熵值：|offset|length|829142|UUID.randomUUID().toString().replace("-",+"")|829143|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions^0|0|0|0|0|0|C|4|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@$O|16|P|17|1|18]]|A|$]]|$1|Q|3|R|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

I don't really like any of these answers regarding a &quot;simple&quot; solution :S
I would go for a simple ;), pure Java, one liner (entropy is based on random string length and the given character set):
<pre><code>public String randomString(int length, String characterSet) {
 return IntStream.range(0, length).map(i -&gt; new SecureRandom().nextInt(characterSet.length())).mapToObj(randomInt -&gt; characterSet.substring(randomInt, randomInt + 1)).collect(Collectors.joining());
}

@Test
public void buildFiveRandomStrings() {
 for (int q = 0; q &lt; 5; q++) {
 System.out.println(randomString(10, &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789&quot;)); // The character set can basically be anything
 }
}
</code></pre>
Or (a bit more readable old way)
<pre><code>public String randomString(int length, String characterSet) {
 StringBuilder sb = new StringBuilder(); // Consider using StringBuffer if needed
 for (int i = 0; i &lt; length; i++) {
 int randomInt = new SecureRandom().nextInt(characterSet.length());
 sb.append(characterSet.substring(randomInt, randomInt + 1));
 }
 return sb.toString();
}

@Test
public void buildFiveRandomStrings() {
 for (int q = 0; q &lt; 5; q++) {
 System.out.println(randomString(10, &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789&quot;)); // The character set can basically be anything
 }
}
</code></pre>
But on the other hand you could also go with <a href="https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions" rel="nofollow noreferrer">UUID</a> which has a pretty good entropy:
<pre><code>UUID.randomUUID().toString().replace(&quot;-&quot;, &quot;&quot;)
</code></pre>

blocks|key|124619|text|这里有一个简单的一行，使用UUID作为字符库，并且能够指定(几乎)任何长度。(是的，我知道以前有人建议使用UUID。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|124620|public+static+String+randString(int+length)+{
++++return+UUID.randomUUID().toString().replace("-",+"").substring(0,+Math.min(length,+32))+%2B+(length+>+32+?+randString(length+-+32)+:+"");
}|code-block|syntax|javascript|124621|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a simple one-liner using UUIDs as the character base and being able to specify (almost) any length. (Yes, I know that using a UUID has been suggested before.)
<pre><code>public static String randString(int length) {
 return UUID.randomUUID().toString().replace(&quot;-&quot;, &quot;&quot;).substring(0, Math.min(length, 32)) + (length &gt; 32 ? randString(length - 32) : &quot;&quot;);
}
</code></pre>

blocks|key|124660|text|我认为这是这里最小的解决方案，或者几乎是最小的解决方案之一：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|124661|+public+String+generateRandomString(int+length)+{
++++String+randomString+=+"";

++++final+char[]+chars+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890".toCharArray();
++++final+Random+random+=+new+Random();
++++for+(int+i+=+0;+i+<+length;+i%2B%2B)+{
++++++++randomString+=+randomString+%2B+chars[random.nextInt(chars.length)];
++++}

++++return+randomString;
}|code-block|syntax|javascript|124662|代码运行得很好。如果您使用此方法，我建议您使用10个以上的字符。冲突发生在5个字符/+30362次迭代中。这花了9秒。|124663|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think this is the smallest solution here, or nearly one of the smallest:
<pre><code> public String generateRandomString(int length) {
 String randomString = &quot;&quot;;

 final char[] chars = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890&quot;.toCharArray();
 final Random random = new Random();
 for (int i = 0; i &lt; length; i++) {
 randomString = randomString + chars[random.nextInt(chars.length)];
 }

 return randomString;
}
</code></pre>
The code works just fine. If you are using this method, I recommend you to use more than 10 characters. A collision happens at 5 characters / 30362 iterations. This took 9 seconds.

blocks|key|825042|text|以下是基于流的Java+8解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825043|++++public+String+generateString(String+alphabet,+int+length)+{
++++++++return+generateString(alphabet,+length,+new+SecureRandom()::nextInt);
++++}

++++//+nextInt+=+bound+->+n+in+[0,+bound)
++++public+String+generateString(String+source,+int+length,+IntFunction<Integer>+nextInt)+{
++++++++StringBuilder+sb+=+new+StringBuilder();
++++++++IntStream.generate(source::length)
++++++++++++++++.boxed()
++++++++++++++++.limit(length)
++++++++++++++++.map(nextInt::apply)
++++++++++++++++.map(source::charAt)
++++++++++++++++.forEach(sb::append);

++++++++return+sb.toString();
++++}|code-block|syntax|javascript|825044|用它就像|825045|String+alphabet+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
int+length+=+12;
String+generated+=+generateString(alphabet,+length);
System.out.println(generated);|825046|函数nextInt应该接受一个int+bound，并在0和bound+-+1之间返回一个随机数。|offset|length|style|CODE|825047|entityMap^0|0|0|0|0|2|7|J|5|R|1|T|9|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]|$M|11|N|12|O|P]|$M|13|N|14|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

Here is a Java 8 solution based on streams.

<pre><code> public String generateString(String alphabet, int length) {
 return generateString(alphabet, length, new SecureRandom()::nextInt);
 }

 // nextInt = bound -&gt; n in [0, bound)
 public String generateString(String source, int length, IntFunction&lt;Integer&gt; nextInt) {
 StringBuilder sb = new StringBuilder();
 IntStream.generate(source::length)
 .boxed()
 .limit(length)
 .map(nextInt::apply)
 .map(source::charAt)
 .forEach(sb::append);

 return sb.toString();
 }
</code></pre>

Use it like 

<pre><code>String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
int length = 12;
String generated = generateString(alphabet, length);
System.out.println(generated);
</code></pre>

The function <code>nextInt</code> should accept an int <code>bound</code> and return a random number between <code>0</code> and <code>bound - 1</code>.

blocks|key|829198|text|效率高，时间短。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829199|/**
+*+Utility+class+for+generating+random+Strings.
+*/
public+interface+RandomUtil+{

++++int++++DEF_COUNT+=+20;
++++Random+RANDOM++++=+new+SecureRandom();

++++/**
+++++*+Generate+a+password.
+++++*
+++++*+@return+the+generated+password
+++++*/
++++static+String+generatePassword()+{
++++++++return+generate(true,+true);
++++}

++++/**
+++++*+Generate+an+activation+key.
+++++*
+++++*+@return+the+generated+activation+key
+++++*/
++++static+String+generateActivationKey()+{
++++++++return+generate(false,+true);
++++}

++++/**
+++++*+Generate+a+reset+key.
+++++*
+++++*+@return+the+generated+reset+key
+++++*/
++++static+String+generateResetKey()+{
++++++++return+generate(false,+true);
++++}

++++static+String+generate(boolean+letters,+boolean+numbers)+{
++++++++int
++++++++++++start+=+'+',
++++++++++++end+++=+'z'+%2B+1,
++++++++++++count+=+DEF_COUNT,
++++++++++++gap+++=+end+-+start;
++++++++StringBuilder+builder+=+new+StringBuilder(count);

++++++++while+(count--+!=+0)+{
++++++++++++int+codePoint+=+RANDOM.nextInt(gap)+%2B+start;

++++++++++++switch+(getType(codePoint))+{
++++++++++++++++case+UNASSIGNED:
++++++++++++++++case+PRIVATE_USE:
++++++++++++++++case+SURROGATE:
++++++++++++++++++++count%2B%2B;
++++++++++++++++++++continue;
++++++++++++}

++++++++++++int+numberOfChars+=+charCount(codePoint);

++++++++++++if+(count+==+0+&&+numberOfChars+>+1)+{
++++++++++++++++count%2B%2B;
++++++++++++++++continue;
++++++++++++}

++++++++++++if+(letters+&&+isLetter(codePoint)
++++++++++++++++%7C%7C+numbers+&&+isDigit(codePoint)
++++++++++++++++%7C%7C+!letters+&&+!numbers)+{

++++++++++++++++builder.appendCodePoint(codePoint);
++++++++++++++++if+(numberOfChars+==+2)
++++++++++++++++++++count--;
++++++++++++}
++++++++++++else
++++++++++++++++count%2B%2B;
++++++++}
++++++++return+builder.toString();
++++}
}|code-block|syntax|javascript|829200|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Efficient and short.
<pre><code>/**
 * Utility class for generating random Strings.
 */
public interface RandomUtil {

 int DEF_COUNT = 20;
 Random RANDOM = new SecureRandom();

 /**
 * Generate a password.
 *
 * @return the generated password
 */
 static String generatePassword() {
 return generate(true, true);
 }

 /**
 * Generate an activation key.
 *
 * @return the generated activation key
 */
 static String generateActivationKey() {
 return generate(false, true);
 }

 /**
 * Generate a reset key.
 *
 * @return the generated reset key
 */
 static String generateResetKey() {
 return generate(false, true);
 }

 static String generate(boolean letters, boolean numbers) {
 int
 start = ' ',
 end = 'z' + 1,
 count = DEF_COUNT,
 gap = end - start;
 StringBuilder builder = new StringBuilder(count);

 while (count-- != 0) {
 int codePoint = RANDOM.nextInt(gap) + start;

 switch (getType(codePoint)) {
 case UNASSIGNED:
 case PRIVATE_USE:
 case SURROGATE:
 count++;
 continue;
 }

 int numberOfChars = charCount(codePoint);

 if (count == 0 &amp;&amp; numberOfChars &gt; 1) {
 count++;
 continue;
 }

 if (letters &amp;&amp; isLetter(codePoint)
 || numbers &amp;&amp; isDigit(codePoint)
 || !letters &amp;&amp; !numbers) {

 builder.appendCodePoint(codePoint);
 if (numberOfChars == 2)
 count--;
 }
 else
 count++;
 }
 return builder.toString();
 }
}
</code></pre>

blocks|key|1123946|text|public+static+String+RandomAlphanum(int+length)
{
++++String+charstring+=+"abcdefghijklmnopqrstuvwxyz0123456789";
++++String+randalphanum+=+"";
++++double+randroll;
++++String+randchar;
++++for+(double+i+=+0;+i+<+length;+i%2B%2B)
++++{
++++++++randroll+=+Math.random();
++++++++randchar+=+"";
++++++++for+(int+j+=+1;+j+<=+35;+j%2B%2B)
++++++++{
++++++++++++if+(randroll+<=+(1.0+/+36.0+*+j))
++++++++++++{
++++++++++++++++randchar+=+Character.toString(charstring.charAt(j+-+1));
++++++++++++++++break;
++++++++++++}
++++++++}
++++++++randalphanum+%2B=+randchar;
++++}
++++return+randalphanum;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1123947|我使用了一个使用Math.random()的非常原始的算法。要增加随机性，可以直接实现util.Date类。尽管如此，它还是有效的。|unstyled|offset|length|style|CODE|1123948|entityMap^0|0|17|9|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>public static String RandomAlphanum(int length)
{
 String charstring = &quot;abcdefghijklmnopqrstuvwxyz0123456789&quot;;
 String randalphanum = &quot;&quot;;
 double randroll;
 String randchar;
 for (double i = 0; i &lt; length; i++)
 {
 randroll = Math.random();
 randchar = &quot;&quot;;
 for (int j = 1; j &lt;= 35; j++)
 {
 if (randroll &lt;= (1.0 / 36.0 * j))
 {
 randchar = Character.toString(charstring.charAt(j - 1));
 break;
 }
 }
 randalphanum += randchar;
 }
 return randalphanum;
}
</code></pre>
I used a very primitive algorithm using Math.random(). To increase randomness, you can directly implement the <code>util.Date</code> class. Nevertheless, it works.

blocks|key|1123983|text|我使用阿帕奇公域中的一个库来生成字母数字字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1123984|import+org.apache.commons.lang3.RandomStringUtils;

String+keyLength+=+20;
RandomStringUtils.randomAlphanumeric(keylength);|code-block|syntax|javascript|1123985|它又快又简单！|1123986|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Apache_Commons^0|3|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I'm using a library from <a href="https://en.wikipedia.org/wiki/Apache_Commons" rel="nofollow noreferrer">Apache Commons</a> to generate an alphanumeric string:
<pre><code>import org.apache.commons.lang3.RandomStringUtils;

String keyLength = 20;
RandomStringUtils.randomAlphanumeric(keylength);
</code></pre>
It's fast and simple!

blocks|key|825081|text|我使用的是一个非常简单的使用Java+8的解决方案，只需根据您的需要定制即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825082|...
import+java.security.SecureRandom;
...

//Generate+a+random+String+of+length+between+10+to+20.
//Length+is+also+randomly+generated+here.
SecureRandom+random+=+new+SecureRandom();

String+sampleSet+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";

int+stringLength+=+random.ints(1,+10,+21).mapToObj(x+->+x).reduce((a,+b)+->+a).get();

String+randomString+=+random.ints(stringLength,+0,+sampleSet.length()+-+1)
++++++++.mapToObj(x+->+sampleSet.charAt(x))
++++++++.collect(Collector
++++++++++++.of(StringBuilder::new,+StringBuilder::append,
++++++++++++++++StringBuilder::append,+StringBuilder::toString));|code-block|syntax|javascript|825083|我们可以使用它生成像这样的字母数字随机字符串(返回的字符串将强制具有一些非数字字符以及一些数字字符)：|825084|public+String+generateRandomString()+{
++++++++++++
++++String+sampleSet+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_";
++++String+sampleSetNumeric+=+"0123456789";
++++
++++String+randomString+=+getRandomString(sampleSet,+10,+21);
++++String+randomStringNumeric+=+getRandomString(sampleSetNumeric,+10,+21);
++++
++++randomString+=+randomString+%2B+randomStringNumeric;
++++
++++//Convert+String+to+List<Character>
++++List<Character>+list+=+randomString.chars()
++++++++++++.mapToObj(x+->+(char)x)
++++++++++++.collect(Collectors.toList());
++++
++++Collections.shuffle(list);
++++
++++//This+is+needed+to+force+a+non-numeric+character+as+the+first+String
++++//Skip+this+for()+if+you+don't+need+this+logic

++++for(;;)+{
++++++++if(Character.isDigit(list.get(0)))+Collections.shuffle(list);
++++++++else+break;
++++}
++++
++++//Convert+List<Character>+to+String
++++randomString+=+list.stream()
++++++++++++.map(String::valueOf)
++++++++++++.collect(Collectors.joining());
++++
++++return+randomString;
++++
}

//Generate+a+random+number+between+the+lower+bound+(inclusive)+and+upper+bound+(exclusive)
private+int+getRandomLength(int+min,+int+max)+{
++++SecureRandom+random+=+new+SecureRandom();
++++return+random.ints(1,+min,+max).mapToObj(x+->+x).reduce((a,+b)+->+a).get();
}

//Generate+a+random+String+from+the+given+sample+string,+having+a+random+length+between+the+lower+bound+(inclusive)+and+upper+bound+(exclusive)
private+String+getRandomString(String+sampleSet,+int+min,+int+max)+{
++++SecureRandom+random+=+new+SecureRandom();
++++return+random.ints(getRandomLength(min,+max),+0,+sampleSet.length()+-+1)
++++.mapToObj(x+->+sampleSet.charAt(x))
++++.collect(Collector
++++++++.of(StringBuilder::new,+StringBuilder::append,
++++++++++++StringBuilder::append,+StringBuilder::toString));
}|825085|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I am using a very simple solution using Java 8. Just customize it according to your needs.
<pre><code>...
import java.security.SecureRandom;
...

//Generate a random String of length between 10 to 20.
//Length is also randomly generated here.
SecureRandom random = new SecureRandom();

String sampleSet = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_&quot;;

int stringLength = random.ints(1, 10, 21).mapToObj(x -&gt; x).reduce((a, b) -&gt; a).get();

String randomString = random.ints(stringLength, 0, sampleSet.length() - 1)
 .mapToObj(x -&gt; sampleSet.charAt(x))
 .collect(Collector
 .of(StringBuilder::new, StringBuilder::append,
 StringBuilder::append, StringBuilder::toString));
</code></pre>
<hr />
We can use this to generate an alphanumeric random String like this (the returned String will mandatorily have some non-numeric characters as well as some numeric characters):
<pre><code>public String generateRandomString() {
 
 String sampleSet = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_&quot;;
 String sampleSetNumeric = &quot;0123456789&quot;;
 
 String randomString = getRandomString(sampleSet, 10, 21);
 String randomStringNumeric = getRandomString(sampleSetNumeric, 10, 21);
 
 randomString = randomString + randomStringNumeric;
 
 //Convert String to List&lt;Character&gt;
 List&lt;Character&gt; list = randomString.chars()
 .mapToObj(x -&gt; (char)x)
 .collect(Collectors.toList());
 
 Collections.shuffle(list);
 
 //This is needed to force a non-numeric character as the first String
 //Skip this for() if you don't need this logic

 for(;;) {
 if(Character.isDigit(list.get(0))) Collections.shuffle(list);
 else break;
 }
 
 //Convert List&lt;Character&gt; to String
 randomString = list.stream()
 .map(String::valueOf)
 .collect(Collectors.joining());
 
 return randomString;
 
}

//Generate a random number between the lower bound (inclusive) and upper bound (exclusive)
private int getRandomLength(int min, int max) {
 SecureRandom random = new SecureRandom();
 return random.ints(1, min, max).mapToObj(x -&gt; x).reduce((a, b) -&gt; a).get();
}

//Generate a random String from the given sample string, having a random length between the lower bound (inclusive) and upper bound (exclusive)
private String getRandomString(String sampleSet, int min, int max) {
 SecureRandom random = new SecureRandom();
 return random.ints(getRandomLength(min, max), 0, sampleSet.length() - 1)
 .mapToObj(x -&gt; sampleSet.charAt(x))
 .collect(Collector
 .of(StringBuilder::new, StringBuilder::append,
 StringBuilder::append, StringBuilder::toString));
}
</code></pre>

blocks|key|825091|text|public+class+Utils+{
++++private+final+Random+RANDOM+=+new+SecureRandom();
++++private+final+String+ALPHABET+=+"0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";

++++private+String+generateRandomString(int+length)+{
++++++++StringBuffer+buffer+=+new+StringBuffer(length);
++++++++for+(int+i+=+0;+i+<+length;+i%2B%2B)+{
++++++++++++buffer.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
++++++++}
++++++++return+new+String(buffer);
++++}+
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|825092|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class Utils {
 private final Random RANDOM = new SecureRandom();
 private final String ALPHABET = &quot;0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm&quot;;

 private String generateRandomString(int length) {
 StringBuffer buffer = new StringBuffer(length);
 for (int i = 0; i &lt; length; i++) {
 buffer.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
 }
 return new String(buffer);
 } 
}
</code></pre>

blocks|key|829249|text|给定某些字符(AllCharacters)，您可以随机拾取字符串中的一个字符。然后使用-for循环反复获得随机字符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|829250|public+class+MyProgram+{
++static+String+getRandomString(int+size)+{
++++++String+AllCharacters+=+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
++++++StringBuilder+sb+=+new+StringBuilder(size);
++++++int+length+=+AllCharacters.length();
++++++for+(int+i+=+0;+i+<+size;+i%2B%2B)+{
++++++++++sb.append(AllCharacters.charAt((int)(length+*+Math.random())));
++++++}
++++++return+sb.toString();
++}

++public+static+void+main(String[]+args)+{
++++++System.out.println(MyProgram.getRandomString(30));
++}
}|code-block|syntax|javascript|829251|在沙盒上试一试|unordered-list-item|829252|还可以看到其他语言实现了随机串发生器|829253|entityMap|0|LINK|mutability|MUTABLE|url|https://codehs.com/sandbox/id/java-main-4NaSkG|1|https://fe-tool.com/en-us/random-password^0|7|D|0|0|1|2|0|0|C|6|1|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|M|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|N|3|O|5|M|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|P|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|Q|$R|$5|S|T|U|E|$V|W]]|X|$5|S|T|U|E|$V|Y]]]]

Given the some characters (<code>AllCharacters</code>), you could pickup a character in the string randomly. Then use-for loop to get random charcter repeatedly.
<pre class="lang-java prettyprint-override"><code>public class MyProgram {
 static String getRandomString(int size) {
 String AllCharacters = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789&quot;;
 StringBuilder sb = new StringBuilder(size);
 int length = AllCharacters.length();
 for (int i = 0; i &lt; size; i++) {
 sb.append(AllCharacters.charAt((int)(length * Math.random())));
 }
 return sb.toString();
 }

 public static void main(String[] args) {
 System.out.println(MyProgram.getRandomString(30));
 }
}
</code></pre>
<ul>
<li>Try it on the <a href="https://codehs.com/sandbox/id/java-main-4NaSkG" rel="nofollow noreferrer">sandbox</a></li>
<li>Also see other languages implement <a href="https://fe-tool.com/en-us/random-password" rel="nofollow noreferrer">random string generator</a></li>
</ul>

blocks|key|124869|text|您可以在没有外部库的情况下在一行中完成此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|124870|int+length+=+12;
String+randomString+=+new+Random().ints(48,+122).filter(i+->+(i+<+58+%7C%7C+i+>+64)+&&+(i+<+91+%7C%7C+i+>+96)).limit(length).collect(StringBuilder::new,+StringBuilder::appendCodePoint,+StringBuilder::append).toString();
System.out.print(randomString);|code-block|syntax|javascript|124871|我已经将长度分隔成一个参数，并添加了一行来打印结果。|124872|此代码创建一个随机整数流，该随机整数被限定在字母数字ascii范围内。然后它过滤掉一些符号，因为字母数字范围是不连续的。然后，它限制长度并将结果收集到字符串中。|124873|因为这种方法会丢弃大约20%25的数字/字符(因为它们是符号)，所以对性能的影响很小。|124874|我不认为它特别可读性强，但我不认为其他人曾在一行中提出过本机Java解决方案。|124875|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can do this in one line with no external libraries.
<pre><code>int length = 12;
String randomString = new Random().ints(48, 122).filter(i -&gt; (i &lt; 58 || i &gt; 64) &amp;&amp; (i &lt; 91 || i &gt; 96)).limit(length).collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString();
System.out.print(randomString);
</code></pre>
I have separated out the length into a parameter, and added a line to print the result.
This code creates a stream of random integers bounded to the alphanumeric ascii range. It then filters out some symbols, because the alphanumeric range is not continuous. It then limits the length and collects the result into a string.
Because this approach discards something like 20% of the numbers/characters it generates (as they are symbols), there is a small performance impact.
I don't find it particularly readable, but I don't think anyone else has suggested a native Java solution in one line.

I've been looking for a simple Java algorithm to generate a pseudo-random alpha-numeric string. In my situation it would be used as a unique session/key identifier that would "likely" be unique over <code>500K+</code> generation (my needs don't really require anything much more sophisticated). 

Ideally, I would be able to specify a length depending on my uniqueness needs. For example, a generated string of length 12 might look something like <code>"AEYGF7K0DM1X"</code>.

How to generate a random alpha-numeric string

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我一直在寻找一个简单的Java算法来生成一个伪随机α-数字字符串。在我的情况下，它将被用作唯一的会话/密钥标识符，在500K+生成过程中“很可能”是唯一的(我的需求并不需要更复杂的东西)。理想情况下，我可以根据我的唯一性需求指定长度。例如，生成的长度为12的字符串可能类似于"AEYGF7K0DM1X"。

问如何生成随机的alpha-数字字符串
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何生成随机的alpha-数字字符串EN