Java 如何比较列表和方法中的值？

我有一个LinkedList，其中包含我需要处理的不同类型的数据，以便进行比较并添加符合范围的值。下面将给出更多解释

LinkedList

中填充了记录类的数据：

class Record {
    public int id;
    public Point location; 
    public double score; 
    (...)
}

class Point {
    public double x, y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public double dist(Point p) {
        return Math.sqrt((this.x-p.x)*(this.x-p.x)+(this.y-p.y)*(this.y-p.y));
    }

class RankList {

    private Node first;
    private int nodeCount;
    private Record record;

    public static void main(String[] args) {
        RankList list = new RankList();
        Point point = new Point(5.4, 3.2);
        Record record = new Record(1, point, 8.2);
        System.out.println(list.insert(record));
        double maxDist=point.dist(point);

        Point point1 = new Point(1.4, 9.2);
        Record record1 = new Record(2, point1, 7.5);
        if((point1.dist(point)>maxDist)) maxDist=point1.dist(point);
        System.out.println(list.insert(record1));

        Point point2 = new Point(2.2, 1.2);
        Record record2 = new Record(3, point2, 6.0);
        if((point2.dist(point1)>maxDist)) maxDist=point2.dist(point1);
        System.out.println(list.insert(record2));
        list.nearest(point1,maxDist);

public RankList nearest (Point p,double maxDist){
            RankList nearList = new RankList();
            Node current = first;
            System.out.print("HEAD -> ");
            while (current != null) {
                System.out.print(current);
                System.out.print(" -> ");
                current = current.getNext();
            }
            System.out.println("null");
            return null;
       }

点类：

class Record {
    public int id;
    public Point location; 
    public double score; 
    (...)
}

class Point {
    public double x, y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public double dist(Point p) {
        return Math.sqrt((this.x-p.x)*(this.x-p.x)+(this.y-p.y)*(this.y-p.y));
    }

class RankList {

    private Node first;
    private int nodeCount;
    private Record record;

    public static void main(String[] args) {
        RankList list = new RankList();
        Point point = new Point(5.4, 3.2);
        Record record = new Record(1, point, 8.2);
        System.out.println(list.insert(record));
        double maxDist=point.dist(point);

        Point point1 = new Point(1.4, 9.2);
        Record record1 = new Record(2, point1, 7.5);
        if((point1.dist(point)>maxDist)) maxDist=point1.dist(point);
        System.out.println(list.insert(record1));

        Point point2 = new Point(2.2, 1.2);
        Record record2 = new Record(3, point2, 6.0);
        if((point2.dist(point1)>maxDist)) maxDist=point2.dist(point1);
        System.out.println(list.insert(record2));
        list.nearest(point1,maxDist);

public RankList nearest (Point p,double maxDist){
            RankList nearList = new RankList();
            Node current = first;
            System.out.print("HEAD -> ");
            while (current != null) {
                System.out.print(current);
                System.out.print(" -> ");
                current = current.getNext();
            }
            System.out.println("null");
            return null;
       }

RankList类：

class Record {
    public int id;
    public Point location; 
    public double score; 
    (...)
}

class Point {
    public double x, y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public double dist(Point p) {
        return Math.sqrt((this.x-p.x)*(this.x-p.x)+(this.y-p.y)*(this.y-p.y));
    }

class RankList {

    private Node first;
    private int nodeCount;
    private Record record;

    public static void main(String[] args) {
        RankList list = new RankList();
        Point point = new Point(5.4, 3.2);
        Record record = new Record(1, point, 8.2);
        System.out.println(list.insert(record));
        double maxDist=point.dist(point);

        Point point1 = new Point(1.4, 9.2);
        Record record1 = new Record(2, point1, 7.5);
        if((point1.dist(point)>maxDist)) maxDist=point1.dist(point);
        System.out.println(list.insert(record1));

        Point point2 = new Point(2.2, 1.2);
        Record record2 = new Record(3, point2, 6.0);
        if((point2.dist(point1)>maxDist)) maxDist=point2.dist(point1);
        System.out.println(list.insert(record2));
        list.nearest(point1,maxDist);

public RankList nearest (Point p,double maxDist){
            RankList nearList = new RankList();
            Node current = first;
            System.out.print("HEAD -> ");
            while (current != null) {
                System.out.print(current);
                System.out.print(" -> ");
                current = current.getNext();
            }
            System.out.println("null");
            return null;
       }

我在列表中插入了一些值，假设给定点之间有一些距离值，如：

Distance between two points:
A->B = 3.2455
B->C = 7.345 
C->D = 2.111 
D->E = 8.056

由此可知，

maxDist

值为8.059

---

现在我必须编写方法

public RankList nearest（点p，double maxDist）

，它查找范围之间的所有距离值（我对您的代码有点困惑。我在其中找不到任何

LinkedList

。您的类

RankList

似乎只有三个字段，并且没有一个是列表类型的。我不确定

insert

方法做什么

使用

main

方法在类中包含字段不是最好的主意。如果您准备另一个运行该程序的类会更好

我想展示一下如何编写代码：

import java.util.Comparator;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

class Main {

    public static void main(String[] args) {
        // I don't want the list to be a field of the class.
        RecordsList list = new RecordsList();

        // Following code blocks could be extracted as separate methods
        Point point = new Point(5.4, 3.2);
        Record record = new Record(1, point, 8.2);
        list.add(record);
        double maxDist = point.dist(point);

        Point point1 = new Point(1.4, 9.2);
        Record record1 = new Record(2, point1, 7.5);
        if((point1.dist(point)>maxDist)) maxDist=point1.dist(point);
        list.add(record1);

        Point point2 = new Point(2.2, 1.2);
        Record record2 = new Record(3, point2, 6.0);
        if((point2.dist(point1)>maxDist)) maxDist=point2.dist(point1);
        list.add(record2);

        Point farPoint = new Point(50, 50);
        Record recordWithFarPoint = new Record(4, farPoint, 5);
        list.add(recordWithFarPoint);

        RecordsList nearestList = list.nearest(point1, 20);
        for (Record rec : nearestList.getList()) {
            System.out.println(rec.id + " " + rec.location.x + " " + rec.location.y + " " + rec.score);
        }
        /*
         * On console:
         * 2 1.4 9.2 7.5
         * 1 5.4 3.2 8.2
         * 3 2.2 1.2 6.0
         */
    }

}

/**
 * This class is so-called wrapper on ArrayList.
 */
class RecordsList {
    // This may be called delegate.
    private ArrayList<Record> list = new ArrayList<>();

    public void add(Record record) {
        this.list.add(record);
    }

    // This creates shallow copy.
    public ArrayList<Record> getList() {
        return new ArrayList<>(list);
    }

    public RecordsList nearest(Point p, double maxDistance) {
        RecordsList list = new RecordsList();

        List<Record> records = this.getList().stream()
                .sorted(Comparator.comparingDouble(oldListElement -> oldListElement.location.dist(p)))
                .filter(element -> element.location.dist(p) <= maxDistance)
                .collect(Collectors.toList());

        for (Record record : records) {
            list.add(record);
        }

        return list;
    }

}

class Record {
    public int id;
    public Point location;
    public double score;

    public Record(int id, Point location, double score) {
        this.id = id;
        this.location = location;
        this.score = score;
    }

}

class Point {

    public double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double dist(Point p) {
        return Math.sqrt((this.x - p.x) * (this.x - p.x) + (this.y - p.y) * (this.y - p.y));
    }

}

import java.util.Comparator；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.stream.collector；
班长{
公共静态void main（字符串[]args）{
//我不希望列表成为类的字段。
记录列表=新记录列表（）；
//以下代码块可以作为单独的方法提取
点=新点（5.4,3.2）；
记录=新记录（1，点，8.2）；
列表。添加（记录）；
双最大距离=点距离（点）；
点1=新点（1.4,9.2）；
记录1=新记录（2，点1，7.5）；
如果（（point1.dist（point）>maxDist））maxDist=point1.dist（point）；
列表。添加（记录1）；
点2=新点（2.2,1.2）；
记录2=新记录（3，点2，6.0）；
如果（（point2.dist（point1）>maxDist））maxDist=point2.dist（point1）；
列表。添加（记录2）；
点farPoint=新点（50,50）；
recordWithFarPoint=新记录（4，farPoint，5）；
列表。添加（recordWithFarPoint）；
RecordsList nearestList=最近的列表（点1,20）；
for（记录rec:nearestList.getList（））{
System.out.println（rec.id+“”+rec.location.x+“”+rec.location.y+“”+rec.score）；
}
/*
*在控制台上：
* 2 1.4 9.2 7.5
* 1 5.4 3.2 8.2
* 3 2.2 1.2 6.0
*/
}
}
/**
*此类是ArrayList上的所谓包装器。
*/
类记录列表{
//这可以称为委托。
private ArrayList list=new ArrayList（）；
公共作废添加（记录）{
此.列表.添加（记录）；
}
//这将创建浅拷贝。
公共ArrayList getList（）{
返回新的ArrayList（列表）；
}
公共记录列表最近（点p，双最大距离）{
记录列表=新记录列表（）；
列表记录=this.getList（）.stream（）
.sorted（Comparator.comparingDouble（oldListElement->oldListElement.location.dist（p）））
.filter（element->element.location.dist（p）什么是
RankList
类和
first
变量/字段？你能用
最近的方法粘贴整个类吗？@JakubBiernaczyk更新！