Java航班路径解析：中转城市与距离计算教程

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《Java航班路径显示：中转城市与距离计算教程》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

本文旨在指导读者如何在Java中实现一个航班路径程序，使其能够准确地显示从用户指定的中转城市出发的所有后续连接，并计算从起始城市到最终目的地的总距离。通过分析现有代码的不足，我们将重点优化`showConnections`方法，使其能够有针对性地获取并展示特定中转城市的出港航班及其累计飞行距离，从而提高程序的逻辑准确性和可读性。

1. 引言：理解航班连接与距离计算的需求

在构建航班路径管理系统时，一个常见需求是根据用户的选择，显示从某一特定中转城市出发的所有直达航班，并计算从整个行程起点到这些后续目的地的总距离。例如，如果从芝加哥（Chicago）出发，经纽约（New York）中转，我们不仅要列出从纽约出发的航班，还要显示“芝加哥 -> 纽约 -> 目的地”的总距离。

原始代码尝试通过showConnections方法实现这一功能，但存在逻辑上的偏差，导致其遍历了整个航班图，而非仅仅是中转城市的连接。本教程将详细介绍如何修正这一问题，实现精确的连接显示和距离累计。

2. 初始代码分析与存在的问题

让我们首先审视原始代码中HWDriverPrep.java的showConnections方法及其辅助方法connect：

// HWDriverPrep.java (原始代码片段)
private static void showConnections(HWGraph g, Vertex layOverVertex) {
    g.graphMap.forEach(
            (key, value) -> connect(key, value));
}

private static void connect(String key, ArrayList<Vertex> value) {
    for(Vertex v : value){
        System.out.println("City: " + v.label + " Distance: " + v.weight);
    }
}

问题点分析：

1. showConnections方法的遍历范围不准确： g.graphMap.forEach((key, value) -> connect(key, value))这行代码遍历了HWGraph中存储的所有城市及其连接，而不是仅限于用户选择的中转城市layOverVertex。这意味着无论用户选择哪个中转城市，程序都会尝试打印出图中所有城市的连接，与实际需求不符。
2. connect方法缺乏上下文信息： connect方法在被调用时，只接收了当前遍历到的城市key和其直连的value（一个ArrayList）。它不知道当前正在处理的是否是用户指定的中转城市，也不知道从起始城市到中转城市的距离。因此，它无法计算“起始城市 -> 中转城市 -> 目的地”的总距离。
3. layOverVertex参数未被充分利用： showConnections方法接收的layOverVertex参数包含了中转城市的标签（layOverVertex.label）和从起始城市到中转城市的距离（layOverVertex.weight）。这些关键信息在原始实现中并未被有效利用来过滤连接或计算总距离。

3. 核心解决方案：精准定位与距离累计

要解决上述问题，我们需要对showConnections方法进行根本性改造。核心思路是：

1. 精准定位中转城市连接： 利用HWGraph类中已有的getConnections(String label)方法，直接获取中转城市的所有出港连接，避免遍历整个图。
2. 传递并累计距离： 将从起始城市到中转城市的距离作为基准，与中转城市到后续目的地的直飞距离相加，得到完整的总距离。

4. 重构showConnections方法

我们将废弃原有的connect辅助方法，将其逻辑直接整合到重构后的showConnections中，并确保layOverVertex的所有信息得到充分利用。

以下是修正后的showConnections方法实现：

// HWDriverPrep.java (修正后的代码片段)
private static void showConnections(HWGraph g, Vertex layOverVertex) {
    // 1. 获取中转城市的标签
    String layOverCityLabel = layOverVertex.label;
    // 2. 获取从起始城市到中转城市的距离
    int distanceToLayover = layOverVertex.weight;

    // 3. 使用HWGraph的getConnections方法，获取中转城市的所有出港连接
    ArrayList<Vertex> onwardConnections = g.getConnections(layOverCityLabel);

    System.out.printf("\n从 %s 中转的连接 (起始城市到中转城市距离: %d):\n", layOverCityLabel, distanceToLayover);

    if (onwardConnections != null && !onwardConnections.isEmpty()) {
        for (Vertex onwardCity : onwardConnections) {
            // 4. 计算总距离：起始城市 -> 中转城市 -> 后续城市
            int totalDistance = distanceToLayover + onwardCity.weight;
            System.out.printf("  -> %s (直飞距离: %d, 总距离: %d)\n",
                              onwardCity.label, onwardCity.weight, totalDistance);
        }
    } else {
        System.out.printf("  从 %s 没有后续连接。\n", layOverCityLabel);
    }
}

代码解释：

• layOverCityLabel：直接从layOverVertex中提取中转城市的名称。
• distanceToLayover：从layOverVertex中提取从起始城市到中转城市的距离。这个Vertex对象是由g.getThisVertex(startCity, layOver)返回的，其weight属性恰好存储了这一段的距离。
• g.getConnections(layOverCityLabel)：这是关键一步，它直接从图结构中获取了layOverCityLabel所代表城市的所有直连出港航班。
• 循环遍历onwardConnections：对于每一个从layOverCityLabel出发的后续城市onwardCity，我们计算其totalDistance。
• totalDistance：等于distanceToLayover（起始到中转）加上onwardCity.weight（中转到后续城市）。
• 输出格式：清晰地展示了后续城市、中转到后续的直飞距离以及从起始城市算起的总距离。

5. 完整的HWDriverPrep.java示例

为了更好地展示如何集成上述修改，以下是完整的HWDriverPrep.java代码，其中包含了创建图、获取用户输入以及调用修正后showConnections方法的逻辑。

import java.util.ArrayList;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class HWDriverPrep {
    public static void main(String[] args) {
        HWGraph g = createGraph();
        // 打印整个图结构，用于调试或全面了解
        // printGraph( g ); 

        Set<String> keys = g.getKeys();
        String startCity = "Chicago"; // 示例起始城市

        // 获取用户输入的中转城市
        String layOver = getLayOverCity(keys, startCity);

        // 获取从起始城市到中转城市的Vertex对象，其中包含了该段的距离
        Vertex layOverVertex = g.getThisVertex(startCity, layOver);

        if (layOverVertex == null) {
            System.out.println("错误：无法找到从 " + startCity + " 到 " + layOver + " 的直飞路径，请检查输入。");
            return;
        }

        System.out.printf("\n起始城市: %s, 中转城市: %s (距离: %d)\n", startCity, layOverVertex.label, layOverVertex.weight);

        // 调用修正后的showConnections方法，显示中转城市的所有连接及总距离
        showConnections(g, layOverVertex);
    }

    // 辅助方法：打印整个图结构（可选，用于调试）
    private static void printGraph(HWGraph g) {
        System.out.println("--- 完整航班图结构 ---");
        g.graphMap.forEach(
                (key, value) -> show(key, value));
        System.out.println("--------------------");
    }

    // 辅助方法：显示单个城市的连接（用于printGraph）
    private static void show(String key, ArrayList<Vertex> value) {
        System.out.println("城市: " + key + " 的连接:");
        for(Vertex v : value){
            System.out.println("  -> " + v.label + " (距离: " + v.weight + ")");
        }
    }

    // 辅助方法：获取用户输入的中转城市
    private static String getLayOverCity(Set<String> keys, String startCity) {
        Scanner s = new Scanner(System.in);
        StringBuilder oStr = new StringBuilder();
        String cm = "";
        for(String item: keys) {
            oStr.append(cm).append(item);
            cm = ", ";
        }

        System.out.printf("请选择一个中转城市 (%s): ", oStr.toString());
        String retItem = s.nextLine();
        return retItem;
    }

    // 修正后的方法：显示中转城市的连接及总距离
    private static void showConnections(HWGraph g, Vertex layOverVertex) {
        String layOverCityLabel = layOverVertex.label;
        int distanceToLayover = layOverVertex.weight; // 从起始城市到中转城市的距离

        ArrayList<Vertex> onwardConnections = g.getConnections(layOverCityLabel);

        System.out.printf("\n从 %s 中转的连接 (起始城市到中转城市距离: %d):\n", layOverCityLabel, distanceToLayover);

        if (onwardConnections != null && !onwardConnections.isEmpty()) {
            for (Vertex onwardCity : onwardConnections) {
                int totalDistance = distanceToLayover + onwardCity.weight;
                System.out.printf("  -> %s (直飞距离: %d, 总距离: %d)\n",
                                  onwardCity.label, onwardCity.weight, totalDistance);
            }
        } else {
            System.out.printf("  从 %s 没有后续连接。\n", layOverCityLabel);
        }
    }

    // 创建航班图数据
    private static HWGraph createGraph() {
        HWGraph g = new HWGraph();
        g.addVertex("Chicago");
        g.addVertex("Dallas");
        g.addVertex("Atlanta");
        g.addVertex("New York");
        g.addVertex("Houston");
        g.addVertex("Orlando");

        // --- 添加连接
        g.addEdge("Chicago",new Vertex("Dallas",968));
        g.addEdge("Chicago",new Vertex("Atlanta",718));
        g.addEdge("Chicago",new Vertex("New York",790));

        g.addEdge("Dallas",new Vertex("Houston",239));
        g.addEdge("Dallas", new Vertex("Orlando",1120));

        g.addEdge("Houston", new Vertex("Orlando",967));

        g.addEdge("Atlanta", new Vertex("Dallas",781));
        g.addEdge("Atlanta", new Vertex("New York",870));
        g.addEdge("Atlanta", new Vertex("Orlando",438));

        g.addEdge("New York", new Vertex("Houston",1647));
        g.addEdge("New York", new Vertex("Orlando",1080));

        return g;
    }
}

6. Vertex.java 和 HWGraph.java （无变化）

这两个类保持不变，因为它们的设计已经足以支持上述逻辑。

Vertex.java:

public class Vertex {
    String label;
    int weight;
    public Vertex(String label, int weight) {
        this.label = label;
        this.weight = weight;
    }
}

HWGraph.java:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HWGraph {
    public HashMap<String, ArrayList<Vertex>> graphMap = new HashMap<>();

    public void addVertex( String label ){
        ArrayList<Vertex> items = new ArrayList<>();
        graphMap.put( label, items);
    }
    public void removeVertex( String label ){
        // 移除顶点及其所有相关边，此处未实现
    }
    public void addEdge( String label1, Vertex v){
        // 添加从 label1 到 v.label 的有向边，权重为 v.weight
        graphMap.get(label1).add(v);
    }
    ArrayList<Vertex> getConnections( String label){
        // 获取指定城市的所有出港连接
        return graphMap.get(label);
    }
    Set<String> getKeys( ){
        // 获取所有城市的标签
        Set<String> keys = graphMap.keySet();
        return keys;
    }
    Vertex getThisVertex( String startCity, String destCity){
        // 获取从 startCity 到 destCity 的直飞 Vertex 对象，包含距离
        ArrayList<Vertex> destCities = this.getConnections( startCity);
        if (destCities != null) {
            for( Vertex v : destCities){
                if ( v.label.equalsIgnoreCase(destCity)){
                    return v;
                }
            }
        }
        return null; // 如果没有找到直飞路径
    }
}

7. 注意事项与最佳实践

• 错误处理： 在main方法中，我们添加了对layOverVertex == null的检查。如果用户输入的中转城市无法从起始城市直飞到达，getThisVertex会返回null。良好的错误处理能够提升用户体验。
• 图的表示： 当前的HWGraph是一个有向图，其中addEdge只添加了从label1到v的边。如果需要双向连接（即如果A能飞到B，B也能飞到A），则需要修改addEdge方法，同时添加两条边。
• 灵活性： showConnections方法现在是高度聚焦的。如果未来需要显示所有连接（如printGraph），可以保留或创建单独的方法来处理。
• 用户输入验证： getLayOverCity方法目前没有验证用户输入是否是有效城市。在实际应用中，应该添加逻辑来检查用户输入是否在keys集合中。

8. 总结

通过对showConnections方法进行重构，我们解决了原始代码中遍历范围不准确和缺乏上下文信息的问题。现在，程序能够：

1. 根据用户选择的中转城市，精确地显示其所有后续直飞连接。
2. 正确计算从起始城市经过中转城市到达后续目的地的总飞行距离。

这一改进使得航班路径显示功能更加准确、直观，并且代码逻辑也更加清晰和易于维护，体现了在图结构中进行有针对性数据查询和处理的最佳实践。

今天关于《Java航班路径解析：中转城市与距离计算教程》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！