Java set/setElementAt未设置正确的值

我需要找到给定n（用户输入）的所有排列，而不需要回溯

我尝试的是：

import java.util.Scanner;
import java.util.Vector;

class Main {

    private static int n;
    private static Vector<Vector<Integer>> permutations = new Vector<>();



    private static void get_n() {

        Scanner user = new Scanner(System.in);

        System.out.print("n = ");

        n = user.nextInt();
    }
    private static void display(Vector<Vector<Integer>> permutations) {

        for (int i = 0; i < factorial(n) - 1; ++i) {
            for (int j = 0; j < n; ++j) {
                System.out.print(permutations.elementAt(i).elementAt(j) + " ");
            }
            System.out.println();
        }
    }



    private static int factorial(int n) {

        int result = 1;

        for (int i = 1; i <= n; ++i) {

            result *= i;
        }

        return result;
    }
    private static int max(Vector<Integer> permutation) {

        int max = permutation.elementAt(0);

        for (int i = 1; i < permutation.size(); ++i)
            if (permutation.elementAt(i) > max)
                max = permutation.elementAt(i);

        return max;
    }



    //  CHECKS FOR ELEMENT COUNT AND 0 - (n-1) APPARITION
    public static int validate_permutation(Vector<Integer> permutation) {

        // GOOD NUMBER OF ELEMENTS
        if (max(permutation) != permutation.size() - 1)
            return 0;

        // PROPER ELEMENTS APPEAR
        for (int i = 0; i < permutation.size(); ++i)
            if (!permutation.contains(i))
                return 0;

        return 1;
    }

    private static Vector<Integer> next_permutation(Vector<Integer> permutation) {

        int i;

        do {
            i = 1;

            // INCREMENT LAST ELEMENT
            permutation.set(permutation.size() - i, permutation.elementAt(permutation.size() - i) + 1);

            // IN A P(n-1) PERMUTATION FOUND n. "OVERFLOW"
            while (permutation.elementAt(permutation.size() - i) == permutation.size()) {

                // RESET CURRENT POSITION
                permutation.set(permutation.size() - i, 0);

                // INCREMENT THE NEXT ONE
                ++i;
                permutation.set(permutation.size() - i, permutation.elementAt(permutation.size() - i) + 1);
            }
        } while (validate_permutation(permutation) == 0);


        // OUTPUT
        System.out.print("output of next_permutation:\t\t");
        for (int j = 0; j < permutation.size(); ++j)
            System.out.print(permutation.elementAt(j) + " ");
        System.out.println();

        return permutation;
    }

    private static Vector<Vector<Integer>> permutations_of(int n) {

        Vector<Vector<Integer>> permutations = new Vector<>();

        // INITIALIZE PERMUTATION SET WITH 0
        for (int i = 0; i < factorial(n); ++i) {

            permutations.addElement(new Vector<>());

            for(int j = 0; j < n; ++j)
                permutations.elementAt(i).addElement(0);
        }


        for (int i = 0; i < n; ++i)
            permutations.elementAt(0).set(i, i);

        for (int i = 1; i < factorial(n); ++i) {

            // ADD THE NEXT PERMUTATION TO THE SET
            permutations.setElementAt(next_permutation(permutations.elementAt(i - 1)), i);

            System.out.print("values set by permutations_of:\t");
            for (int j = 0; j < permutations.elementAt(i).size(); ++j)
                System.out.print(permutations.elementAt(i).elementAt(j)  + " ");
            System.out.println("\n");
        }

        System.out.print("\nFinal output of permutations_of:\n\n");
        display(permutations);

        return permutations;
    }



    public static void main(String[] args) {

        get_n();

        permutations.addAll(permutations_of(n));
    }
}

import java.util.Scanner；
导入java.util.Vector；
班长{
私有静态int n；
私有静态向量置换=新向量（）；
私有静态void get_n（）{
扫描仪用户=新扫描仪（System.in）；
系统输出打印（“n=”）；
n=user.nextInt（）；
}
专用静态空白显示（矢量排列）{
对于（int i=0；i<阶乘（n）-1；++i）{
对于（int j=0；j

现在，运行代码时，问题显而易见。next_permutation在调用时输出正确的置换，值被正确设置为对应的置换向量，但最终结果是最后一个置换的大量复制，这使我相信，每次next_permutation输出一个新置换并设置为置换向量，不知何故，这种排列也被复制到所有其他排列上。我也不明白为什么，为了我的生命

我尝试了set、setElementAt和一个实现，在这个实现中，我没有首先初始化置换向量，而是在下一个置换用add（）输出时添加置换，我遇到了完全相同的问题。Java处理内存有什么奇怪的方式吗？或者这是什么原因

提前谢谢你

permutations.setElementAt(next_permutation(permutations.elementAt(i - 1)), i);

这实际上是将

置换（i）

处的向量设置为与

置换[i-1]

相同的对象。不相同的值-完全相同的对象。我认为这是你问题的根源。相反，您需要复制向量中的值