暴力算法w/Java传递字符串错误

我认为这可能是一个非常简单的解决方案，但我不太确定

我试图创建一个字符数组，通过增加数组的特定索引对它们进行排序，并在末尾将它们放入字符串中

我已经完成了这一点，（通过将结果打印到控制台进行验证。“aaaaaaaa”到“aaaaaab”等等。但是，我的新版本代码通过ASCII值33-126进行排序。“！”到“~”

现在，我要做的一件事是在main方法中调用该字符串，这样分配给我们的加密/解密程序可以反复使用该字符串

我们最初分配的计划可在此处找到：

import java.lang.Class.*；
导入java.io.FileInputStream；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入javax.crypto.Cipher；
导入javax.crypto.cipheriputstream；
导入javax.crypto.CipherOutputStream；
导入javax.crypto.SecretKey；
导入javax.crypto.SecretKeyFactory；
导入javax.crypto.spec.DESKeySpec；
公共课示例1{
公共字符串keyGen（）{
//创建用于存储每个字符的数组
字符数组[]=新字符[8]；
//“！”和“~”之间的每个字符的for循环检查
对于（char c0='！'；c0希望这能帮助您解决问题。至于现在，您的
keyGen（）
相当于以下代码：

public String keyGen() {
    return "!!!!!!!!";
}

因为您在输入最里面的
for
循环时立即返回值。也许您想更改方法以返回
列表
，并将最里面的
for
循环中的字符串添加到该列表中，然后在所有
for
循环之后返回该列表？这样您就可以在
循环中迭代列表>main
方法


如果我计算正确，则有93^8=5.595.818.096.650.401个不同的字符串。将所有字符串存储在列表中是一个错误的建议。Dukeling在评论中指出，最好使用自定义的
迭代器


编辑

下面是这样一个迭代器的实现：

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（））；
}
}
}
@MattheusWardius:请参见我的编辑，了解这样一个
迭代器
。它有
main
方法来演示如何使用它。
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());
        }
    }
}