Java计算经纬度距离的示例代码

public class GeoDistanceCalculator {
 
    public static double haversineDistance(double lat1, double lon1, double lat2, double lon2) {
        final int EARTH_RADIUS_METERS = 6371000;
 
        double dLat = Math.toRadians(lat2 - lat1);
        double dLon = Math.toRadians(lon2 - lon1);
 
        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                   Math.cos(Math.toRadians(lat1)) * 
                   Math.cos(Math.toRadians(lat2)) *
                   Math.sin(dLon / 2) * Math.sin(dLon / 2);
 
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        return EARTH_RADIUS_METERS * c;
    }
 
    public static void main(String[] args) {
        double distance = haversineDistance(40.7128, -74.0060, 34.0522, -118.2437);
        System.out.println("距离：" + distance + " 米"); // 输出约 3933476 米
    }
}

public static double sphericalCosineLaw(double lat1, double lon1, double lat2, double lon2) {
    final int EARTH_RADIUS_METERS = 6371000;
 
    double lat1Rad = Math.toRadians(lat1);
    double lat2Rad = Math.toRadians(lat2);
    double dLon = Math.toRadians(lon2 - lon1);
 
    double distance = Math.acos(
        Math.sin(lat1Rad) * Math.sin(lat2Rad) +
        Math.cos(lat1Rad) * Math.cos(lat2Rad) * Math.cos(dLon)
    ) * EARTH_RADIUS_METERS;
 
    return distance;
}

public static double vincentyDistance(double lat1, double lon1, double lat2, double lon2) {
    final double a = 6378137.0; // 赤道半径（米）
    final double b = 6356752.314245; // 极半径（米）
    final double f = 1 / 298.257223563; // 扁率
 
    double L = Math.toRadians(lon2 - lon1);
    double U1 = Math.atan((1 - f) * Math.tan(Math.toRadians(lat1)));
    double U2 = Math.atan((1 - f) * Math.tan(Math.toRadians(lat2)));
 
    double sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
    double sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
 
    double lambda = L, lambdaPrev;
    double sinSigma, cosSigma, sigma, sinAlpha, cosSqAlpha, C;
    int maxIterations = 200;
 
    do {
        double sinLambda = Math.sin(lambda), cosLambda = Math.cos(lambda);
        sinSigma = Math.sqrt(
            (cosU2 * sinLambda) * (cosU2 * sinLambda) +
            (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) * 
            (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
        );
        if (sinSigma == 0) return 0; // 重合点
 
        cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
        sigma = Math.atan2(sinSigma, cosSigma);
        sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
        cosSqAlpha = 1 - sinAlpha * sinAlpha;
        C = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
        lambdaPrev = lambda;
        lambda = L + (1 - C) * f * sinAlpha * 
            (sigma + C * sinSigma * (cosSigma + C * cosSigma * (-1 + 2 * C * cosSigma * cosSigma)));
    } while (Math.abs(lambda - lambdaPrev) > 1e-12 && --maxIterations > 0);
 
    double uSq = cosSqAlpha * (a * a - b * b) / (b * b);
    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 * (cosSigma + B / 4 * 
        (cosSigma * (-1 + 2 * B * cosSigma * cosSigma) - 
         B / 6 * cosSigma * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cosSigma * cosSigma)));
 
    return b * A * (sigma - deltaSigma);
}

import android.location.Location;
 
public static float androidLocationDistance(double lat1, double lon1, double lat2, double lon2) {
    Location location1 = new Location("point1");
    location1.setLatitude(lat1);
    location1.setLongitude(lon1);
 
    Location location2 = new Location("point2");
    location2.setLatitude(lat2);
    location2.setLongitude(lon2);
 
    return location1.distanceTo(location2); // 返回米
}

public static double polarApproximation(double lat1, double lon1, double lat2, double lon2) {
    final int EARTH_RADIUS_METERS = 6371000;
 
    double dLat = Math.toRadians(lat2 - lat1);
    double dLon = Math.toRadians(lon2 - lon1);
    double avgLat = Math.toRadians((lat1 + lat2) / 2);
 
    double x = dLon * Math.cos(avgLat);
    double y = dLat;
    return Math.sqrt(x * x + y * y) * EARTH_RADIUS_METERS;
}

import math
 
def haversine_distance(lat1, lon1, lat2, lon2):
    # 地球半径，单位：公里
    R = 6371.0
    
    # 将经纬度转换为弧度
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)
    
    # 计算差值
    dlat = lat2_rad - lat1_rad
    dlon = lon2_rad - lon1_rad
    
    # Haversine公式
    a = math.sin(dlat / 2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon / 2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    
    distance = R * c
    return distance
 
# 示例使用
lat1, lon1 = 34.052235, -118.243683  # 洛杉矶的经纬度
lat2, lon2 = 40.712776, -74.005974   # 纽约的经纬度
 
distance = haversine_distance(lat1, lon1, lat2, lon2)
print(f"Distance using Haversine formula: {distance} km")

pip install geographiclib
from geographiclib.geodesic import Geodesic
 
def vincenty_distance(lat1, lon1, lat2, lon2):
    geod = Geodesic.WGS84  # 使用WGS84椭球体模型
    result = geod.Inverse(lat1, lon1, lat2, lon2)
    distance = result['s12'] / 1000.0  # 距离单位：公里
    return distance
 
# 示例使用
lat1, lon1 = 34.052235, -118.243683  # 洛杉矶的经纬度
lat2, lon2 = 40.712776, -74.005974   # 纽约的经纬度
 
distance = vincenty_distance(lat1, lon1, lat2, lon2)
print(f"Distance using Vincenty formula: {distance} km")

pip install geopy
from geopy.distance import geodesic
 
def calculate_distance_with_geopy(lat1, lon1, lat2, lon2):
    # 定义两个点
    point1 = (lat1, lon1)
    point2 = (lat2, lon2)
    
    # 计算两点之间的距离
    distance = geodesic(point1, point2).kilometers
    return distance
 
# 示例使用
lat1, lon1 = 34.052235, -118.243683  # 洛杉矶的经纬度
lat2, lon2 = 40.712776, -74.005974   # 纽约的经纬度
 
distance = calculate_distance_with_geopy(lat1, lon1, lat2, lon2)
print(f"Distance using Vincenty formula: {distance} km")