Java 是否生成具有指定字符的随机字符串？

嗯，我一直在研究如何用指定的字符生成包含所有可能值的字符串。 好吧，我不知道怎么解释，所以这里有一个例子：

字符：

a、b、c

生成：

abc
aab
abb
acc
baa
bbb
bbc
bac
cab
ccc
aaa
cbb
caa
ccb
cca
bab
bcb

---

我尝试使用一个字符列表，然后迭代列表中的每个字符，然后再次迭代列表中的每个字符，但是。。。假设它不起作用。

我自己的答案的副本：

这适用于

a、b、c

或任何其他连续字符序列：

import java.util.Arrays;
import java.util.Iterator;

public class BruteForceIterator implements Iterator<String> {

    private char min, max;

    private char[] current;

    private char[] last;

    private int reachedLast = 0;

    public BruteForceIterator(char min, char max, int length) {
        this.min = min;
        this.max = max;
        current = new char[length];
        Arrays.fill(current, min);
        last = new char[length];
        Arrays.fill(last, max);
    }

    @Override
    public boolean hasNext() {
        return reachedLast < 2;
    }

    @Override
    public String next() {
        String str = new String(current);
        for(int i = current.length - 1; i >= 0; i--) {
            char next = following(current[i]);
            current[i] = next;
            if (next != min) {
                break;
            }
        }
        if (Arrays.equals(current, last) || reachedLast > 0) {
            reachedLast++;
        }
        return str;
    }

    private char following(char in) {
        if (in < max) {
            return (char) (in + 1);
        } else {
            return min;
        }
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("No with me, sir!");
    }

    public static void main(String[] args) {
        BruteForceIterator bit = new BruteForceIterator('a', 'c', 3);
        while (bit.hasNext()) {
            System.out.println(bit.next());
        }
    }
} 

导入java.util.array；
导入java.util.Iterator；
公共类BruteForceIterator实现迭代器{
私有字符最小值，最大值；
私有字符[]当前；
私有字符[]最后；
private int reachedast=0；
公共BruteForceIterator（字符最小值、字符最大值、整数长度）{
this.min=min；
this.max=max；
当前=新字符[长度]；
数组。填充（当前，最小值）；
last=新字符[长度]；
数组。填充（最后一个，最大值）；
}
@凌驾
公共布尔hasNext（）{
返回到达时间<2；
}
@凌驾
公共字符串next（）{
String str=新字符串（当前）；
对于（int i=current.length-1；i>=0；i--）{
char next=以下（当前[i]）；
当前[i]=下一个；
如果（下一步！=分钟）{
打破
}
}
if（Arrays.equals（current，last）| | reachedLast>0）{
reachedast++；
}
返回str；
}
私有字符跟踪（字符输入）{
如果（单位<最大值）{
返回（字符）（in+1）；
}否则{
返回最小值；
}
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“不，先生！”）；
}
公共静态void main（字符串[]args）{
BruteForceIterator位=新的BruteForceIterator（'a'，'c'，3）；
while（位hasNext（））{
System.out.println（bit.next（））；
}
}
} 

我自己的答案的副本：

这适用于

a、b、c

或任何其他连续字符序列：

import java.util.Arrays;
import java.util.Iterator;

public class BruteForceIterator implements Iterator<String> {

    private char min, max;

    private char[] current;

    private char[] last;

    private int reachedLast = 0;

    public BruteForceIterator(char min, char max, int length) {
        this.min = min;
        this.max = max;
        current = new char[length];
        Arrays.fill(current, min);
        last = new char[length];
        Arrays.fill(last, max);
    }

    @Override
    public boolean hasNext() {
        return reachedLast < 2;
    }

    @Override
    public String next() {
        String str = new String(current);
        for(int i = current.length - 1; i >= 0; i--) {
            char next = following(current[i]);
            current[i] = next;
            if (next != min) {
                break;
            }
        }
        if (Arrays.equals(current, last) || reachedLast > 0) {
            reachedLast++;
        }
        return str;
    }

    private char following(char in) {
        if (in < max) {
            return (char) (in + 1);
        } else {
            return min;
        }
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("No with me, sir!");
    }

    public static void main(String[] args) {
        BruteForceIterator bit = new BruteForceIterator('a', 'c', 3);
        while (bit.hasNext()) {
            System.out.println(bit.next());
        }
    }
} 

导入java.util.array；
导入java.util.Iterator；
公共类BruteForceIterator实现迭代器{
私有字符最小值，最大值；
私有字符[]当前；
私有字符[]最后；
private int reachedast=0；
公共BruteForceIterator（字符最小值、字符最大值、整数长度）{
this.min=min；
this.max=max；
当前=新字符[长度]；
数组。填充（当前，最小值）；
last=新字符[长度]；
数组。填充（最后一个，最大值）；
}
@凌驾
公共布尔hasNext（）{
返回到达时间<2；
}
@凌驾
公共字符串next（）{
String str=新字符串（当前）；
对于（int i=current.length-1；i>=0；i--）{
char next=以下（当前[i]）；
当前[i]=下一个；
如果（下一步！=分钟）{
打破
}
}
if（Arrays.equals（current，last）| | reachedLast>0）{
reachedast++；
}
返回str；
}
私有字符跟踪（字符输入）{
如果（单位<最大值）{
返回（字符）（in+1）；
}否则{
返回最小值；
}
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“不，先生！”）；
}
公共静态void main（字符串[]args）{
BruteForceIterator位=新的BruteForceIterator（'a'，'c'，3）；
while（位hasNext（））{
System.out.println（bit.next（））；
}
}
} 

我很快在下面写下了这段代码。您可能需要对其进行一些编辑，以使其工作或适应您的需要我只是想与您分享我的代码的想法。不过，我还是推荐jlordo的答案，因为它更有效

Array String[] = new Array[]{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"}
ArrayList<String> numbersrandom;
for(int a = 0; i <= 26; i++){
for(int b = 0; i <= 26; i++){
for(int c = 0; i <= 26; i++){
numbersrandom.add(String[a]+String[b]+String[c]);
}
}
}

数组字符串[]=新数组[]{“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”、“i”、“j”、“k”、“l”、“m”、“n”、“o”、“p”、“q”、“r”、“s”、“t”、“u”、“v”、“w”、“x”、“y”、“z”}
数组列表数随机；
对于（int a=0；i我在下面快速编写了此代码。您可能需要对其进行一些编辑，以使其工作或适应您的需要。我只是想与您分享我的代码的想法。不过，我建议您使用jlordo的答案，因为它更有效

Array String[] = new Array[]{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"}
ArrayList<String> numbersrandom;
for(int a = 0; i <= 26; i++){
for(int b = 0; i <= 26; i++){
for(int c = 0; i <= 26; i++){
numbersrandom.add(String[a]+String[b]+String[c]);
}
}
}

数组字符串[]=新数组[]{“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”、“i”、“j”、“k”、“l”、“m”、“n”、“o”、“p”、“q”、“r”、“s”、“t”、“u”、“v”、“w”、“x”、“y”、“z”}
数组列表数随机；
对于（int a=0；我在此处查看接受答案中的代码：您想要一个随机字符串，还是所有可能的字符串？@Arian所有可能的字符串。@jlordo成功了，谢谢。如果您想要，请发布一个答案，以便我可以投票给您。在此处查看接受答案中的代码：您想要一个随机字符串，还是所有可能的字符串？@Arian所有可能的字符串字符串。@jlordo成功了，谢谢。如果你愿意，发布一个答案，这样我就可以投票给你了。你的意思可能是
String array[]=new String[]…
，但似乎需要存储所有可能的字符串。在这种情况下，它是26^3。你的意思可能是
String array[]=new String[]…
，但是存储所有可能的数据似乎有点太多了。在本例中是26^3。