Java 降低复杂性。找到最近的一对纬度和经度

我有两个阵列代表两个不同的GPS路径。每个阵列包含偶数指数中的纬度（从0开始）和奇数指数中的经度，如下所示：

48.855002219371706,2.3472976684570312,48.855050000000006,2.34735,48.85508,2.3473200000000003,48.85584,2.3477300000000003,48.8562,2.3465000000000003,...

我想计算这两条路径最近点之间的距离之和。我用哈弗森方法计算纬度和经度对之间的距离

这就是我要做的：我搜索当前数组中距离最小的一对纬度和经度。然后我将最小距离添加到一个变量中，该变量将所有最小距离相加。然后，我从数组中移除经纬度

代码如下：

public class Distance {

private String filename1;
private String filename2;

public Distance(String filename1, String filename2) {
    this.filename1 = filename1;
    this.filename2 = filename2;
}

public double distance() {
    if(this.filename1.equals(this.filename2))
        return 0;
    double distance = 0;
    BufferedReader br1 = null;
    BufferedReader br2 = null;
    try {
        br1 = new BufferedReader(new FileReader("files/" + this.filename1));
        br2 = new BufferedReader(new FileReader("files/" + this.filename2));
        String []data1 = br1.readLine().split(",");
        String []data2 = br2.readLine().split(",");
        System.out.println("Number of points in " + this.filename1 + " = " + data1.length/2);
        System.out.println("Number of points in " + this.filename2 + " = " + data2.length/2);

        while((isPresent(data1)) && (isPresent(data2))) {
            int posi = -1;
            int posj = -1;
            double minD = Double.MAX_VALUE;

            for(int i = 0; i < data1.length; i+=2) {
                if(!data1[i].equals("-9999")) {
                    double lat1 = Double.parseDouble(data1[i]);
                    double lon1 = Double.parseDouble(data1[i+1]);

                for(int j = 0; j < data2.length; j+=2) {
                    if(!data2[j].equals("-9999")) {
                        double lat2 = Double.parseDouble(data2[j]);
                        double lon2 = Double.parseDouble(data2[j+1]);
                        double d = getDistance(lat1, lon1, lat2, lon2);
                        if(minD > d) {

                            minD = d;
                            posi = i;
                            posj = j;
                        }
                    }
                }
              }
            }
            if(posi != -1){
            data1[posi] = data1[posi+1] = data2[posj] = data2[posj+1] = "-9999";
            distance += minD;
            }
        }
    } catch (FileNotFoundException e) {

        e.printStackTrace();
    } catch (IOException e) {

        e.printStackTrace();
    } finally {
        if(br1 != null) {
            try {
                br1.close();
            } catch (IOException e) {

                e.printStackTrace();
            }
        }
        if(br2 != null) {
            try {
                br2.close();
            } catch (IOException e) {

                e.printStackTrace();
            }
        }
    }
    return distance;
}

private boolean isPresent(String arr[]) {

    for(int i = 0; i < arr.length; i+=2) {
        if(!arr[i].equals("-9999"))
            return true;
    }
    return false;
}

private double getDistance(double lat1, double lon1, double lat2,
        double lon2) {

    double R = 6378.1; // Radius of the earth in km
      double dLat = deg2rad(lat2-lat1);  // deg2rad below
      double dLon = deg2rad(lon2-lon1); 
      double a = 
        Math.sin(dLat/2) * Math.sin(dLat/2) +
        Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * 
        Math.sin(dLon/2) * Math.sin(dLon/2)
        ; 
      double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); 
      double d = R * c; // Distance in km
      return d*1000;
}

private double deg2rad(double d) {

    return d * (Math.PI/180);
 }
}

公共类距离{
私有字符串filename1；
私有字符串文件名2；
公共距离（字符串文件名1、字符串文件名2）{
this.filename1=filename1；
this.filename2=filename2；
}
公共双倍距离（）{
if（this.filename1.equals（this.filename2））
返回0；
双倍距离=0；
BufferedReader br1=null；
BufferedReader br2=null；
试一试{
br1=新的BufferedReader（新的文件读取器（“files/”+this.filename1））；
br2=新的BufferedReader（新的文件读取器（“files/”+this.filename2））；
字符串[]data1=br1.readLine（）.split（“，”）；
字符串[]data2=br2.readLine（）.split（“，”）；
System.out.println（“中的点数”+this.filename1+“=”+data1.length/2）；
System.out.println（“在“+this.filename2+”=“+data2.length/2”中的点数）；
而（（isPresent（data1））和&（isPresent（data2）））{
int posi=-1；
int posj=-1；
双心=双最大值；
对于（int i=0；id）{
思维=d；
posi=i；
posj=j；
}
}
}
}
}
if（posi！=-1）{
data1[posi]=data1[posi+1]=data2[posj]=data2[posj+1]=“-9999”；
距离+=心灵；
}
}
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}最后{
如果（br1！=null）{
试一试{
br1.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
如果（br2！=null）{
试一试{
br2.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
返回距离；
}
私有布尔值isPresent（字符串arr[]）{
对于（int i=0；i

你认为这样做很笨拙吗？ 我怎样才能很快做到

N.B.我已经看到了，但不知道如何使用纬度和经度来实现它，以便比较两个不同阵列之间的点。

希望这会有所帮助

输入：包含纬度和经度数据的文件
从第一个文件

• 根据纬度对所有值进行排序，并将其存储在数组中

• 根据经度对所有值进行排序，并将其存储在第二个数组中

数组的输入大小为n和m
现在，从第二个数组中选择一个点，并使用此
对所有点重复此操作并打印最小值

对每个数组进行排序O（nlogn）*2=O（nlogn） 找到最近点的距离不超过O（2m）

因为数组长度是已知的。请使用大数组并将其用于n个大小的数组操作

---

如果其中一个文件已修复，则可以重复使用