java如何存储无限递归对象

下面的代码显示了leetcode中的数据结构。我们可以看到node1存储一个包含node2和node3的列表，node2将存储一个包含node1和node4的列表。在这种情况下，我认为node1和node2将存储彼此的对象，这将导致无限递归。java是如何存储这样的数据结构的，它不会导致内存溢出吗

class Node {
    public int val;
    public List<Node> neighbors;

    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }

    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }

    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}

类节点{
公共国际价值；
公布邻居名单；
公共节点（）{
val=0；
邻居=新的ArrayList（）；
}
公共节点（int_val）{
val=_val；
邻居=新的ArrayList（）；
}
公共节点（int _val，ArrayList _邻居）{
val=_val；
邻居=_邻居；
}
}

publicstaticvoidmain（字符串[]args）{
Node node1=新节点（1，new ArrayList（））；
Node node2=新节点（2，new ArrayList（））；
Node node3=新节点（3，new ArrayList（））；
Node node4=新节点（4，new ArrayList（））；
node1.neights.add（node2）；
node1.neights.add（node4）；
node2.neights.add（node1）；
node2.neights.add（node3）；
node3.neights.add（node2）；
node3.neights.add（node4）；
node4.neights.add（node1）；
node4.neights.add（node3）；
溶液=新溶液（）；
解决方案：克隆人（node1）；
}

如果每个节点的邻居列表都包含这些邻居的副本，那么这个导致内存被超过的代码是正确的。但Java不是这样工作的。相反，该列表包含对相邻节点的引用

打个比方，如果每次你写下某人的地址，你都需要一份他们房子的完整副本，那么你的空间很快就会用完。但你不需要——你只需要一个对他们房子的引用，而房子本身就可以包含对你房子的引用

请注意，编写代码很容易导致堆栈溢出，对象中包含对自身的引用。例如，如果您的类有一个方法：

class Node {
    public int sumVals() {
        return val + neighbours.stream().mapToInt(Node::sumVals).sum();
    }
}

---

调用node1.sumVals（）将导致无限递归。

没有递归。你好@Jackie。我能理解这让你很困惑。您对每个对象存储其他对象的理解是正确的。但请记住，存储对象发生在内存中。递归是一种计算技术。以某种方式存储数据并不意味着会有递归。递归发生在执行某些计算时。例如，在图遍历期间（在本例中），需要解决方案工程师处理递归可能进入无限循环的情况。您应该尝试解决一些图遍历问题，以掌握其窍门。

class Node {
    public int sumVals() {
        return val + neighbours.stream().mapToInt(Node::sumVals).sum();
    }
}