编写程序，演示无向图的遍历操作。要求以邻接矩阵为存储结构实现连通无向图的深度优先遍历和广度优先遍历，输出图的邻接矩阵，并以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集（JAVA）

在Java中，我们可以首先创建一个邻接矩阵来表示无向图，然后实现深度优先搜索(DFS)和广度优先搜索(BFS)算法。以下是代码示例：

import java.util.*;

class Graph {
    int V; // 图的顶点数
    boolean[][] adjMatrix; // 邻接矩阵

    // 构造函数
    public Graph(int v) {
        V = v;
        adjMatrix = new boolean[v][v];
    }

    // 添加边
    void addEdge(int v, int w) {
        adjMatrix[v][w] = true;
        adjMatrix[w][v] = true; // 无向图，添加双向边
    }

    // DFS遍历
    private List<Integer> dfsUtil(int src) {
        boolean[] visited = new boolean[V];
        Stack<Integer> stack = new Stack<>();
        visited[src] = true;
        stack.push(src);

        List<Integer> traversal = new ArrayList<>();
        while (!stack.isEmpty()) {
            int u = stack.pop();
            traversal.add(u);
            for (int i = 0; i < V; i++) {
                if (adjMatrix[u][i] && !visited[i]) {
                    stack.push(i);
                    visited[i] = true;
                }
            }
        }

        return traversal;
    }

    // DFS遍历并打印路径
    void printDFTriple(int src) {
        List<Integer> traversal = dfsUtil(src);
        System.out.println("DFS from " + src + ": " + traversal);
        // 打印边集（生成树的边）
        for (int i = 1; i < traversal.size(); i++) {
            System.out.print(traversal.get(i - 1) + " -> " + traversal.get(i) + " ");
        }
        System.out.println("\n");
    }

    // BFS遍历
    private Queue<Integer> bfsUtil(int src) {
        boolean[] visited = new boolean[V];
        Queue<Integer> queue = new LinkedList<>();
        visited[src] = true;

        queue.offer(src);
        List<Integer> traversal = new ArrayList<>();
        while (!queue.isEmpty()) {
            int u = queue.poll();
            traversal.add(u);
            for (int i = 0; i < V; i++) {
                if (adjMatrix[u][i] && !visited[i]) {
                    visited[i] = true;
                    queue.offer(i);
                }
            }
        }

        return traversal;
    }

    // BFS遍历并打印路径
    void printBFTriple(int src) {
        List<Integer> traversal = bfsUtil(src);
        System.out.println("BFS from " + src + ": " + traversal);
        // 打印边集（生成树的边）
        for (int i = 1; i < traversal.size(); i++) {
            System.out.print(traversal.get(i - 1) + " -> " + traversal.get(i) + " ");
        }
        System.out.println("\n");
    }
}

// 用户入口
public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph(4); // 假设有4个节点
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(2, 0);
        graph.addEdge(2, 3);
        graph.addEdge(3, 3); // 自环，仅用于测试

        System.out.println("邻接矩阵:");
        for (boolean[] row : graph.adjMatrix) {
            for (boolean b : row) {
                System.out.print(b ? '1' : '0');
            }
            System.out.println();
        }

        System.out.println("从节点0开始的DFS遍历:");
        graph.printDFTriple(0);

        System.out.println("从节点0开始的BFS遍历:");
        graph.printBFTriple(0);
    }
}

这段代码首先创建了一个无向图，然后实现了DFS和BFS的遍历，以及打印出对应的访问序列和边集。用户可以在main方法中修改`Graph`实例的构造函数，添加或删除边，然后选择任意节点作为起始点。