blocks|key|1983310|text|如果你总是设置种子，你将总是得到相同的答案。这就是设置种子的功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1983311|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you always set the seed, you will always get the same answer. That is what setting the seed does.

blocks|key|1769841|text|在启动时设置种子一次，而不是每次需要新的随机数时都设置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1769842|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Set the seed once on startup, rather than every time you want a new random number.

blocks|key|1769857|text|您需要在整个类中共享Random()实例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1769858|public+class+Numbers+{
++++Random+randnum;

++++public+Numbers()+{
++++++++randnum+=+new+Random();
++++++++randnum.setSeed(123456789);
++++}

++++public+int+random(int+i){
++++++++return+randnum.nextInt(i);
++++}
}|code-block|syntax|javascript|1769859|entityMap^0|A|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You need to share the <code>Random()</code> instance across the whole class:

<pre><code>public class Numbers {
 Random randnum;

 public Numbers() {
 randnum = new Random();
 randnum.setSeed(123456789);
 }

 public int random(int i){
 return randnum.nextInt(i);
 }
}
</code></pre>

blocks|key|1769894|text|您使用的不是随机数生成器，而是伪随机数生成器。PRNG生成伪随机数序列，种子选择序列中的起始点(PRNG可以生成一个或多个序列)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1769895|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

What you are using is not a Random Number Generator, it's a Pseudo-Random Number Generator. PRNG's generate sequences of pseudo-random numbers, the seed selects a starting point in a sequence (a PRNG may generate one or several sequences).

blocks|key|1983473|text|通常，随机不是真正的随机，而是伪随机。这意味着它接受一个给定的种子，并使用它来生成一个看起来像随机的数字序列(但在输入时是可预测的，如果你放入相同的种子，它会重复)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1983474|如果你不放种子，那么第一个种子将从一个可变的来源(通常是系统时间)获取。|1983475|通常，将使用带有种子的值，以便使其重复确切的值(例如，用于测试)。改用不带种子的随机数。|1983476|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Usually, Random is not truly random but pseudorandom. It means it takes a given seed and uses it to generate a sequence of numbers that looks like random (but is enterely predictable and it repeats if you put the same seed).

If you don't put seed, then the first seed will be taken from a variable source (usually the system time).

Usually, a value with seed will be used in order to have it repeat the exact values (for example, for testing). Use Random without seed instead.

blocks|key|1770021|text|有两个问题导致了您看到的结果。第一个是代码为Random实例设置一个种子值。第二种方法是实例方法"+Random“实例化一个新的Random对象，然后每次都用相同的种子立即设置它的种子。这两者的结合保证了，对于相同的i值，方法"random“将始终返回相同的值，并且它将始终是种子生成的序列中的第一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1770022|假设设置种子是强制性的，为了每次都获得序列中的下一个值而不是序列中相同的第一个值，Random的randnum实例不能在调用它的下一个方法之前每次都设置它的种子。要解决这个问题，可以将Random的随机局部变量实例从random实例方法的作用域移动到类作用域。其次，仅当为random分配了Random实例时才设置种子，或者仅当从随机实例中获得相同序列的结果时才设置种子，以便重新开始。随机类的setSeed(长种子)实例方法不能在类作用域中执行，因此构造函数必须使用带有长种子参数的随机构造函数来设置它。下面的代码显示了这些更改：|1770023|public+class+RandomDemo+{+//+arbitrary+example+class+name
++++//+lots+of+class+related+stuff+may+be+here...

++++//+still+inside+the+class+scope...
++++//+private+is+a+good+idea+unless+an+external+method+needs+to+change+it
++++private+Random+randnum+=+new+Random(123456789L);
++++//+the+seed+guarantees+it+will+always+produce+the+same+sequence
++++//+of+pseudo-random+values+when+the+next+methods+get+called
++++//+for+unpredicable+sequences,+use+the+following+constructor+instead:
++++//+private+Random+randnum+=+new+Random();

++++//+lots+of+code+may+be+here...

++++//+publicly+exposed+instance+method+for+getting+random+number
++++//+from+a+sequence+determined+by+seed+123456789L
++++//+in+the+range+from+0+through+i-1
++++public+int+randnum(int+i)+{
++++++++//+don't+set+the+seed+in+here,+or+randnum+will+return+the+exact+same+integer
++++++++//+for+the+same+value+of+i+on+every+method+call
++++++++//+nextInt(i)+will+give+the+next+value+from+randnum+conforming+to+range+i
++++++++return+randnum.nextInt(i);
++++}+//+end+randnum

++++//+lots+of+more+code+may+be+here...

}+//+end+class+RandDemo|code-block|syntax|javascript|1770024|如上所述，上述方法将为您的确切问题提供准确的解决方案。然而，考虑到强制种子的作用，使用强制种子似乎并不常见。|1770025|如果这是用于类项目或软件测试，其中序列必须是可预测和可重复的，则将种子设置为固定值是有意义的。否则，质疑将种子设置为某个预定值的有效性。下面解释更多关于随机、随机种子以及为什么有提供种子的规定。|1770026|Random有两个构造函数：|1770027|Random()|1770028|和|1770029|Random(long+seed)|1770030|和一个实例方法|1770031|setSeed(long+seed)|1770032|所有这些都会影响从Random实例获得的数字序列。实例方法，|1770033|setSeed(long+seed)|1770034|将Random对象设置为与其仅使用与构造函数参数相同的种子实例化时所处的相同状态。仅使用种子值的低48位。|1770035|如果随机对象实例化时没有种子，则种子将与系统时间相同(以毫秒为单位)。这确保了，除非在同一毫秒内实例化两个随机对象，否则它们将产生不同的伪随机序列。仅使用种子值的低48位。这会导致不可预测的伪随机序列。每次调用next方法时都要获得一个新的Random实例，这是不必要的，也不是浪费计算资源。|1770036|提供了Random的种子参数，以便可以实例化一个随机对象，该对象产生一个可重复的序列。对于给定的种子，无论何时使用该种子，next方法中的值序列都保证是相同的序列。这对于将要使用伪随机序列的测试软件很有用，其中结果必须是可预测和可重复的。它对于在操作中创建不同的不可预测伪随机序列没有用处。|1770037|“设置种子是强制性的”这句话否定了Random对象的伪随机序列的任何不可预测性。这是否适用于类、项目或软件测试，在这些测试中，程序的相同输入结果必须相同？|1770038|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1M|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|1O|8|@]|9|@]|A|$G|H]]|$1|12|3|13|5|6|7|1P|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1R|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|1S|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|1B|$]]

There are two issues causing what you see. The first is that the code sets a seed value for a Random instance. The second is that the instance method "random" instances a new Random object and then immediately sets its seed with the same seed every time. The combination of these two guarantees that, for the same value of i, the method "random" will always return the same value and it will always be the first in the sequence that the seed always generates. 

Assuming setting the seed is mandatory, to get the next value in the sequence instead of the same first value of the sequence every time, the randnum instance of Random can't have its seed set every time just before its next method gets called. To fix that, move the randnum local variable instance of Random from the scope of the random instance method to the class scope. Second, set the seed only when random is assigned a Random instance or only to get same sequence of results from it to start over again. Class Random's setSeed(long seed) instance method can't execute in the class scope, so the constructor has to set it using the Random constructor with the long seed parameter. The following code shows the changes:

<pre><code>public class RandomDemo { // arbitrary example class name
 // lots of class related stuff may be here...

 // still inside the class scope...
 // private is a good idea unless an external method needs to change it
 private Random randnum = new Random(123456789L);
 // the seed guarantees it will always produce the same sequence
 // of pseudo-random values when the next methods get called
 // for unpredicable sequences, use the following constructor instead:
 // private Random randnum = new Random();

 // lots of code may be here...

 // publicly exposed instance method for getting random number
 // from a sequence determined by seed 123456789L
 // in the range from 0 through i-1
 public int randnum(int i) {
 // don't set the seed in here, or randnum will return the exact same integer
 // for the same value of i on every method call
 // nextInt(i) will give the next value from randnum conforming to range i
 return randnum.nextInt(i);
 } // end randnum

 // lots of more code may be here...

} // end class RandDemo
</code></pre>

The above will give you an exact solution to your exact problem, as stated. However, using a mandatory seed seems unusual, given what it does. 

If this is for a class project or software testing where the sequence has to be predictable and repeatable, setting the seed to a fixed value makes sense. Otherwise, question the validity of setting the seed to some predetermined value. The following explains more about Random, seeds for Random and why there is a provision for supplying a seed.

Random has two constructors:

<pre><code>Random()
</code></pre>

and

<pre><code>Random(long seed)
</code></pre>

and an instance method

<pre><code>setSeed(long seed)
</code></pre>

that all affect the sequence of numbers obtained from a Random instance. The instance method,

<pre><code>setSeed(long seed)
</code></pre>

sets the Random object to the same state it would have been in had it been just instanced with the same seed as the constructor argument. Only the low-order 48 bits of a seed value get used. 

If a Random object is instanced without a seed, the seed will be the same as the system time in milliseconds. This ensures that, unless two Random objects are instanced in the same millisecond, they will produce different pseudo-random sequences. Only the low order 48 bits of the seed value gets used. This causes unpredictable pseudo-random sequences. It is not necessary and wasteful of computing resources to get a new instance of Random every time one calls a next method. 

Random's seed parameters are provided so that one may instance a Random object that produces a sequence that is repeatable. For a given seed, the sequence of values in next methods are guaranteed to be the same sequence whenever that seed is used. This is useful for testing software that is going to use pseudo-random sequences where results have to be predicable and repeatable. It is not useful for creating different unpredictable pseudo-random sequences in operation. 

The statement "it is mandatory that I set the seed" negates any unpredictablity of the Random object's pseudo-random sequences. Is this for a class project or software test where results have to be the same for the same inputs to the program?

I require help with a random number generator I am creating. My code is as follows (inside a class called numbers):

<pre><code>public int random(int i){
 Random randnum = new Random();
 randnum.setSeed(123456789);
 return randnum.nextInt(i);
}
</code></pre>

When I call this method from another class (in order to generate a random number), it always returns the same number. For example if I were to do:

<pre><code>System.out.println(numbers.random(10));
System.out.print(numbers.random(10));
</code></pre>

it always prints the same number e.g. 5 5. What do I have to do so that it prints two different numbers e.g. 5 8

It is mandatory that I set the seed.

Thanks

Java random always returns the same number when I set the seed?

软件测试

我需要帮助与随机数生成器，我正在创建。我的代码如下(在一个名为numbers的类中)：public int random(int i){    Random randnum = new Random();    randnum.setSeed(123456789);    return randnum.nextInt(...

问当我设置种子时，Java random总是返回相同的数字？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当我设置种子时，Java random总是返回相同的数字？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当我设置种子时，Java random总是返回相同的数字？
EN