Java：提供对ArrayList的引用的对象<；对象>；同班同学

我是Java新手，这可能真的很容易，但我还是坚持使用它。我必须创建一个类Node，它代表一个图中的所有节点。我将使用它来实现基本算法，如dfs。我只需要使用一个字段，它是节点所有邻居的ArrayList。每个创建的节点都会引用其邻居。这是我目前的课程：

public class Node{
    protected ArrayList<Node> neighbours = new ArrayList<>();

    public Node(ArrayList<Node> neighbours){
        for(int i=0;i<neighbours.size();i++){
            this.neighbours.add(neighbours.get(i));
        }

    }
    public void setNeighbours(ArrayList<Node> neighbours){
        this.neighbours=null;
    }
    public ArrayList<Node> getNeighbours(){
        return this.neighbours;
    }
}

公共类节点{
受保护的ArrayList邻居=新的ArrayList（）；
公共节点（ArrayList邻居）{
对于（int i=0；i不喜欢使用传入的列表，而是复制其内容：

public void setNeighbours(ArrayList<Node> neighbours){
    this.neighbours.clear();
    this.neighbours.addAll(neighbours);
}

public void setneights（ArrayList neights）{
这个。邻居。清除（）；
this.neights.addAll（neights）；
}

因为如果您使用它，另一个进程可能会在您的类不知道更改的情况下更改它。
是的，您可以创建默认构造函数

public Node() {}

这样，您就可以创建一个空节点

Node A = new Node();

并且仍然使用您描述的类

Node A = new Node(listOfNeighbors);

另外，对于新创建的空节点的set方法，我建议使用类似Bohemian posted的方法，即在清除成员列表内容后复制传入的列表内容：
如果将构造函数参数更改为如下数组：

公共节点（节点…节点）{
}

您可以传递如下内容：

节点A=新节点（b，c）

在构造函数中，您应该这样编写：
Arrays.asList（节点）
如果我正确地解释了您的问题，它将返回List
，您已经这样做了。如果您想将节点A称为节点A，只需在代码中放入
A
（变量名称）。如果您想要它的邻居，只需放入
A.getNeights（）

节点A是一个节点。邻居仅仅是该节点的一个属性（字段）。这意味着通过名称引用该节点意味着它被用作节点。将其与
getneights（）
一起使用意味着它被用作数组（在您的示例中，
[B，C]
）
我不确定这是否完全是您所要求的，但您可能需要的是每个节点中的某种数据字段。这样，您可以根据节点的数据识别节点，而不仅仅是它所连接的节点列表。目前，您只能根据它们的连接进行搜索，因为它们没有连接任何可识别的属性。
不确定是否回答您的问题，但第一步是通过边定义图形，如链表，指示源节点和目标节点。然后，要执行算法dfs，您需要标记路径邻居，而不是再次经过他，以便每个节点都应有属性名称和sta特朗普

public class DephFirstSearch {
            Vertex vertice[];
            ArrayList list=new ArrayList();
            public DephFirstSearch(int  tam,ArrayList list)
            {
                    vertice = new Vertex [tam];
                    vertice[0]= new Vertex("V0", false);
                    vertice[1]= new Vertex("V1", false);
                    vertice[2]= new Vertex("V2", false);
                    vertice[3]= new Vertex("V3", false);
                    vertice[4]= new Vertex("V4", false);
                    vertice[5]= new Vertex("V5", false);
                    vertice[6]= new Vertex("V6", false);

                    this.list=list;                 

            }
            public void dfs(String origen) {

                    dfsVisit(vertice[0], 0);
            }
            public void dfsVisit(Vertex nodo, int i) {
                    nodo.setState(true);
                    System.out.println("nodo: " + nodo.getNode());

                    for (int j = 0; j < vertice.length; j++) {
                            if (isEdge(i, j) && vertice[j].isState() != true) {
                                    dfsVisit(vertice[j], j);
                            }
                    }

            }

            public boolean isEdge(int i, int j) {
                    Vertex actual = vertice[i];
                    Vertex next = vertice[j];
                    Vector lac;

                    for (int k = 0; k < list.size(); k++) {
                            lac = (Vector) list.get(k);
                            if (lac.getOrigin().equals(actual.getNode())
                                            && lac.getDestination().equals(next.getNode())) {
                                    return true;

                            }

                    }

                    return false;

                }

    public class Vertex 
  {
            String node;
            boolean state;

            public Vertex(String node, boolean state) {
                    super();
                    this.node = node;
                    this.state = state;`enter code here`
            }
}

公共类DephFirstSearch{
顶点垂直[]；
ArrayList=新建ArrayList（）；
公共部门优先搜索（int tam，ArrayList列表）
{
vertice=新顶点[tam]；
vertice[0]=新顶点（“V0”，假）；
vertice[1]=新顶点（“V1”，假）；
vertice[2]=新顶点（“V2”，false）；
vertice[3]=新顶点（“V3”，false）；
vertice[4]=新顶点（“V4”，假）；
vertice[5]=新顶点（“V5”，假）；
vertice[6]=新顶点（“V6”，假）；
this.list=list；
}
公共无效dfs（字符串源）{
DfsVisite（vertice[0]，0）；
}
公共访问（顶点节点，int i）{
nodo.setState（真）；
System.out.println（“nodo:+nodo.getNode（））；
对于（int j=0；j
ArrayList具有来自集合的addAll方法使用此方法而不是for循环。（this.neights.addAll（neights））您希望A仍然有邻居，但不在构造函数中指定它们？我也在考虑这一点，但我现在真的不想创建节点ID。而且，这可能对我的情况没有帮助，但只会使程序变得更复杂。