Java中的随机数问题

我在Java中编写了一段代码以随机方向移动对象。有两个功能

FindRandomDirection-从8个可能的方向（方向由numpad中的数字1,2,3,4,6,7,8,9表示）获取随机方向。检查对象是否靠近任何边界。如果是这样，对象将沿远离边界的方向移动

MoveObject-通过以恒定步长移动来更改对象的（X，Y）坐标

但我给X，Y的值是多少；在多次（700或更多）重复该过程之后，X，Y的值变为{X:20-50}和{Y:450-465}

即

我想知道为什么经过几次迭代后，x，y点会收敛到这些值，即使我随机生成这些数字

下面是相同的代码

import java.io.*;
public class bug
{
    //public static int x = 35;
    //public static int y = 60;

    //public static int x = 35;
    //public static int y = 460;

    //public static int x = 435;
    //public static int y = 60;

    public static int x = 435;
    public static int y = 460;

    public static final int NORTH = 8;
    public static final int EAST = 6;
    public static final int WEST = 4;
    public static final int SOUTH = 2;
    public static final int NORTHEAST = 9;
    public static final int NORTHWEST = 7;
    public static final int SOUTHWEST = 1;
    public static final int SOUTHEAST = 3;
    public static final int STEP = 5;

    //Function to move the object in a specified direction.
    public static void moveObject(int direction)
    {
            double nX = 0, nY=0;
            switch(direction)
            {
            case  NORTH:
                nY = y- STEP; 
                nX = x;
                break;
            case  SOUTH:
                nY = y+ STEP; 
                nX = x;
                break;
            case  EAST:             
                nY = y; 
                nX = x +  STEP;
                break;
            case  WEST:
                nY = y; 
                nX = x- STEP;               
                break;
            case  NORTHEAST:
                nX = x +  STEP;
                nY = y- STEP; 
                break;
            case  NORTHWEST:
                nX = x- STEP;
                nY = y- STEP; 
                break;
            case  SOUTHEAST:
                nX = x +  STEP;
                nY = y+ STEP; 
                break;
            case  SOUTHWEST:
                nX = x- STEP;
                nY = y+ STEP; 
                break;
            }
            x = (int) nX;
            y = (int) nY;
            System.out.println("Direction: "+direction+"; X: "+x+"; Y: "+y);
        }
//Function to move the object in a random direction
//Also if wall(Border) is present the object should move in proper direction
    public static int findRandomDirection(int objObjectX, int objObjectY)
    {
        int[] move = {1,2,3,4,0,6,7,8,9};
        int randDir=0;
        //Generate a random direction to move. Generate new direction if the objected can not be moved in a direction 
        do
        {
            java.util.Random randomGenerator = new java.util.Random();
            randDir = randomGenerator.nextInt(8);

            //If the object lies near East Border, it can not move in that direction
            if(objObjectX <= 25)
            {
                move[0] = 0;
                move[3] = 0;
                move[6] = 0;
            }

            //If the object lies near West Border, it can not move in that direction
            if(objObjectX >= 465)
            {
                move[2] = 0;
                move[5] = 0;
                move[8] = 0;                
            }

            //If the object lies near North Border, it can not move in that direction
            if(objObjectY <= 25)
            {
                move[6] = 0;
                move[7] = 0;
                move[8] = 0;
            }

            //If the object lies near South Border, it can not move in that direction
            if(objObjectY >= 465)
            {
                move[0] = 0;
                move[1] = 0;
                move[2] = 0;                
            }
        } while(move[randDir]==0);
        return move[randDir];       
    }
    public static void main(String[] args)
    {
        for(int i = 0; i<1000;i++)
        {
        int dir=findRandomDirection(x,y);   
        moveObject(dir);
        }
    }
}

import java.io.*；
公共类错误
{
//公共静态int x=35；
//公共静态int y=60；
//公共静态int x=35；
//公共静态int y=460；
//公共静态整数x=435；
//公共静态int y=60；
公共静态整数x=435；
公共静态int y=460；
公共静态最终int北=8；
公共静态最终int东=6；
公共静态最终int WEST=4；
公共静态最终int南=2；
公共静态最终int东北=9；
公共静态最终int西北=7；
公共静态最终int西南=1；
公共静态最终int东南=3；
公共静态最终整数步长=5；
//函数以指定方向移动对象。
公共静态void移动对象（int方向）
{
双nX=0，nY=0；
开关（方向）
{
案例北：
nY=y步；
nX=x；
打破
南方案例：
nY=y+阶跃；
nX=x；
打破
案例东：
nY=y；
nX=x+阶跃；
打破
凯西：
nY=y；
nX=x阶跃；
打破
案例东北：
nX=x+阶跃；
nY=y步；
打破
案例西北：
nX=x阶跃；
nY=y步；
打破
案例东南：
nX=x+阶跃；
nY=y+阶跃；
打破
案例西南：
nX=x阶跃；
nY=y+阶跃；
打破
}
x=（int）nX；
y=（int）nY；
系统输出打印项次（“方向：+方向+”，X:+X+，Y:+Y）；
}
//函数以随机方向移动对象
//此外，如果存在墙（边框），则对象应沿正确方向移动
公共静态int-findAndomdirection（int-objObjectX，int-objObjectY）
{
int[]move={1,2,3,4,0,6,7,8,9}；
int-randDir=0；
//生成要移动的随机方向。如果对象无法沿某个方向移动，则生成新方向
做
{
java.util.Random randomGenerator=new java.util.Random（）；
randDir=randomGenerator.nextInt（8）；
//如果对象位于东边界附近，则它不能向该方向移动
如果（objObjectX=465）
{
移动[2]=0；
移动[5]=0；
move[8]=0；
}
//如果该对象位于北边界附近，则无法朝该方向移动
如果（对象对象=465）
{
移动[0]=0；
移动[1]=0；
移动[2]=0；
}
}while（move[randDir]==0）；
返回移动[randDir]；
}
公共静态void main（字符串[]args）
{
对于（int i=0；i由于您使用的是
nextInt（8）
，因此返回的值将始终介于0和7（包括）之间。由于从未返回8，因此移动会偏向相反的方向。您可能希望使用
nextInt（9）
，以返回0和8（包括）之间的值

编辑：为了澄清，由于“8”从未被选为随机方向，并且
移动[8]==9
，因此对象从未向
东北方向移动，这意味着随着时间的推移，它将倾向于向西南方向移动

此外，正如@Joey上面所说的，您不应该每次都重新初始化
随机对象，但这不是导致漂移行为的原因。
当您选择一个方向时，您选择了一个介于0和7之间的值。这些值（在映射中）对应于：

public static final int SOUTHWEST = 1;
public static final int SOUTH = 2;
public static final int SOUTHEAST = 3;
public static final int WEST = 4;
public static final int EAST = 6;
public static final int NORTHWEST = 7;
public static final int NORTH = 8;

但请注意，这永远不会被选择：

public static final int NORTHEAST = 9;

因此，您的代码似乎偏向东南方向，这对我来说并不奇怪…
nextInt（n）
方法返回从零（包含）到
n（独占）的数字。由于传递值8，结果来自8个值的集合0–7。因此，表示东北方向的数组的第九个元素永远不会被选择

这种对东北方向的偏见最终会导致向西南方向的迁移。
您不应该在循环中重新初始化伪随机数生成器。为类创建一次对象并重新使用它。虽然
java.util.random
包含处理此错误的代码，但最好不要养成坏习惯。这很有趣s的问题在这里停留了45分钟，没有答案（我知道，我一直在想办法），然后你的答案吸引了另外两个几乎相同的人：）
public static final int NORTHEAST = 9;