Java 使用可比较类保留2D Arraylist的原始索引

我有一个arraylist的arraylist，它存储点之间的距离。在对arraylist排序之后，我需要保留距离的原始索引，因为我需要在代码的后期找到K-最近邻。我实现的类不会输出正确的距离索引，而只输出ArrayList索引

我曾尝试实现一个2D可比类，但出现了一些错误

public staticArrayList<ArrayList<Double>>distance(ArrayList<sample_points> points) {

    ArrayList<ArrayList<Double>> distArray = new ArrayList<ArrayList<Double>>(points.size());
    double dist = 0;
    List<Element> elements = new ArrayList<Element>();
    for(int i = 0; i<points.size()-1; i++) {
        ArrayList<Double> distances = new ArrayList<Double>();
        for(int j=i+1; j<points.size(); j++){
            // do your calculations here
            dist = Math.sqrt(Math.pow(points.get(i).getX() - points.get(j).getX(), 2) 
                    + Math.pow(points.get(i).getY() - points.get(j).getY(), 2));   
            distances.add(dist);// add the distance to the current distances list
        }
        distArray.add(distances);//
    }
    System.out.print("Distances: "distArray);
    System.out.println();
    for(int i = 0; i < distArray.size(); i++) {
        for (int j = 0; j < distArray.get(i).size(); j++) {
            elements.add(new Element(i, distArray.get(i).get(j)));
        }
    }
    Collections.sort(elements);
    for(int i = 0; i < elements.size(); i++) {
        System.out.println("Dist "+ elements.get(i).distance + " " 
                + "Index " + elements.get(i).index+" ");
    }
}

实际结果：

Distances: [[2.8284271247461903, 5.830951894845301, 7.280109889280518], 
[3.1622776601683795, 5.0], [2.23606797749979]]

Dist 2.23606797749979 Index 2 
Dist 2.8284271247461903 Index 0 
Dist 3.1622776601683795 Index 1 
Dist 5.0 Index 1 
Dist 5.830951894845301 Index 0 
Dist 7.280109889280518 Index 0

---

在检查代码时，我认为错误在于您的假设，而输出本身实际上是正确的。您看到的索引实际上是您在此处创建的列表嵌套数组列表中外部列表的索引：

for (int i=0; i<points.size()-1; i++) {
    ArrayList<Double> distances = new ArrayList<Double>();
    for (int j=i+1; j < points.size(); j++) {
        // do your calculations here
        dist = Math.sqrt(Math.pow(points.get(i).getX() - points.get(j).getX(), 2) 
                + Math.pow(points.get(i).getY() - points.get(j).getY(), 2));   
        distances.add(dist); // add the distance to the current distances list
    }
    distArray.add(distances);  //  ***** the index of items added here *****
}

---

旁注：将来，创建一个最小的可运行程序来演示问题，我们可以轻松编译和运行。对于这个问题，我必须自己创建一个：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Foo01 {

    public static void main(String[] args) {
        List<SamplePoints> points = new ArrayList<>();

        int maxXY = 100;
        int max = 4;
        for (int i = 0; i < max; i++) {
            int x = (int) (maxXY * Math.random());
            int y = (int) (maxXY * Math.random());
            points.add(new SamplePoints(x, y));
        }

        distance(points);
    }

    private static class SamplePoints {
        private int x;
        private int y;

        public SamplePoints(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

    }

    private static class Element implements Comparable<Element> {
        public final int index;
        public final double distance;

        public Element(int index, double distance) {
            this.index = index;
            this.distance = distance;
        }

        @Override
        public int compareTo(Element e) {
            return Double.valueOf(this.distance).compareTo(Double.valueOf(e.distance));
        }
    }

    public static void distance(List<SamplePoints> points) {

        ArrayList<ArrayList<Double>> distArray = new ArrayList<ArrayList<Double>>(points.size());
        double dist = 0;
        List<Element> elements = new ArrayList<Element>();
        for (int i = 0; i < points.size() - 1; i++) {
            ArrayList<Double> distances = new ArrayList<Double>();
            for (int j = i + 1; j < points.size(); j++) {
                // do your calculations here
                dist = Math.sqrt(Math.pow(points.get(i).getX() - points.get(j).getX(), 2)
                        + Math.pow(points.get(i).getY() - points.get(j).getY(), 2));
                distances.add(dist);// add the distance to the current distances
                                    // list
            }
            distArray.add(distances);//

            System.out.println(distArray.indexOf(distances));
            System.out.println(distances);
            System.out.println();

        }
        System.out.print("Distances: " + distArray);
        System.out.println();
        for (int i = 0; i < distArray.size(); i++) {
            for (int j = 0; j < distArray.get(i).size(); j++) {
                elements.add(new Element(i, distArray.get(i).get(j)));
            }
        }
        Collections.sort(elements);
        for (int i = 0; i < elements.size(); i++) {
            System.out.println("Dist " + elements.get(i).distance + " " + "Index "
                    + elements.get(i).index + " ");
        }
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公开课Foo01{
公共静态void main（字符串[]args）{
列表点=新的ArrayList（）；
int maxXY=100；
int max=4；
对于（int i=0；i

---

但在将来，你会希望这样做，以帮助你的问题更容易回答

考虑设置所有左对齐代码的格式。如果它更容易阅读，也更容易理解。好的，我已经尝试为您格式化代码和输出，但在将来，如果您在发布问题时自己这样做，我们都会非常感激。非常感谢，我是新来的堆栈溢出请容忍我你似乎没有正确地调试东西-为什么不打印出索引，何时何地创建它们？在我看来，这似乎是最有可能出错的代码，而不是您的排序代码。谢谢，我需要获取arraylist中距离的索引值，而不是外部arraylist的索引。@D.Khumalo:请更详细、更清晰地解释您需要的，@D.Khumalo:请参见编辑：您的索引字段是不可变的，并且您在对任何项目进行排序之前就设置了它，因此它永远无法表示您希望它表示的内容。如果我有一个距离的二维数组列表，即[[d1，d2，d3]，[d4，d5]，[d6]]。指数如下：d1=0、d2=1、d3=2、d4=0、d5=1和d6=0。因此，在对每个arraylist排序之后，我需要获得前面提到的原始索引。@D.Khumalo：然后使用

j

创建索引，而不是

I

。请参见编辑。

for (int i=0; i<points.size()-1; i++) {
    ArrayList<Double> distances = new ArrayList<Double>();
    for (int j=i+1; j < points.size(); j++) {
        // do your calculations here
        dist = Math.sqrt(Math.pow(points.get(i).getX() - points.get(j).getX(), 2) 
                + Math.pow(points.get(i).getY() - points.get(j).getY(), 2));   
        distances.add(dist); // add the distance to the current distances list
    }
    distArray.add(distances);  //  ***** the index of items added here *****
}

for (int i=0; i < points.size()-1; i++) {
    ArrayList<Double> distances = new ArrayList<Double>();
    for (int j=i+1; j<points.size(); j++) {
        // do your calculations here
        dist = Math.sqrt(Math.pow(points.get(i).getX() - points.get(j).getX(), 2) 
                + Math.pow(points.get(i).getY() - points.get(j).getY(), 2));   
        distances.add(dist);// add the distance to the current distances list
    }
    distArray.add(distances);  //  ***** the index of items added here *****

    // ******* add this  ********
    System.out.println(distArray.indexOf(distances));
    System.out.println(distances);
    System.out.println();
}

for(int i = 0; i < distArray.size(); i++) {
    for (int j = 0; j < distArray.get(i).size(); j++) {
        // elements.add(new Element(i, distArray.get(i).get(j)));
        elements.add(new Element(j, distArray.get(i).get(j))); // ***** note change *****
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Foo01 {

    public static void main(String[] args) {
        List<SamplePoints> points = new ArrayList<>();

        int maxXY = 100;
        int max = 4;
        for (int i = 0; i < max; i++) {
            int x = (int) (maxXY * Math.random());
            int y = (int) (maxXY * Math.random());
            points.add(new SamplePoints(x, y));
        }

        distance(points);
    }

    private static class SamplePoints {
        private int x;
        private int y;

        public SamplePoints(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

    }

    private static class Element implements Comparable<Element> {
        public final int index;
        public final double distance;

        public Element(int index, double distance) {
            this.index = index;
            this.distance = distance;
        }

        @Override
        public int compareTo(Element e) {
            return Double.valueOf(this.distance).compareTo(Double.valueOf(e.distance));
        }
    }

    public static void distance(List<SamplePoints> points) {

        ArrayList<ArrayList<Double>> distArray = new ArrayList<ArrayList<Double>>(points.size());
        double dist = 0;
        List<Element> elements = new ArrayList<Element>();
        for (int i = 0; i < points.size() - 1; i++) {
            ArrayList<Double> distances = new ArrayList<Double>();
            for (int j = i + 1; j < points.size(); j++) {
                // do your calculations here
                dist = Math.sqrt(Math.pow(points.get(i).getX() - points.get(j).getX(), 2)
                        + Math.pow(points.get(i).getY() - points.get(j).getY(), 2));
                distances.add(dist);// add the distance to the current distances
                                    // list
            }
            distArray.add(distances);//

            System.out.println(distArray.indexOf(distances));
            System.out.println(distances);
            System.out.println();

        }
        System.out.print("Distances: " + distArray);
        System.out.println();
        for (int i = 0; i < distArray.size(); i++) {
            for (int j = 0; j < distArray.get(i).size(); j++) {
                elements.add(new Element(i, distArray.get(i).get(j)));
            }
        }
        Collections.sort(elements);
        for (int i = 0; i < elements.size(); i++) {
            System.out.println("Dist " + elements.get(i).distance + " " + "Index "
                    + elements.get(i).index + " ");
        }
    }
}