JAVA:Random的种子含义

Random类的基值seed是什么意思？
比如：
Random ran1=new Random();
Random ran2=new Random(12345);
这两个有什么区别啊？运行结果没区别啊！

生成随机数
            Random random = new Random();
            Random random = new Random(100);//指定种子数100
            random调用不同的方法，获得随机数。
            如果2个Random对象使用相同的种子（比如都是100），并且以相同的顺序调用相同的函数，那它们返回值完全相同。如下面代码中两个Random对象的输出完全相同
           import java.util.*;
           class TestRandom {
                 public static void main(String[] args) {
                      Random random1 = new Random(100);
                      System.out.println(random1.nextInt());
                      System.out.println(random1.nextFloat());
                      System.out.println(random1.nextBoolean());
                      Random random2 = new Random(100);
                      System.out.println(random2.nextInt());
                      System.out.println(random2.nextFloat());
                      System.out.println(random2.nextBoolean());
                 }
             } 

====================================================================

一般计算机的随机数都是伪随机数，以一个真随机数（种子）作为初始条件，然后用一定的算法不停迭代产生随机数，下面介绍两种方法： 

　　一般种子可以以当前的系统时间，这是完全随机的 

　　。 

　　算法1：平方取中法。 

　　1）将种子设为X0，并mod 10000得到4位数 

　　2)将它平方得到一个8位数（不足8位时前面补0） 

　　3）取中间的4位数可得到下一个4位随机数X1 

　　4）重复1-3步，即可产生多个随机数 

　　这个算法的一个主要缺点是最终它会退化成0，不能继续产生随机数。 

　　算法2：线性同余法 

　　1）将种子设为X0， 

　　2）用一个算法X(n+1)=(a*X(n)+b) mod c产生X(n+1) 

　　一般将c取得很大，可产生0到c-1之间的伪随机数 

　　该算法的一个缺点是会出现循环。

 
 

  
  
JDK中关于Random的构造函数叙述如下:
  
  
public Random()

  
  

   
   

    
    创建一个新的随机数生成器。此构造方法为随机数生成器的种子设置某个值，该值与此构造方法的所有其他调用所用的值完全不同。
   
   
  
  
  
  
public Random(long seed)

  
  

   
   

    
    使用单个 long 种子创建一个新随机数生成器：
    
    

     
     
public Random(long seed) { setSeed(seed); }

    
    
   
   
  
  
  
  

   
   
next 方法使用它来保存随机数生成器的状态。 

   
   
参数：seed - 初始种子。 

   
   

    
    
     
     另请参见： Random的setSeed(long)
    
    
   
   
   
   
public void setSeed(long seed)

   
   

    
    

     
     使用单个 long 种子设置此随机数生成器的种子。setSeed的常规协定是它更改此随机数生成器对象的状态，使其状态好像是刚刚使用参数 seed作为种子创建它的状态一样。Random 类按如下方式实现 setSeed 方法：
     
     

      
      
synchronized public void setSeed(long seed) {
       this.seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1);
       haveNextNextGaussian = false;
 }

     
     
     
     由 Random 类实现的 setSeed 恰好只使用 48位的给定种子。但是，通常重写方法可能使用 long 参数的所有 64 位作为种子值。 注：尽管种子值是一个基本的AtomicLong，但仍必须对此方法同步，确保 haveNextNextGaussian 的语义正确。
     
     
 
    
    
    
    

     
     

      
       
       参数： 
      
      
      
 
       seed - 初始种子。 
      
     
     
    
    
   
   
   
   
 
  
  
  
  
观察如下的代码

  
  
public class Test {
public static void main(String args[]) throws Throwable {
   for(inti=0;i<10;i++)
       System.out.print((new Random(10)).nextInt(10));
   for(intj=0;j<10;j++)
       System.out.print((new Random()).nextInt(10));
}
}
  
  
输出接结果是：33333333333012603015
  
  
当为其指定种子为10时，随机出来的数是相同的，不指定时随机的数是大多不相同的。
  
  
因为在不指定种子的构造函数时系统根据当前时间生成种子，每个种子对应一个数列，相同的种子会得到相同数列，而不是数值。所以如果在构造函数中指定种子，会得到同一个数列。
  
  
 
  
  
实际上Random是一种伪随机数，相同的种子产生相同的序列（注意不是相同数值）。
  
  
Random的nextInt实现如下，依赖于next
  
  
public int nextInt(int n) {
       if (n <= 0)
           throw new IllegalArgumentException("n must be positive");
  
  
       if ((n & -n) == n) // i.e., n is a power of 2
           return (int)((n * (long)next(31)) >>31);
  
  
       int bits, val;
       do {
           bits = next(31);
           val = bits % n;
       } while (bits - val + (n-1) < 0);
       return val;
    }
  
  
next方法实现如下：
  
  
protected int next(int bits) {
       long oldseed, nextseed;
       AtomicLong seed = this.seed;
       do {
    oldseed = seed.get();
    nextseed = (oldseed * multiplier + addend) &mask;
       } while (!seed.compareAndSet(oldseed, nextseed));
       return (int)(nextseed>>> (48 -bits));
    }
  
  
next依赖于seed生成一个随机数，如果seed相同则生成同一随机数列。
  
  
观看如下代码：
  
  
Random rand = new Random(47);
Random rand2 = new Random(47);
   int i =rand.nextInt(100);
   int j =rand.nextInt(100);
   int i1 =rand2.nextInt(100);
   int j1 =rand2.nextInt(100);
       System.out.print(i+".");
       System.out.print(j+".");
       System.out.print(i1+".");
       System.out.print(j1+".");
  
  
结果：58.55.58.55.
  
  
说明得到的是同一值序列而非同一个值。