java Range类的这种实现有什么问题

Question

我有一个作业，我正在做一个电子表格，这是我的老师交给我的

我被要求实现一个名为Range的类，它接受两个位置（每个位置由表示列和行的两个整数组成，例如new Position（1,2）），然后找到最低的行和列，并构造一个包含这两个值的新位置，这个位置是我的范围的左上角，行和列的最大值也是如此

然后我被要求做一个类，它包含一系列位置的总和。所以我决定，在我的范围内，它应该能够有一个方法，将所有位置放入ArrayList，这就是getPositions（）方法

在这里您可以看到该类的源代码：

package spreadsheet;

import java.lang.Math;
import java.util.ArrayList;

public class Range {

    private Position a;
    private Position b;
    private ArrayList<Position> positionList;

    // Creates a new range, where it makes sure that the positions,
    // appear in the right order, where the first position is the position
    // of the upper left corner, and the second position is the lower right corner.
    public Range(final Position a, final Position b) {
        int minColumn = Math.min(a.getColumn(),b.getColumn());
        int minRow = Math.min(a.getRow(),b.getRow());

        int maxColumn = Math.max(a.getColumn(),b.getColumn());
        int maxRow = Math.max(a.getRow(),b.getRow());

        this.a = new Position(minColumn, minRow);
        this.b = new Position(maxColumn, maxRow);
        positionList = new ArrayList<>();       
    }


    public ArrayList<Position> getPositions() {
        int minColumn = this.a.getColumn();
        int minRow = this.a.getRow();
        int maxColumn = this.b.getColumn();
        int maxRow = this.b.getRow();
        for(int i = minColumn; i < maxColumn; i++) {
            for(int j = minRow; j < maxRow; j++) {
                positionList.add(new Position(i, j));
            }
        }
        return positionList;
    }   
}

但问题是它并没有真正起作用，它返回的列表是空的，这是为什么？有人能发现错误吗

Answer 1

我看没有理由不这样做。 好的，这里有几个问题：

• positionList = new ArrayList<>();将不会编译。它必须是positionList = new ArrayList<Position>();
• 正如乔达卡所说，当你第二次得到职位时，你会在列表中得到两次（当你称之为第四次时，会得到三次，以此类推）
• 您的实现将包括第一列和第一行，但不包括最后一行（在循环中尝试i <= maxColumn和j <= maxRow）

在我的测试中，我使用了点而不是位置，并为点添加了一些强制转换，使用int作为构造函数参数，但返回double。但我没有改变逻辑本身：

package spreadsheet;

import java.awt.Point;
import java.util.ArrayList;

public class Range {

private final Point a;
private final Point b;
private final ArrayList<Point> PointList;

// Creates a new range, where it makes sure that the Points,
// appear in the right order, where the first Point is the Point
// of the upper left corner, and the second Point is the lower right corner.
public Range(final Point a, final Point b) {
    int minColumn = (int) Math.min(a.getX(),b.getX());
    int minRow = (int) Math.min(a.getY(),b.getY());

    int maxColumn =(int)  Math.max(a.getX(),b.getX());
    int maxRow = (int) Math.max(a.getY(),b.getY());
    this.a = new Point(minColumn, minRow);
    this.b = new Point(maxColumn, maxRow);
    PointList = new ArrayList<Point>();
}

public ArrayList<Point> getPoints() {
    int minColumn = (int) a.getX();
    int minRow = (int) a.getY();
    int maxColumn = (int) b.getX();
    int maxRow = (int) b.getY();
    for (int i = minColumn; i < maxColumn; i++) {
        for (int j = minRow; j < maxRow; j++) {
            PointList.add(new Point(i, j));
        }
    }
    return PointList;
}

测试：

package spreadsheet;

import java.awt.Point;
import java.util.ArrayList;

import org.junit.Test;

    public class RangeTest {

    @Test
    public void testSomePoints() throws Exception {
        Range range = new Range(new Point(1, 1), new Point(5, 5));
        ArrayList<Point> points = range.getPoints();
        for (Point point : points) {
            System.out.println(point);
        }
    }
}

结果是：

java.awt.Point[x=1,y=1]
java.awt.Point[x=1,y=2]
java.awt.Point[x=1,y=3]
java.awt.Point[x=1,y=4]
java.awt.Point[x=2,y=1]
java.awt.Point[x=2,y=2]
java.awt.Point[x=2,y=3]
java.awt.Point[x=2,y=4]
java.awt.Point[x=3,y=1]
java.awt.Point[x=3,y=2]
java.awt.Point[x=3,y=3]
java.awt.Point[x=3,y=4]
java.awt.Point[x=4,y=1]
java.awt.Point[x=4,y=2]
java.awt.Point[x=4,y=3]
java.awt.Point[x=4,y=4]

编辑：

如果我再次调用getPoints（），我也会看到每个点两次。 创建一次列表，但每次调用getPoints（）时都会添加点

有几种可能性：

1. 可以在getPoints（）方法中而不是在构造函数中创建ArrayList。但通常情况下，你不会希望每次调用这个方法时都创建一个全新的列表
2. 您可以将列表存储在字段中，在构造函数中计算它，并仅使用返回字段的getter
3. 与第二种可能性类似，但您可以根据需要计算列表。因此，如果它现在为空，不要在构造函数中计算它，而是在getter中计算它，否则使用存储的列表

2。编辑

1. 选项：

   public class Range {
   
       private final Point a;
       private final Point b;
       private final ArrayList<Point> PointList;
   
       public Range(final Point a, final Point b) {
           int minColumn = (int) Math.min(a.getX(),b.getX());
           int minRow = (int) Math.min(a.getY(),b.getY());
   
           int maxColumn =(int)  Math.max(a.getX(),b.getX());
           int maxRow = (int) Math.max(a.getY(),b.getY());
           this.a = new Point(minColumn, minRow);
           this.b = new Point(maxColumn, maxRow);
       }
   
       public ArrayList<Point> getPoints() {
           PointList = new ArrayList<Point>();
           int minColumn = (int) a.getX();
           int minRow = (int) a.getY();
           int maxColumn = (int) b.getX();
           int maxRow = (int) b.getY();
           for (int i = minColumn; i < maxColumn; i++) {
               for (int j = minRow; j < maxRow; j++) {
                   PointList.add(new Point(i, j));
               }
           }
           return PointList;
       }
   }
   

2. 选项：

   public class Range {
   
       private final Point a;
       private final Point b;
       private final ArrayList<Point> PointList;
   
       public Range(final Point a, final Point b) {
           int minColumn = (int) Math.min(a.getX(),b.getX());
           int minRow = (int) Math.min(a.getY(),b.getY());
   
           int maxColumn =(int)  Math.max(a.getX(),b.getX());
           int maxRow = (int) Math.max(a.getY(),b.getY());
           this.a = new Point(minColumn, minRow);
           this.b = new Point(maxColumn, maxRow);
           PointList = calcPoints();
       }
   
       private ArrayList<Point> calcPoints() {
           ArrayList<Point> list = new ArrayList<Point>();
           int minColumn = (int) a.getX();
           int minRow = (int) a.getY();
           int maxColumn = (int) b.getX();
           int maxRow = (int) b.getY();
           for (int i = minColumn; i < maxColumn; i++) {
               for (int j = minRow; j < maxRow; j++) {
                   PointList.add(new Point(i, j));
               }
           }
           return list;
       }
   
       public ArrayList<Point> getPoints() {
           return PointList;
       }
   }
   

3. 选项：

   public class Range {
   
       private final Point a;
       private final Point b;
       private final ArrayList<Point> PointList;
   
       public Range(final Point a, final Point b) {
           int minColumn = (int) Math.min(a.getX(),b.getX());
           int minRow = (int) Math.min(a.getY(),b.getY());
   
           int maxColumn =(int)  Math.max(a.getX(),b.getX());
           int maxRow = (int) Math.max(a.getY(),b.getY());
           this.a = new Point(minColumn, minRow);
           this.b = new Point(maxColumn, maxRow);
       }
   
       private ArrayList<Point> calcPoints() {
           ArrayList<Point> list = new ArrayList<Point>();
           int minColumn = (int) a.getX();
           int minRow = (int) a.getY();
           int maxColumn = (int) b.getX();
           int maxRow = (int) b.getY();
           for (int i = minColumn; i < maxColumn; i++) {
               for (int j = minRow; j < maxRow; j++) {
                   list.add(new Point(i, j));
               }
           }
           return list;
       }
   
       public ArrayList<Point> getPoints() {
           if(PointList == null) {
               PointList = calcPoints();
           }
           return PointList;
       }
   }