StackOverflowError 异常破坏了有趣且复杂的程序

Question

所以这个问题有点复杂，很难理解我想要做什么。

基本上，我试图随机生成 3 个向量，大小均为 11。

第一个向量必须在位置 0 处为 1，接下来的 5 个位置为 0（例如 100000），而接下来的五个数字可以是 0 1 或 2，然而，最后 5 位只能使用一个零，因此 10000012101 有效，但 10000012001 无效。

这同样适用于第二个和第三个向量，但是第一个 1 将为第二个和第三个向量移动一个位置（第二个向量为 010000xxxxx，第三个向量为 001000xxxxx）。

还有更多的条件需要满足。每个向量必须在至少 5 个位置上彼此不同（10000011210 与 01000022100 在 5 个位置上不同，这是可行的）。

然而，还有一个最终约束，即如果将向量模 3 相加，则这两个向量相加的结果必须在向量中至少有 5 个非零值。

我已经通过使用数组列表来解决这个问题。据我所知，每个向量的每个数组列表的前 6 个元素我手动放入，对于接下来的 5 个元素我随机分配它们，如果最后 5 位数字中有多个 0，我会再次递归调用该方法。

我对这个程序的问题是，当我尝试运行我的代码时，它会出现
线程“main”中的异常 java.lang.StackOverflowError 在 java.util.ArrayList.get(Unknown Source)

我认为这是因为它不断尝试循环并因此崩溃，但我不确定。请参阅下面的代码。

import java.util.ArrayList;

/**
 * The purpose of this class is to be able to capture different ways 
 * of generating six vectors that will produce a collection of 729 
 * vectors that guarantee 9 out of 11 correct. 
 */

public class GenerateVectors {

    static ArrayList<Integer> firstVector = new ArrayList<Integer>();
    static ArrayList<Integer> secondVector = new ArrayList<Integer>();
    static ArrayList<Integer> thirdVector = new ArrayList<Integer>();
    static ArrayList<Integer> sumOfXandY = new ArrayList<Integer>();

    //Creates the first vectors to ensure it starts with "1,0,0,0,0,0" 
    //and has at most one more zero in the last 5 digits
    public void createFirstVector(){

        int[] fir stVector1 = {1,0,0,0,0,0};
        for (int i=0; i<firstVector1.length; i++) {
            firstVector.add(firstVector1[i]);
        }
        for(int i = 0; i < 5; i++){
            int x = (int) (Math.random()*3);
            firstVector.add(x);
    }
    int j = 0;
    for(int i = 6; i<firstVector.size(); i++){
        if(firstVector.get(i).equals(0)){
            j++;
        }
    }
    if(j>1){
        OneZeroInLastFive(firstVector);
    }


    int[] sum = {0,0,0,0,0,0,0,0,0,0,0};
        for (int i=0; i<sum.length; i++) {
            sumOfXandY.add(sum[i]);
        }
    }

    //Edits the vector if there is more than 0 in the last five digits
    public void OneZeroInLastFive(ArrayList<Integer> x){
        int j = 0;
        for(int i = 6; i<x.size(); i++){
            if(x.get(i).equals(0)){
                j++;
            }
        }
        if(j>1){
            x.set(6, (int) (Math.random()*3));
            x.set(7, (int) (Math.random()*3));
            x.set(8, (int) (Math.random()*3));
            x.set(9, (int) (Math.random()*3));
            x.set(10, (int) (Math.random()*3));
            j = 0;
            OneZeroInLastFive(x);
        }
    }


    //Creates the second vector with the last 5 digits random
    public void createSecondVector(){
        int[] secondVector1 = {0,1,0,0,0,0};
        for (int i=0; i<secondVector1.length; i++) {
            secondVector.add(secondVector1[i]);
        }
        for(int i = 0; i < 5; i++){
            int x = (int) (Math.random()*3);
            secondVector.add(x);
        }
    }

    //Creates the third vector with the last 5 digits random
    public void createThirdVector(){
        int[] thirdVector1 = {0,0,1,0,0,0};
        for (int i=0; i<thirdVector1.length; i++) {
            thirdVector.add(thirdVector1[i]);
        }
        for(int i = 0; i < 5; i++){
            int x = (int) (Math.random()*3);
            thirdVector.add(x);
        }
    }

    /**
     * Will edit the second vector to ensure the following conditions are satisfied 
     * - The sum of x and y modulo 3 has at least 5 NON zeros
     * - x and y must DIFFER in at least 5 places 
     * - There is only one zero within the last 5 digits 
     *
     */
    public void checkVectors(ArrayList<Integer> x, ArrayList<Integer> y){
        int k = 0;
        int m = 0;
        for(int j = 0; j < x.size(); j++){
            if(x.get(j).equals(y.get(j))){
                ;
            }
            else{
                k++;
            }   
        }
        for(int i = 6; i<y.size(); i++){
            if(y.get(i).equals(0)){
                m++;
            }
        }
        if((k>4 && m<1)&& checkNonZeros(x,y)){

            System.out.println("Conditions met");
        }
        else{
            y.set(6, (int) (Math.random()*3));
            y.set(7, (int) (Math.random()*3));
            y.set(8, (int) (Math.random()*3));
            y.set(9, (int) (Math.random()*3));
            y.set(10, (int) (Math.random()*3));
            k = 0;
            m = 0;
            checkVectors(x,y);
        }
    }


    public ArrayList<Integer> addTwoVectors(ArrayList<Integer> x, ArrayList<Integer> y, ArrayList<Integer> z){
        for(int i = 0; i<x.size(); i++){
            int j = x.get(i);
            int k = y.get(i);
            z.set(i, ((j+k)%3));
        }
        return z;
    }


    public boolean checkNonZeros(ArrayList<Integer> x, ArrayList<Integer> y){
        addTwoVectors(x,y, sumOfXandY);
        int j = 0;
        for(int i = 0; i<firstVector.size(); i++){
            if(sumOfXandY.get(i).equals(0)){
                ;
            }
            else{
                j++;
            }
        }
        if(j<5){
            return false;
        }
        else {
            return true;
        }
    }

    public static void main(String[] args){
        GenerateVectors g = new GenerateVectors();
        g.createFirstVector();
        g.createSecondVector();
        g.createThirdVector();

        g.checkVectors(firstVector,secondVector);
        g.checkVectors(secondVector,thirdVector);

        System.out.println(firstVector);
        System.out.println(secondVector);
        System.out.println(thirdVector + "\n");

        System.out.println(g.checkNonZeros(firstVector, secondVector));
        System.out.println(g.checkNonZeros(secondVector,thirdVector));
        System.out.println(sumOfXandY);
    }

}

任何帮助将不胜感激！

Answer 1

问题在于，您的方法会递归地调用自身以“重做”，这可能会在成功之前发生多次。这在像scheme或ml这样的语言中很好，它们可以进行适当的尾递归，但java不会，所以你会遇到堆栈溢出。

为了解决这个问题，您需要手动将递归代码转换为循环。代码看起来像：

method(arg1, arg2) {
    Code_block_1;
    if (test) {
        Code_block_2;
    } else {
        Code_block_3;
        method(newarg1, newarg2);
    }
}

需要变成类似：

method(arg1, arg2) {
    Code_block_1;
    while(!test) {
        Code_block_3;
        arg1 = newarg1;
        arg2 = newarg2;
        Code_block_1;
    }
    Code_block_2;
}

如果你愿意的话，你可以重构东西来删除/合并重复的代码。