blocks|key|691259|text|public+class+SeqGen+{
++++public+static+void+main(String[]+args)+{
++++++++//This+is+the+configurable+param
++++++++int+seqWidth+=+3;

++++++++Double+charSetSize+=+26d;

++++++++//+The+size+of+the+array+will+be+26+%5E+seqWidth.+ie:+if+2+chars+wide,+26
++++++++//+*+26.+3+chars,+26+*+26+*+26
++++++++Double+total+=+Math.pow(charSetSize,+(new+Integer(seqWidth)).doubleValue());

++++++++StringBuilder[]+sbArr+=+new+StringBuilder[total.intValue()];
++++++++//+Initializing+the+Array
++++++++for(int+j+=+0;+j+<total;+j%2B%2B){
++++++++++++sbArr[j]+=+new+StringBuilder();
++++++++}

++++++++char+ch+=+'A';
++++++++//+Iterating+over+the+entire+length+for+the+'char+width'+number+of+times.
++++++++//+TODO:+Can+these+iterations+be+reduced?
++++++++for(int+k+=+seqWidth;+k+>0;+k--){
++++++++++++//+Iterating+and+adding+each+char+to+the+entire+array.++++++++
++++++++++++for(int+l+=+1;+l+<=total;+l%2B%2B){
++++++++++++++++sbArr[l-1].append(ch);
++++++++++++++++if((l+%25+(Math.pow(charSetSize,+k-1d)))+==+0){
++++++++++++++++++++ch%2B%2B;
++++++++++++++++++++if(ch+>+'Z'){
++++++++++++++++++++++++ch+=+'A';
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}

++++++++//Use+the+stringbuilder+array.
++++++++for+(StringBuilder+builder+:+sbArr)+{
++++++++++++System.out.println(builder.toString());
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|691260|请参考example，并根据您的要求进行修改。|unstyled|offset|length|691261|entityMap|0|LINK|mutability|MUTABLE|url|http://codesnippets.joyent.com/posts/show/2407^0|0|3|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<pre><code>public class SeqGen {
 public static void main(String[] args) {
 //This is the configurable param
 int seqWidth = 3;

 Double charSetSize = 26d;

 // The size of the array will be 26 ^ seqWidth. ie: if 2 chars wide, 26
 // * 26. 3 chars, 26 * 26 * 26
 Double total = Math.pow(charSetSize, (new Integer(seqWidth)).doubleValue());

 StringBuilder[] sbArr = new StringBuilder[total.intValue()];
 // Initializing the Array
 for(int j = 0; j &lt;total; j++){
 sbArr[j] = new StringBuilder();
 }

 char ch = 'A';
 // Iterating over the entire length for the 'char width' number of times.
 // TODO: Can these iterations be reduced?
 for(int k = seqWidth; k &gt;0; k--){
 // Iterating and adding each char to the entire array. 
 for(int l = 1; l &lt;=total; l++){
 sbArr[l-1].append(ch);
 if((l % (Math.pow(charSetSize, k-1d))) == 0){
 ch++;
 if(ch &gt; 'Z'){
 ch = 'A';
 }
 }
 }
 }

 //Use the stringbuilder array.
 for (StringBuilder builder : sbArr) {
 System.out.println(builder.toString());
 }
 }
}
</code></pre>

refer to the <a href="http://codesnippets.joyent.com/posts/show/2407" rel="nofollow">example</a> and modify as per your requirements.

blocks|key|691356|text|我建议使用迭代器返回下一个值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691357|迭代器需要能够基于内部计数器创建要返回的字符串。对于您的示例，使用两个计数器就足够了。一个用于字符串中的第一个字符，另一个用于第二个字符。|691358|每个计数器可以对应于"+ABCDEFGHIJKLMNOPQRSTUVWXYZ"中的索引。当你返回一个字符串时，更新最后一个位置的计数器。如果它落在“边缘”，则将其重置为指向"A“，并递增下一个计数器。当计数器变得很大时，要么让迭代器指示没有更多的元素，要么根据您的需要将其重置为指向“”。|offset|length|style|CODE|691359|请注意，通过使第一个位置为空，您可以在字符串上使用trim()，以消除第一个响应为"A“的任何空格。|691360|entityMap^0|0|0|A|T|0|P|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|M|$]]

I would suggest an iterator returning the next value.

The iterator needs to be able to create the string to return, based on internal counters. For your example it would be enough with two counters. One for the first character in the string, and one for the second character.

Each counter could correspond to the index in <code>" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</code>. When you've returned a string update the counter for the last position. If it falls "over the edge" reset it to point to "A" and increment the next counter. When that counter gets to large, either let the iterator indicate there is no more elements, or reset it to point to " " depending on what you need.

Note that by having the first position a blank, you can use <code>trim()</code> on the string to get rid of any spaces giving "A" for the first response.

blocks|key|475242|text|为什么不递归地创建序列呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475243|示例(未测试)：|475244|public+String+createSequenceElement(int+index)+{
String+sequenceElement+=+"";
int+first++=+index+/+26;
int+second+=+index+%25+26;
if+(first+<+1)+{
++++sequenceElement+%2B=++(char)+('A'+%2B+second);
}+else+{
++++sequenceElement+%2B=++createSequenceElement(first)+%2B+(char)+('A'+%2B+second);
}
return+sequenceElement+;
}

public+static+void+main(String[]+args)+{
++++String+sequence+=+"";
++++for+(int+i+=+0;+i+<+100;+i%2B%2B)+{
++++++++if+(i+>+0)+{
++++++++++++sequence+%2B=+",+";
++++++++}
++++++++sequence+%2B=+createSequenceElement(i);

++++}
++++System.out.println(sequence);
}|code-block|syntax|javascript|475245|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Why don't creating the sequence recursively?

Example (untested):

<pre><code>public String createSequenceElement(int index) {
String sequenceElement = "";
int first = index / 26;
int second = index % 26;
if (first &lt; 1) {
 sequenceElement += (char) ('A' + second);
} else {
 sequenceElement += createSequenceElement(first) + (char) ('A' + second);
}
return sequenceElement ;
}

public static void main(String[] args) {
 String sequence = "";
 for (int i = 0; i &lt; 100; i++) {
 if (i &gt; 0) {
 sequence += ", ";
 }
 sequence += createSequenceElement(i);

 }
 System.out.println(sequence);
}
</code></pre>

blocks|key|691457|text|我结合了维基百科的Hexavigesimal#Bijective+base-26和Bijective+numeration#Properties+of+bijective+base-k+numerals来做这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|691458|import+static+java.lang.Math.*;

private+static+String+getString(int+n)+{
++++char[]+buf+=+new+char[(int)+floor(log(25+*+(n+%2B+1))+/+log(26))];
++++for+(int+i+=+buf.length+-+1;+i+>=+0;+i--)+{
++++++++n--;
++++++++buf[i]+=+(char)+('A'+%2B+n+%25+26);
++++++++n+/=+26;
++++}
++++return+new+String(buf);
}|code-block|syntax|javascript|691459|在Wolfram+Alpha的帮助下。不过，如果只使用第一个链接中的实现，可能会更简单。|691460|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/w/index.php?title=Hexavigesimal&oldid=578218059#Bijective_base-26|1|http://en.wikipedia.org/w/index.php?title=Bijective_numeration&oldid=580744715#Properties_of_bijective_base-k_numerals|2|http://www.wolframalpha.com/input/?i=log_26%2528n%252B1%2529%2B%252B%2Blog_26%252825%2529^0|9|V|0|15|1O|1|0|0|1|D|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

I combined Wikipedia's <a href="http://en.wikipedia.org/w/index.php?title=Hexavigesimal&amp;oldid=578218059#Bijective_base-26" rel="noreferrer">Hexavigesimal#Bijective base-26</a> and <a href="http://en.wikipedia.org/w/index.php?title=Bijective_numeration&amp;oldid=580744715#Properties_of_bijective_base-k_numerals" rel="noreferrer">Bijective numeration#Properties of bijective base-k numerals</a> to make this:

<pre><code>import static java.lang.Math.*;

private static String getString(int n) {
 char[] buf = new char[(int) floor(log(25 * (n + 1)) / log(26))];
 for (int i = buf.length - 1; i &gt;= 0; i--) {
 n--;
 buf[i] = (char) ('A' + n % 26);
 n /= 26;
 }
 return new String(buf);
}
</code></pre>

With the help of <a href="http://www.wolframalpha.com/input/?i=log_26%28n%2B1%29+%2B+log_26%2825%29" rel="noreferrer">Wolfram Alpha</a>. Maybe it would have been simpler to just use the implementation in the first link though.

blocks|key|691527|text|此方法生成Alpha字符序列|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691528|如果用null调用，它返回A。当用A调用时，它返回B。|691529|序列是A，B，C+......Z，AA，AB，AC+.....AZ，BA，BB，BC……BZ，CA，CB，CC....CZ，DA......ZA，ZB....ZZ，AAA，AAB，AAC....AAZ，ABA，ABB...AZZ、BAA、BAB....ZZZ|691530|/**
*+@param+charSeqStr
*+@return
*/

public+static+String+getNextAlphaCharSequence(String+charSeqStr)+{

++++String+nextCharSeqStr+++++++=+null;
++++char[]+charSeqArr+++++++++++=+null;
++++boolean+isResetAllChar++++++=+false;
++++boolean+isResetAfterIndex+++=+false;
++++Integer+resetAfterIndex+++++=+0;

++++if+(StringUtils.isBlank(charSeqStr))+{
++++++++charSeqArr+=+new+char[]+{+'A'+};
++++}+else+{
++++++++charSeqArr+=+charSeqStr.toCharArray();
++++++++Integer+charSeqLen+=+charSeqArr.length;

++++++++for+(int+index+=+charSeqLen+-+1;+index+>=+0;+index--)+{
++++++++++++char+charAtIndex+=+charSeqArr[index];

++++++++++++if+(Character.getNumericValue(charAtIndex)+%25+35+==+0)+{
++++++++++++++++if+(index+==+0)+{
++++++++++++++++++++charSeqArr+=+Arrays.copyOf(charSeqArr,+charSeqLen+%2B+1);
++++++++++++++++++++isResetAllChar+=+true;
++++++++++++++++}+else+{
++++++++++++++++++++continue;
++++++++++++++++}
++++++++++++}+else+{
++++++++++++++++char+nextCharAtIndex+=+(char)+(charAtIndex+%2B+1);
++++++++++++++++charSeqArr[index]+=+nextCharAtIndex;
++++++++++++++++if+(index+%2B+1+<+charSeqLen)+{
++++++++++++++++++++isResetAfterIndex+=+true;
++++++++++++++++++++resetAfterIndex+=+index;
++++++++++++++++}
++++++++++++++++break;
++++++++++++}
++++++++}
++++++++charSeqLen+=+charSeqArr.length;
++++++++if+(isResetAllChar)+{
++++++++++++for+(int+index+=+0;+index+<+charSeqLen;+index%2B%2B)+{
++++++++++++++++charSeqArr[index]+=+'A';
++++++++++++}
++++++++}+else+if+(isResetAfterIndex)+{
++++++++++++for+(int+index+=+resetAfterIndex+%2B+1;+index+<+charSeqLen;+index%2B%2B)+{
++++++++++++++++charSeqArr[index]+=+'A';
++++++++++++}
++++++++}
++++}

++++nextCharSeqStr+=+String.valueOf(charSeqArr);
++++return+nextCharSeqStr;
}

public+static+void+main(String+args[])+{
++++String+nextAlphaSequence+=+null;
++++for+(int+index+=+0;+index+<+1000;+index%2B%2B)+{
++++++++nextAlphaSequence+=+getNextAlphaCharSequence(nextAlphaSequence);
++++++++System.out.print(nextAlphaSequence+%2B+",");
++++}
}|code-block|syntax|javascript|691531|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This method generates Alpha Character Sequence

If called with null it return A. When called with A it returns B.

The sequence goes like A, B, C ...... Z, AA, AB, AC ..... AZ, BA, BB, BC.... BZ, CA, CB, CC....CZ, DA......ZA, ZB....ZZ, AAA, AAB, AAC....AAZ, ABA, ABB... AZZ, BAA, BAB....ZZZ

<pre><code>/**
* @param charSeqStr
* @return
*/

public static String getNextAlphaCharSequence(String charSeqStr) {

 String nextCharSeqStr = null;
 char[] charSeqArr = null;
 boolean isResetAllChar = false;
 boolean isResetAfterIndex = false;
 Integer resetAfterIndex = 0;

 if (StringUtils.isBlank(charSeqStr)) {
 charSeqArr = new char[] { 'A' };
 } else {
 charSeqArr = charSeqStr.toCharArray();
 Integer charSeqLen = charSeqArr.length;

 for (int index = charSeqLen - 1; index &gt;= 0; index--) {
 char charAtIndex = charSeqArr[index];

 if (Character.getNumericValue(charAtIndex) % 35 == 0) {
 if (index == 0) {
 charSeqArr = Arrays.copyOf(charSeqArr, charSeqLen + 1);
 isResetAllChar = true;
 } else {
 continue;
 }
 } else {
 char nextCharAtIndex = (char) (charAtIndex + 1);
 charSeqArr[index] = nextCharAtIndex;
 if (index + 1 &lt; charSeqLen) {
 isResetAfterIndex = true;
 resetAfterIndex = index;
 }
 break;
 }
 }
 charSeqLen = charSeqArr.length;
 if (isResetAllChar) {
 for (int index = 0; index &lt; charSeqLen; index++) {
 charSeqArr[index] = 'A';
 }
 } else if (isResetAfterIndex) {
 for (int index = resetAfterIndex + 1; index &lt; charSeqLen; index++) {
 charSeqArr[index] = 'A';
 }
 }
 }

 nextCharSeqStr = String.valueOf(charSeqArr);
 return nextCharSeqStr;
}

public static void main(String args[]) {
 String nextAlphaSequence = null;
 for (int index = 0; index &lt; 1000; index++) {
 nextAlphaSequence = getNextAlphaCharSequence(nextAlphaSequence);
 System.out.print(nextAlphaSequence + ",");
 }
}
</code></pre>

blocks|key|691563|text|这将为传递的值创建序列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691564|/**
+*+Method+that+returns+batch+names+based+on+passed+value
+*+@param+batchCount
+*+@return+String[]
+*/
public+static+String[]+getBatchNamesForExecutor(int+batchCount)+{
++++//+Batch+names+array
++++String[]+batchNames+=+new+String[batchCount];

++++//+Loop+from+0+to+batchCount+required
++++for(int+index=0;+index+<+batchCount;+index%2B%2B)+{
++++++++//+Alphabet+for+current+batch+name+
++++++++int+alphabet+=+index%2526;

++++++++//+iteration+count+happened+on+all+alphabets+till+now
++++++++int+iterations+=+index/26;

++++++++//+initializing+array+element+to+blank+string
++++++++batchNames[index]+=+"";

++++++++//+Looping+over+the+iterationIndex+and+creating+batch+alphabet+prefix+/+prefixes
++++++++for(int+iterationIndex+=+0;+iterationIndex+<+iterations;+iterationIndex%2B=26){
++++++++++++batchNames[index]+%2B=+String.valueOf((char)('A'+%2B+(iterations-1)+%25+26+));
++++++++}

++++++++//+Adding+last+alphabet+in+batch+name
++++++++batchNames[index]+%2B=+String.valueOf((char)('A'+%2B+alphabet+%25+26+));
++++}

++++return+batchNames;
}

public+static+void+main(String[]+args)+{
++++for(String+s:+getBatchNamesForExecutor(8))++{
++++++++System.err.println(s);
++++}
++++System.exit(0);+
}|code-block|syntax|javascript|691565|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|$]]

This will create the sequence for passed value.

<pre><code>/**
 * Method that returns batch names based on passed value
 * @param batchCount
 * @return String[]
 */
public static String[] getBatchNamesForExecutor(int batchCount) {
 // Batch names array
 String[] batchNames = new String[batchCount];

 // Loop from 0 to batchCount required
 for(int index=0; index &lt; batchCount; index++) {
 // Alphabet for current batch name 
 int alphabet = index%26;

 // iteration count happened on all alphabets till now
 int iterations = index/26;

 // initializing array element to blank string
 batchNames[index] = "";

 // Looping over the iterationIndex and creating batch alphabet prefix / prefixes
 for(int iterationIndex = 0; iterationIndex &lt; iterations; iterationIndex+=26){
 batchNames[index] += String.valueOf((char)('A' + (iterations-1) % 26 ));
 }

 // Adding last alphabet in batch name
 batchNames[index] += String.valueOf((char)('A' + alphabet % 26 ));
 }

 return batchNames;
}

public static void main(String[] args) {
 for(String s: getBatchNamesForExecutor(8)) {
 System.err.println(s);
 }
 System.exit(0); 
}
</code></pre>

blocks|key|691598|text|有趣的是，还没有人提供基于Java+8的函数式解决方案。这是一个使用jOOλ的解决方案，它为characters、foldLeft()和crossJoin()提供了range()等功能(免责声明，我在维护jOOλ的公司工作)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|691599|int+max+=+3;

List<String>+alphabet+=+Seq
++++.rangeClosed('A',+'Z')
++++.map(Object::toString)
++++.toList();

Seq.rangeClosed(1,+max)
+++.flatMap(length+->
+++++++Seq.rangeClosed(1,+length+-+1)
++++++++++.foldLeft(Seq.seq(alphabet),+(s,+i)+->+s.crossJoin(Seq.seq(alphabet))
++++++++++++++++++++++++++++++++++++++++++++++++++.map(t+->+t.v1+%2B+t.v2)))
+++.forEach(System.out::println);|code-block|syntax|javascript|691600|这个解决方案并不是很快(e.g.+as+this+one)。为了完整起见，我只是添加了它。|691601|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/jOOQ/jOOL|1|https://stackoverflow.com/a/20954353/521799^0|1L|A|1W|B|2A|7|Y|4|0|0|0|C|G|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|M|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

Interestingly, no one has provided a Java 8-based functional solution yet. Here's a solution using <a href="https://github.com/jOOQ/jOOL" rel="nofollow noreferrer">jOOλ</a>, which provides functionality like <code>range()</code> for characters, <code>foldLeft()</code> and <code>crossJoin()</code> (disclaimer, I work for the company that maintains jOOλ):

<pre class="lang-java prettyprint-override"><code>int max = 3;

List&lt;String&gt; alphabet = Seq
 .rangeClosed('A', 'Z')
 .map(Object::toString)
 .toList();

Seq.rangeClosed(1, max)
 .flatMap(length -&gt;
 Seq.rangeClosed(1, length - 1)
 .foldLeft(Seq.seq(alphabet), (s, i) -&gt; s.crossJoin(Seq.seq(alphabet))
 .map(t -&gt; t.v1 + t.v2)))
 .forEach(System.out::println);
</code></pre>

This solution isn't really fast (<a href="https://stackoverflow.com/a/20954353/521799">e.g. as this one</a>). I've just added it for completeness' sake.

blocks|key|691633|text|仅仅因为我喜欢短代码…灵感来自Thomas+Jung’s+answer|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|691634|static+String+asLetters(long+value)+{
++++int+codePoint+=+(int)+('A'+%2B+--value+%25+26);
++++long+higher+=+value+/+26;
++++String+letter+=+new+String(Character.toChars(codePoint));
++++return+higher+==+0+?+letter+:+asLetters(higher).concat(letter);
}|code-block|syntax|javascript|691635|从1→CRPXNLSKVLJFHG开始，直到Long.MAX_VALUE→→。对于小写字母，使用'a'而不是'A'。|style|CODE|691636|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/8714470/1503237^0|F|K|0|0|0|3|E|M|E|1C|3|1I|3|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|@$A|10|B|11|K|L]|$A|12|B|13|K|L]|$A|14|B|15|K|L]|$A|16|B|17|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Just because I like short code … inspired by <a href="https://stackoverflow.com/a/8714470/1503237">Thomas Jung’s answer</a>:

<pre><code>static String asLetters(long value) {
 int codePoint = (int) ('A' + --value % 26);
 long higher = value / 26;
 String letter = new String(Character.toChars(codePoint));
 return higher == 0 ? letter : asLetters(higher).concat(letter);
}
</code></pre>

Starts with 1 → <code>a</code> until <code>Long.MAX_VALUE</code> → <code>CRPXNLSKVLJFHG</code>. Use <code>'a'</code> instead of <code>'A'</code> for lowercase letters.

blocks|key|691678|text|从整数生成字符串的单行递归函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691679|static+String+str(int+i)+{
++++return+i+<+0+?+""+:+str((i+/+26)+-+1)+%2B+(char)(65+%2B+i+%25+26);
}|code-block|syntax|javascript|691680|示例用法：|691681|public+static+void+main(String[]+args)+{
++++for+(int+i+=+0;+i+<+27*27;+%2B%2Bi)+{
++++++++System.out.println(i+%2B+"+->+"+%2B+str(i));
++++}
}|691682|输出：|691683|0+->+A
1+->+B
2+->+C
[...]
24+->+Y
25+->+Z
26+->+AA
27+->+AB
[...]
700+->+ZY
701+->+ZZ
702+->+AAA
703+->+AAB
[...]
727+->+AAZ
728+->+ABA|691684|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|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|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|$]]

A one-line recursive function to generate the string from an integer:

<pre><code>static String str(int i) {
 return i &lt; 0 ? "" : str((i / 26) - 1) + (char)(65 + i % 26);
}
</code></pre>

Example usage:

<pre><code>public static void main(String[] args) {
 for (int i = 0; i &lt; 27*27; ++i) {
 System.out.println(i + " -&gt; " + str(i));
 }
}
</code></pre>

Output:

<pre><code>0 -&gt; A
1 -&gt; B
2 -&gt; C
[...]
24 -&gt; Y
25 -&gt; Z
26 -&gt; AA
27 -&gt; AB
[...]
700 -&gt; ZY
701 -&gt; ZZ
702 -&gt; AAA
703 -&gt; AAB
[...]
727 -&gt; AAZ
728 -&gt; ABA
</code></pre>

blocks|key|475560|text|取‘A’到‘Z’为26基数。示例(C%2B%2B)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475561|++++vector<string>+generateSequenceBySize(int+N)
++++{
++++++++if(N<1)
++++++++++++return+vector<string>();
++++++++int+base+=+26;
++++++++vector<string>+seqs;
++++++++for(int+i=0;i<pow(base,N);i%2B%2B)
++++++++{
++++++++++++int+value+=+i;
++++++++++++string+tmp(N,'A');
++++++++++++for+(int+j=0;j<N;j%2B%2B)
++++++++++++{
++++++++++++++++tmp[N-1-j]+=+'A'%2Bvalue%25base;
++++++++++++++++value+=+value/base;
++++++++++++}
++++++++++++seqs.push_back(tmp);
++++++++}
++++++++return+seqs;
++++}
++++vector<string>+generateSequence()
++++{
++++++++//http://stackoverflow.com/questions/8710719/generating-an-alphabetic-sequence-in-java
++++++++//A,+B,+C,+...,+Z,+AA,+AB,+AC,+...,+ZZ.
++++++++vector<string>+seqs;
++++++++for+(int+i=1;i<=2;i%2B%2B)
++++++++{
++++++++++++vector<string>+subSeq+=+generateSequenceBySize(i);
++++++++++++seqs.insert(seqs.end(),subSeq.begin(),subSeq.end());
++++++++}
++++++++return+seqs;
++++}|code-block|syntax|javascript|475562|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|$]]

take 'A'to'Z' as 26radix.
Example(C++)

<pre><code> vector&lt;string&gt; generateSequenceBySize(int N)
 {
 if(N&lt;1)
 return vector&lt;string&gt;();
 int base = 26;
 vector&lt;string&gt; seqs;
 for(int i=0;i&lt;pow(base,N);i++)
 {
 int value = i;
 string tmp(N,'A');
 for (int j=0;j&lt;N;j++)
 {
 tmp[N-1-j] = 'A'+value%base;
 value = value/base;
 }
 seqs.push_back(tmp);
 }
 return seqs;
 }
 vector&lt;string&gt; generateSequence()
 {
 //http://stackoverflow.com/questions/8710719/generating-an-alphabetic-sequence-in-java
 //A, B, C, ..., Z, AA, AB, AC, ..., ZZ.
 vector&lt;string&gt; seqs;
 for (int i=1;i&lt;=2;i++)
 {
 vector&lt;string&gt; subSeq = generateSequenceBySize(i);
 seqs.insert(seqs.end(),subSeq.begin(),subSeq.end());
 }
 return seqs;
 }
</code></pre>

blocks|key|475566|text|++++char+ch;
++++String+str1+=+"";
++++String+str2+=+"";

++++for+(ch+=+'A';+ch+<=+'Z';+ch%2B%2B)+{
++++++++str1+%2B=+ch;
++++++++for+(int+i+=+0;+i+<+26;+i%2B%2B)+{
++++++++++++char+upper+=+(char)+('A'+%2B+i);
++++++++++++str2+=+str2+%2B+ch+%2B+upper+%2B+"+";

++++++++}
++++}

++++System.out.println(str1+%2B+",+"+%2B+str2);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|475567|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> char ch;
 String str1 = "";
 String str2 = "";

 for (ch = 'A'; ch &lt;= 'Z'; ch++) {
 str1 += ch;
 for (int i = 0; i &lt; 26; i++) {
 char upper = (char) ('A' + i);
 str2 = str2 + ch + upper + " ";

 }
 }

 System.out.println(str1 + ", " + str2);
</code></pre>

blocks|key|475634|text|所有这些长长的答案..。还有那些使用递归的..。哇。在Java中，这可以在几行代码中完成，不需要递归：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475635|private+static+String+intToValueKey(int+value)+{
++++final+StringBuilder+sb+=+new+StringBuilder(String.valueOf((char)('A'%2B(value+%25+26))));
++++while((value+=+(value/26-1))+>=+0)+{
++++++++sb.append((char)('A'%2B(value+%25+26)));
++++}
++++return+sb.reverse().toString();
}|code-block|syntax|javascript|475636|然后，您只需在循环中调用数值递增的方法，以生成从0到n的序列。|475637|for(int+i=0;+i<800;+i%2B%2B)+{
++++System.out.println(intToValueKey(i));
}|475638|如果您关心字母的顺序，则末尾的反向()是唯一的，如果您只是在寻找唯一的排列，则并不真正需要该函数。|475639|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

All these long answers... and the ones that use recursion... wow. This can be done in Java in a few lines with no recursion:

<pre><code>private static String intToValueKey(int value) {
 final StringBuilder sb = new StringBuilder(String.valueOf((char)('A'+(value % 26))));
 while((value = (value/26-1)) &gt;= 0) {
 sb.append((char)('A'+(value % 26)));
 }
 return sb.reverse().toString();
}
</code></pre>

Then you just call the method with increasing numeric value in a loop to generate the sequence from 0 to n.

<pre><code>for(int i=0; i&lt;800; i++) {
 System.out.println(intToValueKey(i));
}
</code></pre>

The reverse() at the end is just if you care about the order of letters and is not really needed if you're just looking for a unique permutation.

I'm looking for a way of generating an alphabetic sequence:

<pre><code>A, B, C, ..., Z, AA, AB, AC, ..., ZZ.
</code></pre>

Can anyone suggest a convenient way of doing this. What data structures can I make use of?

I'd like methods which get the next code in the sequence and then reset the sequence.

Generating an alphabetic sequence in Java

数据结构

Java

我正在寻找一种生成字母序列的方法：A, B, C, ..., Z, AA, AB, AC, ..., ZZ.有没有人能建议一个方便的方法来做这件事。我可以使用哪些数据结构？我想要获得序列中的下一个代码，然后重置序列的方法。

问在Java中生成字母序列
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中生成字母序列EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中生成字母序列
EN