用Java计算两点之间的距离

1. 概述

在这个快速教程中，我们将实现计算两个地理位置之间距离的方法。首先，我们将实现一个近似的距离计算，然后探讨哈弗赛恩公式（Haversine formula）和文森蒂公式（Vincenty formula），它们提供了更高的精度。

2. 圆柱投影距离近似

我们从圆柱投影距离近似开始。由于这个公式使用最少的数学运算，它非常快速：

double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
    double lat1Rad = Math.toRadians(lat1);
    double lat2Rad = Math.toRadians(lat2);
    double lon1Rad = Math.toRadians(lon1);
    double lon2Rad = Math.toRadians(lon2);

    double x = (lon2Rad - lon1Rad) * Math.cos((lat1Rad + lat2Rad) / 2);
    double y = (lat2Rad - lat1Rad);
    double distance = Math.sqrt(x * x + y * y) * EARTH_RADIUS;

    return distance;
}

其中，EARTH_RADIUS是一个常数，等于6371公里，这是地球半径的一个良好近似值。

尽管看起来简单，但圆柱投影近似在计算长距离时并不十分准确。实际上，它将地球视为完美的球体，并将球体映射到矩形网格上。

3. 使用哈弗赛恩公式计算距离

接下来，我们将研究哈弗赛恩公式。同样，它也假设地球是完美的球体。然而，它在计算长距离间的距离时更为精确。

此外，哈弗赛恩公式基于球面哈弗赛恩定律：

double haversine(double val) {
    return Math.pow(Math.sin(val / 2), 2);
}

然后，我们可以使用这个辅助函数来实现计算距离的方法：

double calculateDistance(double startLat, double startLong, double endLat, double endLong) {

    double dLat = Math.toRadians((endLat - startLat));
    double dLong = Math.toRadians((endLong - startLong));

    startLat = Math.toRadians(startLat);
    endLat = Math.toRadians(endLat);

    double a = haversine(dLat) + Math.cos(startLat) * Math.cos(endLat) * haversine(dLong);
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

    return EARTH_RADIUS * c;
}

尽管它提高了计算的准确性，但它仍然假设地球是一个扁平的形状。

4. 使用文森蒂公式计算距离

最后，如果我们想要最高精度，就必须使用文森蒂公式。具体来说，文森蒂公式通过迭代计算直到达到可接受的误差。此外，它还考虑了地球的椭球形状。

首先，公式需要一些常数，描述地球的椭球模型：

double SEMI_MAJOR_AXIS_MT = 6378137;
double SEMI_MINOR_AXIS_MT = 6356752.314245;
double FLATTENING = 1 / 298.257223563;
double ERROR_TOLERANCE = 1e-12;

ERROR_TOLERANCE代表我们愿意接受的误差。接着，我们将使用这些值在文森蒂公式中：

double calculateDistance(double latitude1, double longitude1, double latitude2, double longitude2) {
    double U1 = Math.atan((1 - FLATTENING) * Math.tan(Math.toRadians(latitude1)));
    double U2 = Math.atan((1 - FLATTENING) * Math.tan(Math.toRadians(latitude2)));

    double sinU1 = Math.sin(U1);
    double cosU1 = Math.cos(U1);
    double sinU2 = Math.sin(U2);
    double cosU2 = Math.cos(U2);

    double longitudeDifference = Math.toRadians(longitude2 - longitude1);
    double previousLongitudeDifference;

    double sinSigma, cosSigma, sigma, sinAlpha, cosSqAlpha, cos2SigmaM;

    do {
        sinSigma = Math.sqrt(Math.pow(cosU2 * Math.sin(longitudeDifference), 2) +
            Math.pow(cosU1 * sinU2 - sinU1 * cosU2 * Math.cos(longitudeDifference), 2));
        cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * Math.cos(longitudeDifference);
        sigma = Math.atan2(sinSigma, cosSigma);
        sinAlpha = cosU1 * cosU2 * Math.sin(longitudeDifference) / sinSigma;
        cosSqAlpha = 1 - Math.pow(sinAlpha, 2);
        cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha;
        if (Double.isNaN(cos2SigmaM)) {
            cos2SigmaM = 0;
        }
        previousLongitudeDifference = longitudeDifference;
        double C = FLATTENING / 16 * cosSqAlpha * (4 + FLATTENING * (4 - 3 * cosSqAlpha));
        longitudeDifference = Math.toRadians(longitude2 - longitude1) + (1 - C) * FLATTENING * sinAlpha *
            (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * Math.pow(cos2SigmaM, 2))));
    } while (Math.abs(longitudeDifference - previousLongitudeDifference) > ERROR_TOLERANCE);

    double uSq = cosSqAlpha * (Math.pow(SEMI_MAJOR_AXIS_MT, 2) - Math.pow(SEMI_MINOR_AXIS_MT, 2)) / Math.pow(SEMI_MINOR_AXIS_MT, 2);

    double A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
    double B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));

    double deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * Math.pow(cos2SigmaM, 2))
        - B / 6 * cos2SigmaM * (-3 + 4 * Math.pow(sinSigma, 2)) * (-3 + 4 * Math.pow(cos2SigmaM, 2))));

    double distanceMt = SEMI_MINOR_AXIS_MT * A * (sigma - deltaSigma);
    return distanceMt / 1000;
}

这个公式计算量较大。因此，当精度是目标时，我们可能希望使用它。否则，我们将继续使用哈弗赛恩公式。

5. 测试准确性

最后，我们可以测试我们上面看到的所有方法的准确性：

double lat1 = 40.714268; // New York
double lon1 = -74.005974;
double lat2 = 34.0522; // Los Angeles
double lon2 = -118.2437;

double equirectangularDistance = EquirectangularApproximation.calculateDistance(lat1, lon1, lat2, lon2);
double haversineDistance = HaversineDistance.calculateDistance(lat1, lon1, lat2, lon2);
double vincentyDistance = VincentyDistance.calculateDistance(lat1, lon1, lat2, lon2);

double expectedDistance = 3944;
assertTrue(Math.abs(equirectangularDistance - expectedDistance) < 100);
assertTrue(Math.abs(haversineDistance - expectedDistance) < 10);
assertTrue(Math.abs(vincentyDistance - expectedDistance) < 0.5);

在上面，我们计算了纽约和洛杉矶之间的距离，并评估了其精度以千米为单位。

6. 总结

在这篇文章中，我们在Java中介绍了三种计算两点间地理坐标距离的方法。我们从最不精确的圆柱投影近似开始，然后查看了更准确的哈弗赛恩公式，最后使用了最准确的文森蒂公式。

如往常一样，示例代码可在GitHub上找到。

Persistence

REST

Security