如何在所有可能的情况下增加java字符串？

我需要在java中通过字母表将字符串从“aaaaaa”增加到“aaaaaa b”到“aaaaaa c”，然后最终增加到“aaaaaa ba”到“aaaaaa bb”等等

---

有什么诀窍吗？

我会创建一个字符数组，并逐个递增字符。字符串在Java中是不可变的，因此每次更改都会在堆上创建一个新的位置，从而导致内存不断增长

---

对于字符数组，您不应该有这个问题…

有一个包含ascii值的字节数组，有一个循环，在执行结转时增加最右边的数字

然后使用

public String(byte[] bytes, String charsetName)

---

确保将字符集作为US-ASCII或UTF-8传递，以明确无误。

您基本上实现的是带前导“零”（“a”）的a

使用的方法与将int转换为base-2或base-10字符串的方法相同，但不是使用2或10，而是使用26，而不是使用“0”作为基数，而是使用“a”

在Java中，您可以轻松地使用：

public static String base26(int num) {
  if (num < 0) {
    throw new IllegalArgumentException("Only positive numbers are supported");
  }
  StringBuilder s = new StringBuilder("aaaaaaa");
  for (int pos = 6; pos >= 0 && num > 0 ; pos--) {
    char digit = (char) ('a' + num % 26);
    s.setCharAt(pos, digit);
    num = num / 26;
  }
  return s.toString();
}

公共静态字符串base26（int num）{
if（num<0）{
抛出新的IllegalArgumentException（“仅支持正数”）；
}
StringBuilder s=新StringBuilder（“AAAAA”）；
对于（int pos=6；pos>=0&&num>0；pos--）{
字符位数=（字符）（'a'+num%26）；
s、 设置字符（位置，数字）；
num=num/26；
}
返回s.toString（）；
}

---

基本思想是不存储字符串，只存储一些计数器（int、int或long，取决于您的需求），并根据需要将其转换为字符串。通过这种方式，您可以轻松地增加/减少/修改计数器，而无需解析和重新创建字符串。

增加最后一个字符，如果它达到Z，则将其重置为A并移动到前一个字符。重复此操作，直到找到一个不是Z的字符。因为字符串是不可变的，所以我建议使用字符数组，以避免分配大量的新对象

public static void incrementString(char[] str)
{
    for(int pos = str.length - 1; pos >= 0; pos--)
    {
        if(Character.toUpperCase(str[pos]) != 'Z')
        {
            str[pos]++;
            break;
        }
        else
            str[pos] = 'a';
    }
}

这算不上什么“把戏”，但它适用于4字符字符串。显然，对于更长的字符串，它会变得更难看，但想法是一样的

char array[] = new char[4];
for (char c0 = 'a'; c0 <= 'z'; c0++) {
  array[0] = c0;
  for (char c1 = 'a'; c1 <= 'z'; c1++) {
    array[1] = c1;
    for (char c2 = 'a'; c2 <= 'z'; c2++) {
      array[2] = c2;
      for (char c3 = 'a'; c3 <= 'z'; c3++) {
        array[3] = c3;
        String s = new String(array);
        System.out.println(s);
      }
    }
  }
}

char数组[]=新字符[4]；
对于（char c0=‘a’；c0仅在示例上扩展，至于实现，考虑将它放入类中。每次调用类的ToStin时，它将返回下一个值：

public class Permutator {

    private int permutation;

    private int permutations; 

    private StringBuilder stringbuilder;

    public Permutator(final int LETTERS) {

        if (LETTERS < 1) {
            throw new IllegalArgumentException("Usage: Permutator( \"1 or Greater Required\" \)");
        }

        this.permutation = 0;

        // MAGIC NUMBER : 26 = Number of Letters in the English Alphabet 
        this.permutations = (int) Math.pow(26, LETTERS);

        this.stringbuilder = new StringBuilder();

        for (int i = 0; i < LETTERS; ++i) {
            this.stringbuilder.append('a');
        }
    }

    public String getCount() {

        return String.format("Permutation: %s of %s Permutations.", this.permutation, this.permutations);
    }

    public int getPermutation() {

        return this.permutation;
    }

    public int getPermutations() {

        return this.permutations;
    }

    private void permutate() {

        // TODO: Implement Utilising one of the Examples Posted.
    } 

    public String toString() {

        this.permutate();

        return this.stringbuilder.toString();
    }
}    

公共类置换器{
私有整数置换；
私有整数置换；
私人StringBuilder StringBuilder；
公共置换器（最终整数字母）{
如果（字母<1）{
抛出新的IllegalArgumentException（“用法：Permutator（\“1或更高要求\“\”）”）；
}
这个。排列=0；
//幻数：26=英语字母表中的字母数
this.permutations=（int）Math.pow（26个字母）；
this.stringbuilder=新的stringbuilder（）；
对于（int i=0；i
您可以使用大整数的toString（基数）方法，如：

import java.math.BigInteger;
public class Strings {
    Strings(final int digits,final int radix) {
        this(digits,radix,BigInteger.ZERO);
    }
    Strings(final int digits,final int radix,final BigInteger number) {
        this.digits=digits;
        this.radix=radix;
        this.number=number;
    }
    void addOne() {
        number=number.add(BigInteger.ONE);
    }
    public String toString() {
        String s=number.toString(radix);
        while(s.length()<digits)
            s='0'+s;
        return s;
    }
    public char convert(final char c) {
        if('0'<=c&&c<='9')
            return (char)('a'+(c-'0'));
        else if('a'<=c&&c<='p')
            return (char)(c+10);
        else throw new RuntimeException("more logic required for radix: "+radix);
    }
    public char convertInverse(final char c) {
        if('a'<=c&&c<='j')
            return (char)('0'+(c-'a'));
        else if('k'<=c&&c<='z')
            return (char)(c-10);
        else throw new RuntimeException("more logic required for radix: "+radix);
    }
    void testFix() {
        for(int i=0;i<radix;i++)
            if(convert(convertInverse((char)('a'+i)))!='a'+i)
                throw new RuntimeException("testFix fails for "+i);
    }
    public String toMyString() {
        String s=toString(),t="";
        for(int i=0;i<s.length();i++)
            t+=convert(s.charAt(i));
        return t;
    }
    public static void main(String[] arguments) {
        Strings strings=new Strings(8,26);
        strings.testFix();
        System.out.println(strings.number.toString()+' '+strings+' '+strings.toMyString());
        for(int i=0;i<Math.pow(strings.radix,3);i++)
            try {
                strings.addOne();
                if(Math.abs(i-i/strings.radix*strings.radix)<2)
                    System.out.println(strings.number.toString()+' '+strings+' '+strings.toMyString());
            } catch(Exception e) {
                System.out.println(""+i+' '+strings+" failed!");
            }
    }
    final int digits,radix;
    BigInteger number;
}

import java.math.biginger；
公共类字符串{
字符串（最终整数位数，最终整数基数）{
这（数字、基数、BigInteger.ZERO）；
}
字符串（最终整数位数、最终整数基数、最终大整数）{
这个。数字=数字；
这个。基数=基数；
这个。数字=数字；
}
void addOne（）{
number=number.add（biginger.ONE）；
}
公共字符串toString（）{
字符串s=数字。toString（基数）；
虽然（s.length（）如果您只想要最终结果，我必须同意@saua的方法，但是在您想要每个结果的情况下，这里有一个小小的变化

请注意，由于可能有26^8（或208827064576）个不同的字符串，我怀疑您是否想要全部字符串。也就是说，我的代码将打印它们，而不是仅在字符串生成器中存储一个字符串。（但这并不重要。）

publicstaticvoidbase26（int-maxLength）{
buildWord（maxLength，“”）；
}
公共静态void构建字（剩余整数，字符串字）
{
如果（剩余==0）
{
System.out.println（word）；
}
其他的
{
对于（char letter='A'；letter，下面的代码使用递归方法来获取下一个字符串（比如，从“aaaa”到“aaab”等等），而不需要生成之前的所有组合，因此它相当快，并且不限于给定的最大字符串长度

public class StringInc {
 public static void main(String[] args) {
   System.out.println(next("aaa")); // Prints aab

   System.out.println(next("abcdzz")); // Prints abceaa

   System.out.println(next("zzz")); // Prints aaaa
 }

 public static String next(String s) {
   int length = s.length();
   char c = s.charAt(length - 1);

   if(c == 'z')
     return length > 1 ? next(s.substring(0, length - 1)) + 'a' : "aa";

   return s.substring(0, length - 1) + ++c;
 }
}

正如一些人指出的，这是尾部递归，因此您可以将其重新格式化，用循环替换递归。
基于@cyberz的解决方案，下面的代码是一个示例，说明如何编写递归调用，该调用可以通过支持的编译器进行优化

代码是用Groovy编写的，因为它在JVM上运行，它的语法与Java非常相似，它的编译器支持尾部递归优化

static String next(String input) {
    return doNext(input, "")
}

@TailRecursive
@CompileStatic
static String doNext(String input, String result) {
    if(!self) {
        return result
    }

    final String last = input[-1]
    final String nonLast = self.substring(0, input.size()-1)
    if('z' == last) {
        return doNext(nonLast, (nonLast ? 'a' : 'aa') + result)
    }

    return doNext('', nonLast + (((last as Character) + 1) as Character).toString() + result)
}

因为没有一个答案对我有用，所以我编写了自己的代码：

/**
 * Increases the given String value by one. Examples (with min 'a' and max 'z'): <p>
 * 
 * - "aaa" -> "aab" <br>
 * - "aab" -> "aac" <br>
 * - "aaz" -> "aba" <br>
 * - "zzz" -> "aaaa" <br>
 * 
 * @param s
 * @param min lowest char (a zero)
 * @param max highest char (e.g. a 9, in a decimal system)
 * @return increased String by 1
 */
public static String incString(String s, char min, char max) {
    char last = s.charAt(s.length() - 1);
    if (++last > max)
        return s.length() > 1 ? incString(s.substring(0, s.length()-1), min, max) + min : "" + min + min;
    else
        return s.substring(0, s.length()-1) + last;
}

/**
*将给定的字符串值增加1。示例（使用最小值“a”和最大值“z”）：
* 
*-“aaa”->“AAAB”

*-“aab”->“aac”

*-“aaz”->“aba”

*-“zzz”->“aaaa”

* 
*@param s
*@param min最低字符数（零）
*@param max最高字符数（如十进制中的9）
*@return将字符串增加1
*/
公共静态字符串incString（字符串s、最小字符数、最大字符数）{
char last=s.charAt（s.length（）-1）；
如果（++last>max）
返回s.length（）>1英寸字符串(
/**
 * Increases the given String value by one. Examples (with min 'a' and max 'z'): <p>
 * 
 * - "aaa" -> "aab" <br>
 * - "aab" -> "aac" <br>
 * - "aaz" -> "aba" <br>
 * - "zzz" -> "aaaa" <br>
 * 
 * @param s
 * @param min lowest char (a zero)
 * @param max highest char (e.g. a 9, in a decimal system)
 * @return increased String by 1
 */
public static String incString(String s, char min, char max) {
    char last = s.charAt(s.length() - 1);
    if (++last > max)
        return s.length() > 1 ? incString(s.substring(0, s.length()-1), min, max) + min : "" + min + min;
    else
        return s.substring(0, s.length()-1) + last;
}

public static String incrementString(String string)
{
    if(string.length()==1)
    {
        if(string.equals("z"))
            return "aa";
        else if(string.equals("Z"))
            return "Aa";
        else
            return (char)(string.charAt(0)+1)+"";
    }   
    if(string.charAt(string.length()-1)!='z')
    {
        return string.substring(0, string.length()-1)+(char)(string.charAt(string.length()-1)+1);
    }
    return incrementString(string.substring(0, string.length()-1))+"a";
}

import org.apache.commons.lang3.ArrayUtils;
public class StringInc {
 public static void main(String[] args) {
   System.out.println(next("aaa")); // Prints aab

   System.out.println(next("abcdzz")); // Prints abceaa

   System.out.println(next("zzz")); // Prints aaaa
 }

 public static String next(String str) {
    boolean increment = true;
    char[] arr = str.toCharArray();
    for (int i = arr.length - 1; i >= 0 && increment; i--) {
      char letter = arr[i];
      if (letter != 'z') {
        letter++;
        increment = false;
      } else {
        letter = 'a';
      }
      arr[i] = letter;
    }
    if (increment) {
      arr = ArrayUtils.insert(0, arr, 'a');
    }
    return new String(arr);
}