Question

我有两个数组。一个代表x坐标，另一个代表y坐标（例如）。

double[]xcoordinate={2.3,1.2,3.3,5.5,2.3,1.3,7.9,1.2,3.3,3.3,5.2};
double[]ycoordinate={5.4,2.2,4.4,6.6,5.4,1.9,5.2,2.2,3.5,4.4,4.2};

如果x [i] == x [i + 1] && y [i] == y [i + 1]，则发现我的程序写匹配。

在我的示例中，xcoordinate [0] == xco0rdinate [4]和ycoordinate [0] == ycoordinate [4]这样它写了Match找到了。它们是成对的数据集。像x [0]，y [0]代表点x [1]，y [1]代表点，x [2]，y [2]代表点..依此类推。因此，按照我的定义，x [0]，y [0]和x [4]，y [4]表示同一点。

现在，我想执行这样的检查。首先，x [0]与x [1]匹配。然后，x [2]数据将在循环迭代时出现。现在x [2]寻找与x [1]和x [0]的匹配，然后在下一次迭代x [3]寻找与x [2]，x [1]，x [0]的匹配，依此类推。 y数据集也发生了同样的事情。

到目前为止，我写下了一个代码

public class Arraymatch2 {
public static void main(String args[]){
    double[]xcoordinate={2.3,1.2,3.3,5.5,2.3,1.3,7.9,1.2,3.3,3.3,5.2};
    double[]ycoordinate={5.4,2.2,4.4,6.6,5.4,1.9,5.2,2.2,3.5,4.4,4.2};

    int k=0;

    for(int i=0;i<xcoordinate.length-1;i++)
    {
        double xcoordinate1 = xcoordinate[i];
        double ycoordinate1=ycoordinate[i];
        for(int j=i+1;j<xcoordinate.length;j++) {
            double xcoordinate2 = xcoordinate[j];
            double ycoordinate2 = ycoordinate[j];
            if ((xcoordinate1 == xcoordinate2) && (ycoordinate1 ==ycoordinate2)) {
               Match found
            }
            else {
                No match

            }
        }
    }

}

}

但是此代码的问题是用x [1]检查x [0]，然后用x [2]检查x [0]，然后用x [3]检查x [0]，然后用x [0] x [4]，然后找到一个匹配项并记下匹配项，而不是用x [1]检查x [0]，然后用x [1]检查x [2]，x [0]然后用x [3]检查x [3] 2]，x [1]，x [0]等。需要进行此中间检查是因为说x [2]和x [3]之间存在匹配项。

我应该在哪里更改代码以实现这种检查？

Answer 1

import java.util.*;

public class Test {
    public static void main(String[] args) {
        Point [] points = {new Point(2.3, 5.3), new Point(1.2, 2.2), new Point(3.3, 4.4), new Point(5.5, 6.6), new Point(2.3, 5.4),
        new Point(1.3, 1.9), new Point(7.9, 5.2)};
        Set<Point> set = new HashSet<>(Arrays.asList(points));
        Map<Point, Integer> map = new HashMap<>();
        for(Point point : set){
            for(int i = 0; i < points.length; i++){
                if(point.compareTo(points[i]) == 0){
                    map.put(point, i );
                }
            }
        }
    }
}

class Point implements Comparable{
    private double x, y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Point){
            if(((Point) o).getX() == this.x && ((Point) o).getY() == this.y){
                //Two Points are identicall
                return 0;
            }else{
                return -1;
            }
        }else{
            return -1;
        }
    }
}

我建议使用实现接口COmparable的外部数据结构。

此外，您可以对每个点进行设置并找出可能存在的匹配项，并使用HashMap映射这些匹配项

基于循环的数组检查未在Java

1 个答案: