如何用java代码实现

好的，下面是一个简单的用Java代码实现带权有向图的例子，其中包含了实现起点和目的地咨询功能以及查询重要区域信息的方法：

import java.util.*;

class GraphNode {
    public int id; //节点ID
    public String name; //节点名称
    public boolean isImportant; //是否是重要场所
    public List<Edge> edges; //与该节点相连的边

    public GraphNode(int id, String name, boolean isImportant) {
        this.id = id;
        this.name = name;
        this.isImportant = isImportant;
        edges = new ArrayList<>();
    }
}

class Edge {
    public GraphNode from; //起始节点
    public GraphNode to; //终止节点
    public int weight; //边权

    public Edge(GraphNode from, GraphNode to, int weight) {
        this.from = from;
        this.to = to;
        this.weight = weight;
    }
}

class Graph {
    public List<GraphNode> nodes; //图中所有节点

    public Graph() {
        nodes = new ArrayList<>();
    }

    //添加节点
    public void addNode(GraphNode node) {
        nodes.add(node);
    }

    //添加边
    public void addEdge(GraphNode from, GraphNode to, int weight) {
        Edge edge = new Edge(from, to, weight);
        from.edges.add(edge);
    }

    //根据节点名称查找节点
    public GraphNode findNodeByName(String name) {
        for (GraphNode node : nodes) {
            if (node.name.equals(name)) {
                return node;
            }
        }
        return null;
    }

    //根据起始点和目的地查找最短路径
    public List<GraphNode> findShortestPath(String startName, String endName) {
        //初始化
        PriorityQueue<GraphNode> queue = new PriorityQueue<>(Comparator.comparingInt(n -> n.id));
        Map<GraphNode, Integer> distMap = new HashMap<>();
        Map<GraphNode, GraphNode> prevMap = new HashMap<>();
        GraphNode startNode = findNodeByName(startName);
        GraphNode endNode = findNodeByName(endName);
        for (GraphNode node : nodes) {
            if (node == startNode) {
                distMap.put(node, 0);
            } else {
                distMap.put(node, Integer.MAX_VALUE);
            }
            queue.offer(node);
        }
        //遍历所有节点
        while (!queue.isEmpty()) {
            GraphNode node = queue.poll();
            if (node == endNode) {
                break;
            }
            if (distMap.get(node) == Integer.MAX_VALUE) {
                break;
            }
            for (Edge edge : node.edges) {
                GraphNode nextNode = edge.to;
                int newDist = distMap.get(node) + edge.weight;
                if (newDist < distMap.get(nextNode)) {
                    distMap.put(nextNode, newDist);
                    prevMap.put(nextNode, node);
                    queue.remove(nextNode);
                    queue.offer(nextNode);
                }
            }
        }
        //构造路径
        List<GraphNode> path = new ArrayList<>();
        GraphNode node = endNode;
        while (prevMap.containsKey(node)) {
            path.add(0, node);
            node = prevMap.get(node);
        }
        path.add(0, startNode);
        return path;
    }

    //查询重要区域信息
    public List<String> queryImportantInfo() {
        List<String> result = new ArrayList<>();
        for (GraphNode node : nodes) {
            if (node.isImportant) {
                StringBuilder sb = new StringBuilder();
                sb.append("场所名称：").append(node.name).append("\n");
                sb.append("经过的公交线路：");
                for (Edge edge : node.edges) {
                    sb.append(edge.from.name).append("->").append(edge.to.name).append(", ");
                }
                sb.delete(sb.length() - 2, sb.length());
                result.add(sb.toString());
            }
        }
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        //创建图
        Graph graph = new Graph();
        GraphNode nodeA = new GraphNode(1, "A", false);
        GraphNode nodeB = new GraphNode(2, "B", true);
        GraphNode nodeC = new GraphNode(3, "C", false);
        GraphNode nodeD = new GraphNode(4, "D", false);
        GraphNode nodeE = new GraphNode(5, "E", true);
        graph.addNode(nodeA);
        graph.addNode(nodeB);
        graph.addNode(nodeC);
        graph.addNode(nodeD);
        graph.addNode(nodeE);
        graph.addEdge(nodeA, nodeB, 5);
        graph.addEdge(nodeA, nodeC, 3);
        graph.addEdge(nodeB, nodeC, 1);
        graph.addEdge(nodeB, nodeD, 2);
        graph.addEdge(nodeC, nodeD, 4);
        graph.addEdge(nodeC, nodeE, 6);
        graph.addEdge(nodeD, nodeE, 4);

        //测试起点和目的地咨询功能
        List<GraphNode> path = graph.findShortestPath("A", "E");
        for (GraphNode node : path) {
            System.out.print(node.name + " -> ");
        }
        System.out.println();

        //测试查询重要区域信息功能
        List<String> infoList = graph.queryImportantInfo();
        for (String info : infoList) {
            System.out.println(info);
        }
    }
}

以上代码仅作为示例，实际实现时需要根据具体需求进行修改和完善。