Random.nextBytes（字节[]）在java中的行为

问题是，为什么在单独的方法调用中获取相同数量的字节会返回不同的字节，这取决于在单个方法调用中调用的5000字节或5000个方法调用是使用长度为1的字节数组进行的

以下面的示例为例：在终端中打印21，而不是5000（5000除以256得到19，这使得21个匹配很可能是简单的巧合）

Random rand=new Random（0）；
字节tmp1[]=新字节[5000]；
兰特下字节（tmp1）；
rand=新随机数（0）；
字节tmp2[]=新字节[5000]；
字节tmp3[]=新字节[1]；
对于（int i=0；i<5000；i++）
{
兰特下字节（tmp3）；
tmp2[i]=tmp3[0]；
}
int匹配=0；
对于（int i=0；i<5000；i++）
{
if（tmp1[i]==tmp2[i]）
{
匹配++；
}
}
System.out.println（匹配项）；

更重要的是，任何破解方法都会生成相同的字节，这与我是使用长度为5000的数组调用该方法一次还是使用长度为2500的数组调用该方法两次无关，等等

编辑：下面的帖子完美地回答了这个问题，一次接收4字节完全解决了这个问题。 测试代码如下，返回4000：

                Random rand1 = new Random(0);
                byte tmp11[] = new byte[4000];
                rand1.nextBytes(tmp11);
                rand1 = new Random(0);
                byte tmp22[] = new byte[4000];
                byte tmp33[] = new byte[4];
                for(int i = 0; i < 1000;i++)
                {
                    rand1.nextBytes(tmp33);
                    for(int a = 0; a < 4;a++)
                    {
                        tmp22[(i*4)+a] = tmp33[a];
                    }
                }
                int matches1 = 0;
                for(int i = 0; i < 4000;i++)
                {
                    if(tmp11[i] == tmp22[i])
                    {
                        matches1++;
                    }
                }
                System.out.println(matches1);

Random rand1=新随机数（0）；
字节tmp11[]=新字节[4000]；
rand1.nextBytes（tmp11）；
rand1=新随机数（0）；
字节tmp22[]=新字节[4000]；
字节tmp33[]=新字节[4]；
对于（int i=0；i<1000；i++）
{
rand1.nextBytes（tmp33）；
对于（int a=0；a<4；a++）
{
tmp22[（i*4）+a]=tmp33[a]；
}
}
int matches1=0；
对于（int i=0；i<4000；i++）
{
if（tmp11[i]==tmp22[i]）
{
matches1++；
}
}
系统输出打印LN（匹配1）；

这是因为java使用nextInt（）填充字节，并将其他3个int值字节添加到数组中。基本上，从随机生成器接收的每个int填充数组的4个字节。我将添加一个示例

以下是javadoc的第一部分：

nextBytes方法是通过Random类实现的，就像通过：

 public void nextBytes(byte[] bytes) {    for (int i = 0; i <
 bytes.length; )
      for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
           n-- > 0; rnd >>= 8)
       bytes[i++] = (byte)rnd; 
 }

印刷品： 96 56 96

---

56因为int的大小是4。基本上，它得到一个int（即4个字节），并将其添加到0,1,2,3位置的字节数组中。当您使用字节[1]调用它时，它会得到相同的int并将相同的字节添加到值0，但int中的其他3个字节将丢失。这就是为什么你会不一致。您得到的数字21只是巧合。

这是因为java使用nextInt（）填充字节，并将其他3个int值字节添加到数组中。基本上，从随机生成器接收的每个int填充数组的4个字节。我将添加一个示例

以下是javadoc的第一部分：

nextBytes方法是通过Random类实现的，就像通过：

 public void nextBytes(byte[] bytes) {    for (int i = 0; i <
 bytes.length; )
      for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
           n-- > 0; rnd >>= 8)
       bytes[i++] = (byte)rnd; 
 }

印刷品： 96 56 96

---

56因为int的大小是4。基本上，它得到一个int（即4个字节），并将其添加到0,1,2,3位置的字节数组中。当您使用字节[1]调用它时，它会得到相同的int并将相同的字节添加到值0，但int中的其他3个字节将丢失。这就是为什么你会不一致。您得到的数字21只是巧合。

因为java的

Random

是一个伪随机数生成器，每次调用invoke any

next

方法时，它的内部“状态”都将前进，即返回一个可能与前一个不同的伪随机数。结合对以下内容的描述，即它从对

nextInt

的一次调用中为目标字节数组中的每4个字节构造目标字节数组，这将导致代码的不同结果。

因为java的

Random

是一个伪随机数生成器，每次调用invoke any

next

方法时，其内部“状态”都将前进，即返回一个可能与前一个不同的伪随机数。结合对以下内容的描述，即它从对

nextInt

的一次调用中为目标字节数组中的每4个字节构造目标字节数组，这将导致代码的不同结果。

这是随机种子发生的地方吗？不，如示例中所示，两个随机类实例的种子都为0。种子是相同的这是随机种子发生的地方吗？不，从示例中可以看出，两个随机类实例的种子都是0。种子是相同的，没有转化。他只得到一个int，并从int值中丢失其他3个字节。当他有5000字节数组时，他使用这3个字节。这就是为什么inconsistency@VeselinDavidov从4个字节中删除3个字节在某种程度上是一种转换；）我的意思是，伪随机数生成器在输入相同种子时总是给出相同的整数。因此，他可以相信随机结果每次都是相同的-只是他在转换过程中丢失了一些字节。换句话说，请求1字节，返回第一个nextInt（）内部调用的第一个字节，再次请求一个字节，返回第二个内部nextInt（）调用的第一个字节，请求两个字节将从第三个内部nextInt调用返回第一个字节和第二个字节Yeah如果它从nextInt（）中获得4个字节，则不会再次随机调用，而是使用另一个ByTest优化调用。这不是转换。他只得到一个int，并从int值中丢失其他3个字节。当他有5000字节数组时，他使用这3个字节。这就是为什么inconsistency@VeselinDavidov从4个字节中删除3个字节在某种程度上是一种转换；）我的意思是，伪随机数生成器在输入相同种子时总是给出相同的整数。因此，他可以依靠随机结果得到相同的结果

      Random rand = new Random(0);
      rand.nextBytes(tmp1);
      System.out.println(tmp1[0]);
      System.out.println(tmp1[4]);
      rand = new Random(0);
      rand.nextBytes(tmp3);
      System.out.println(tmp3[0]);
      rand.nextBytes(tmp3);
      System.out.println(tmp3[0]);