用JAVA语言对输入两个站点，给出路线的信息查询的主要代码

### 回答1：
以下是一个简单的Java代码示例，用于查询两个站点之间的路线信息：

import java.util.*;

public class RouteFinder {
  // 定义一个地图，使用邻接矩阵存储站点之间的距离
  private int[][] map;

  // 初始化地图
  public RouteFinder(int[][] map) {
    this.map = map;
  }

  // 查找两个站点之间的最短路线，使用Dijkstra算法
  public List<Integer> findRoute(int start, int end) {
    List<Integer> route = new ArrayList<>();
    int[] dist = new int[map.length];
    boolean[] visited = new boolean[map.length];
    int[] prev = new int[map.length];
    for (int i = 0; i < map.length; i++) {
      dist[i] = Integer.MAX_VALUE;
      visited[i] = false;
      prev[i] = -1;
    }
    dist[start] = 0;

    for (int i = 0; i < map.length; i++) {
      int u = getMinDistance(dist, visited);
      visited[u] = true;
      for (int v = 0; v < map.length; v++) {
        if (!visited[v] && map[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + map[u][v] < dist[v]) {
          dist[v] = dist[u] + map[u][v];
          prev[v] = u;
        }
      }
    }

    int current = end;
    while (current != -1) {
      route.add(0, current);
      current = prev[current];
    }

    return route;
  }

  // 获取未访问节点中距离起点最近的节点
  private int getMinDistance(int[] dist, boolean[] visited) {
    int minDist = Integer.MAX_VALUE;
    int minIndex = -1;
    for (int i = 0; i < dist.length; i++) {
      if (!visited[i] && dist[i] < minDist) {
        minDist = dist[i];
        minIndex = i;
      }
    }
    return minIndex;
  }

  public static void main(String[] args) {
    // 定义一个地图，存储站点之间的距离
    int[][] map = {
      {0, 2, 0, 4, 0},
      {2, 0, 3, 0, 0},
      {0, 3, 0, 0, 5},
      {4, 0, 0, 0, 1},
      {0, 0, 5, 1, 0}
    };
    RouteFinder finder = new RouteFinder(map);
    List<Integer> route = finder.findRoute(0, 4);
    System.out.println(route);
  }
}

这段代码实现了一个RouteFinder类，其中包含一个二维数组map，用于存储站点之间的距离信息。findRoute方法使用Dijkstra算法来查找两个站点之间的最短路线，并返回一个List对象，包含经过的站点的编号。在main方法中，我们创建了一个RouteFinder对象，并使用它来查找从站点0到站点4的最短路线。输出结果为[0, 1,

### 回答2：
以下是一个用 JAVA 语言编写的查询两个站点之间路线信息的主要代码：

import java.util.*;

public class RouteFinder {
    private Map<String, List<String>> graph;

    public RouteFinder() {
        this.graph = new HashMap<>();
    }

    public void addEdge(String source, String destination) {
        if (!graph.containsKey(source)) {
            graph.put(source, new ArrayList<>());
        }
        if (!graph.containsKey(destination)) {
            graph.put(destination, new ArrayList<>());
        }
        graph.get(source).add(destination);
        graph.get(destination).add(source);
    }

    public List<String> findRoute(String source, String destination) {
        Map<String, String> parent = new HashMap<>();
        Queue<String> queue = new LinkedList<>();
        queue.add(source);
        parent.put(source, null);

        while (!queue.isEmpty()) {
            String current = queue.poll();
            if (current.equals(destination)) {
                break;
            }

            for (String neighbor : graph.get(current)) {
                if (!parent.containsKey(neighbor)) {
                    queue.add(neighbor);
                    parent.put(neighbor, current);
                }
            }
        }

        List<String> route = new ArrayList<>();
        String current = destination;
        while (current != null) {
            route.add(current);
            current = parent.get(current);
        }
        Collections.reverse(route);

        return route;
    }

    public static void main(String[] args) {
        RouteFinder finder = new RouteFinder();

        finder.addEdge("站点1", "站点2");
        finder.addEdge("站点1", "站点3");
        finder.addEdge("站点2", "站点3");
        finder.addEdge("站点3", "站点4");
        finder.addEdge("站点4", "站点5");

        String source = "站点1";
        String destination = "站点5";
        List<String> route = finder.findRoute(source, destination);

        if (route.isEmpty()) {
            System.out.println("找不到从 " + source + " 到 " + destination + " 的路线");
        } else {
            System.out.println("从 " + source + " 到 " + destination + " 的路线是：" + route);
        }
    }
}

这段代码实现了一个基于图的路线查询算法。我们首先创建了一个空的图 `graph`，然后通过 `addEdge` 方法向图中添加边，表示站点之间的连接关系。接下来，我们使用广度优先搜索算法遍历图，找到从 `source` 到 `destination` 的最短路径，并将路径节点存储在 `parent` 中。最后，我们通过从 `destination` 开始，逐步回溯到 `source`，将经过的节点添加到 `route` 中。最终，我们可以打印出查询到的路线信息。

### 回答3：
要用JAVA语言编写一个输入两个站点并给出路线信息查询的程序，首先需要设计一个方法来获取两个站点之间的路线信息。

首先，我们可以定义一个叫做`getRouteInfo`的方法，它接收两个站点的参数，并返回一个字符串表示路线信息。

在这个方法中，我们可以利用Java提供的网络请求和解析HTML的库来打开并解析一个能够查询路线信息的网页。可以使用`URLConnection`类来打开网页链接，然后使用`BufferedReader`类读取网页内容。读取到的内容可以使用正则表达式或其他方式进行解析，提取出路线信息。

在网页内容的解析中，我们可以根据网页的结构和元素来定位和提取我们需要的路线信息。例如，可以通过查找某个特定元素的标签或ID来获取出发地、目的地和路线描述等信息。

解析出路线信息后，我们可以将它们拼接成一个字符串，并返回给调用者。

以下是一个简单的示例代码实现：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;

public class RouteInfoQuery {
    public static void main(String[] args) {
        String startStation = "北京";
        String endStation = "上海";
        
        String routeInfo = getRouteInfo(startStation, endStation);
        System.out.println(routeInfo);
    }
    
    public static String getRouteInfo(String start, String end) {
        String routeInfo = "";
        
        try {
            // 构建查询网页链接
            String urlString = "http://www.example.com/route?start=" + start + "&end=" + end;
            URL url = new URL(urlString);
            URLConnection connection = url.openConnection();
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            
            String line;
            StringBuilder content = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                content.append(line);
            }
            reader.close();
            
            // 解析路线信息
            String startStation = parseStartStation(content.toString());
            String endStation = parseEndStation(content.toString());
            String routeDescription = parseRouteDescription(content.toString());
            
            // 拼接路线信息
            routeInfo = "出发地：" + startStation + "\n目的地：" + endStation + "\n路线描述：" + routeDescription;
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        return routeInfo;
    }
    
    // 解析出发地
    public static String parseStartStation(String content) {
        // 在content中解析出发地信息的代码
        // ...
        return "北京";
    }
    
    // 解析目的地
    public static String parseEndStation(String content) {
        // 在content中解析目的地信息的代码
        // ...
        return "上海";
    }
    
    // 解析路线描述
    public static String parseRouteDescription(String content) {
        // 在content中解析路线描述信息的代码
        // ...
        return "通过高速公路前往，全程约1100公里";
    }
}

以上代码是一个简单的示例，实际应用需要根据具体网页结构和解析规则进行相应的修改。还可以进一步优化代码结构和错误处理机制来增加程序的健壮性和可扩展性。