Java ConcurrentSkipListSet是静态的吗？

在处理哈希集时，我遇到了ConcurrentModification异常，因此切换到ConcurrentSkipListSet。虽然并发性问题已经解决，但我现在遇到了一个新问题。ConcurrentSkipListSet似乎在默认情况下是静态的。是这样吗？我在一个递归函数中使用它，这个递归函数有一个迭代器，迭代器对同一个函数进行迭代。当下一个元素被迭代时，由于同一函数的另一个递归实例所做的更改将反映在同一对象中（在正常递归中，每个实例在堆栈中分配自己的空间，这通常不是这种情况）。我不希望这些变化被反映出来。这个问题有什么解决办法吗

提前感谢：）

---

我正在使用java，下面是代码

public class TSA {

    int[][] l = { { 0, 1, 30, 65535 }, { 50, 0, 15, 5 }, { 65535, 65535, 0, 15 }, { 15, 65535, 5, 0 } };
    int[][] g;


    TSA() {
        int n = 4;
        this.g = this.l;
        int k = 0;
        ConcurrentSkipListSet a = new ConcurrentSkipListSet();

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                this.g[i][j] = this.l[i][j];
            }
        }

        System.out.println(this.g[2][1]);
        a.add(2);
        a.add(3);
        a.add(4);

        Iterator ir = a.iterator();
        int[] path = new int[n];
        k = 0;

        while (ir.hasNext()) {
            ConcurrentSkipListSet b = new ConcurrentSkipListSet();
            b = a;
            b.add(2);
            b.add(3);
            b.add(4);

            int next = (Integer) ir.next();
            System.out.println("next in main is   " + next);
            System.out.println("called with   " + b);

            path[k++] = this.l[0][next - 1] + gfun(next, b);
            System.out.println("min path is..." + path[k - 1]);

        }
    }


    public static void main(final String[] args) {
        new TSA();
    }


    int gfun(final int next, final ConcurrentSkipListSet d) {
        ConcurrentSkipListSet b = d;

        if (b.size() != 1 && b.size() != 2) {
            b.remove(next);
            System.out.println(b);

            int[] path = new int[b.size()];
            int k = 0;

            Iterator ir = b.iterator();

            while (ir.hasNext()) {
                int a = (Integer) ir.next();
                System.out.println(a + "     iterator prob   " + b);
                path[k] = this.l[next - 1][a - 1] + gfun(a, b);
                System.out.println("path[" + k + "] is" + path[k]);
                k = k + 1;

            }

            return min(path);
        }
        else if (b.size() == 2) {
            System.out.println("second instance..." + next + ".." + b);
            Iterator irrr = b.iterator();
            int a = (Integer) irrr.next();
            b.remove(next);
            return (gfun(next, b));
        }
        else {
            Iterator irr = b.iterator();

            int j = (Integer) irr.next();
            System.out.println("inside prog size is 1" + b);
            System.out.println("l[" + next + "][" + j + "] is  " + this.l[next - 1][j - 1]);
            int ans = this.l[next - 1][j - 1] + this.g[j - 1][0];
            System.out.println("l[" + next + "][" + j + "]+g[" + j + "][1] which is   " + ans + "  is                                   r               returned");

            return (ans);
        }

    }


    private int min(final int[] path) {
        int m = path[0];

        for (int i = 0; i < path.length; i++) {
            if (path[i] < m) {
                m = path[i];
            }
        }
        return m;
    }
}

公共类TSA{
int[]l={0,1,30,65535}，{50,0,15,5}，{65535,65535,0,15}，{15,65535,5,0}；
int[][]g；
TSA（）{
int n=4；
this.g=this.l；
int k=0；
ConcurrentSkipListSet a=新的ConcurrentSkipListSet（）；
对于（int i=0；i

---

我将从集合b中删除元素，当函数返回到以前的状态（while循环中的迭代器）时，原始集合b将受到影响。我不想发生这种事。谁来帮忙！：（

您对Java中引用和变量的工作方式有一些基本的误解。通常，只有在看到

new

关键字时，您才会创建一个新对象，如

new ConcurrentSkipListSet（）

）。（在一些特殊情况下，如何创建对象而不看到一些

new

关键字，但我认为首先可以忽略这些。）

从一个变量到另一个变量的所有赋值都不会创建新对象。您可以将变量赋值给与另一个相同的对象。这些是对同一对象的引用

您有以下代码，例如：

    while (ir.hasNext()) {
        ConcurrentSkipListSet b = new ConcurrentSkipListSet();
        b = a; // 'b' now refers to the same object as 'a'.
        ...
    }

这完全没有意义。您创建一个新列表并将其放到下一行，因为现在您将引用

b

指向引用

a

指向的同一对象

这就是为什么在所有代码中只使用首先创建的列表对象：

    ConcurrentSkipListSet a = new ConcurrentSkipListSet();

与二维数组非常相似。您只创建了一个数组，将其分配给

l

，并在后面的代码中将

g

指向同一数组

l

所指向的数组。之后，您复制了一些值，但实际上您将值从同一数组对象复制到同一数组对象。这完全没有意义。请按

>System.out.println（this.g[2][1]）；

位于

循环的
顶部，我打赌您会感到惊讶

看看@RC.在他的评论中发布了哪一条。这是在解决您误解的根源。
如果您能展示您的代码，那将非常有帮助。您对“正常递归”的描述虽然听起来不太对，但是…了解您使用的语言可能也很有用…我使用的是java，下面是代码…请忽略我使用过的大量打印语句…我还没有学习eclipse中调试的教程：PMy建议，不要使用数组，不要使用ConcurrentSkipListSet，阅读和不要命名变量a、 b，c，…（最后一个链接回答你的问题）@Fabian Barney我应该更认真地对待我的基础知识…非常感谢！