如何在Java中解决这个国际象棋骑士问题？

我想用Java解决一个国际象棋难题。我编码骑士棋子从开始区域（1；1）移动到任何地方，除了负x和y，如果一切都是有效的，把这个访问过的区域放在列表中，否则，返回到上一个。但它根本不起作用，这个条件从来都不是真的，它一直是负的，它不会返回到前一个字段，是什么导致了问题

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Main
{
    static Vector now;
    static Vector prev;

    static List<Vector> visited = new ArrayList<>();

    public static void main(String[] args)
    {
        now = new Vector(); // sets x = 1, y = 1
        prev = now; // also x = 1, y = 1

        visited.add(now); // we are already on (1;1)

        generate();
    }

    static void generate()
    {
        Random rand = new Random();

        for (int i = 0; i < 50; i++)
        {
            int a = rand.nextInt(8);
            move(a);

            if((isValid()) && hasNotVisited()) // if x and y > 0 , because the smallest coord is (1;1), and check is we haven't visited that field
            {
                visited.add(now);
                prev = now; // previous coord is now, then make a new step
            }
            else
            {
                now = prev; // else, return to previous coord
                // For example, we are one (3;2), we move to (1;0), that's not valid, we should move back to (3;2)
            }
        }
    }

    static void move(int a)
    {
        switch (a){
            case 0:
                now.x += 2;
                now.y++;
                break;
            case 1:
                now.x += 2;
                now.y--;
                break;
            case 2:
                now.x -= 2;
                now.y++;
                break;
            case 3:
                now.x -= 2;
                now.y--;
                break;
            case 4:
                now.y += 2;
                now.x++;
                break;
            case 5:
                now.y += 2;
                now.x--;
                break;
            case 6:
                now.y -= 2;
                now.y++;
                break;
            case 7:
                now.y -= 2;
                now.y--;
                break;
        }
    }

    static boolean hasNotVisited()
    {
        for (Vector aVisited : visited) {
            if (aVisited == now)
                return false;
        }

        return true;
    }

    static boolean isValid()
    {
        return (0 < now.x && now.x <= 10) && (0 < now.y && now.y <= 10);
    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
公共班机
{
静态向量现在；
静态向量预测；
访问的静态列表=新建ArrayList（）；
公共静态void main（字符串[]args）
{
now=new Vector（）；//设置x=1，y=1
prev=now；//也是x=1，y=1
已访问。添加（现在）；//我们已经在（1；1）上了
生成（）；
}
静态void生成（）
{
Random rand=新的Random（）；
对于（int i=0；i<50；i++）
{
int a=兰特·耐克斯汀（8）；
动议（a）；
if（（isValid（））&&hasnotvisted（））//如果x和y>0，因为最小坐标是（1；1），检查是我们没有访问该字段
{
已访问。添加（现在）；
prev=now；//上一个坐标现在是，然后执行新的步骤
}
其他的
{
now=prev；//否则，返回上一个坐标
//例如，我们是一（3；2），我们移到（1；0），这是无效的，我们应该移回（3；2）
}
}
}
静态无效移动（INTA）
{
开关（a）{
案例0：
现在，x+=2；
现在。y++；
打破
案例1：
现在，x+=2；
现在，y-；
打破
案例2：
现在，x-=2；
现在。y++；
打破
案例3：
现在，x-=2；
现在，y-；
打破
案例4：
现在，y+=2；
now.x++；
打破
案例5：
现在，y+=2；
现在，x；
打破
案例6：
现在，y-=2；
现在。y++；
打破
案例7：
现在，y-=2；
现在，y-；
打破
}
}
静态布尔hasnotvisted（）
{
用于（矢量采集：已访问）{
如果（avisted==现在）
返回false；
}
返回true；
}
静态布尔值isValid（）
{
return（0hasnotvisted

方法中使用了

if（aVisited==now）

。您需要使用

if（aVisited.equals（now））

• 使用

  ==

  时，您正在检查两个变量是否引用了

  向量的同一实例

• 当使用

  .equals

  时，您正在检查它是否涉及两个

  向量
  具有相同的属性/值

编辑：我刚刚注意到

向量

不会覆盖

等于

。另请参见。或者，您可以使用

（如果aVisited.x==now.x&&aVisited.y==now.y）

方法中的

未访问

的可能重复