• Tags
  •         
  • www.breakyizhan.com
  •    

    随机类用于在java中生成伪随机数。此类的实例是线程安全的。然而,这个类的实例是加密不安全的。该类提供了各种方法调用,以生成不同的随机数据类型,如float,double,int。

    构造函数:

    • Random():创建一个新的随机数生成器
    • Random(long seed):使用单个seed创建新的随机数生成器

    语法:

    public class Random
                   extends Object
                   implements Serializable

    Java中的Java.util.Random类的方法:

    1. java.util.Random.doubles(): 返回一个有效无限的伪随机double值流,每个值介于零(包括)和一个(独占)
      语法之间:

      public DoubleStream doubles()
      返回: 
      伪随机双精度值的流
    2.  java.util.Random.ints(): 返回一个有效无限的伪随机int值流
      语法:

      public IntStream ints()
      返回: 
      伪随机int值的流
    3. java.util.Random.longs(): 返回一个有效无限的伪随机长值流
      语法:

      public LongStream longs()
      返回: 
      伪随机长值流
    4. next(int bits):java.util.Random.next(int bits)生成下一个伪随机数
      语法:

      protected int next(int bits)
      参数:
      位 - 随机位
      返回:
      这个下一个伪随机值 
      随机数发生器的序列
    5. java.util.Random.nextBoolean(): 从此随机数生成器的序列中返回下一个伪随机,均匀分布的布尔值
      语法:

      public boolean nextBoolean()
      返回:
      下一个伪随机,均匀分布的布尔值 
      从这个随机数发生器的序列
    6. java.util.Random.nextBytes(byte [] bytes):生成随机字节并将它们放入用户提供的字节数组中
      语法:

      public void nextBytes(byte [] bytes)
      参数:
      bytes  - 要填充随机字节的字节数组
      抛出: 
      NullPointerException  - 如果字节数组为null
    7. java.util.Random.nextDouble(): 从这个随机数生成器的序列中返回0.0和1.0之间的下一个伪随机,均匀分布的double值
      语法:

      public double nextDouble()
      返回:
      下一个伪随机,均匀分布的双 
      从这里开始的值介于0.0和1.0之间 
      随机数发生器的序列
    8. java.util.Random.nextFloat(): 从这个随机数生成器的序列中返回0.0和1.0之间的下一个伪随机,均匀分布的浮点值
      语法:

      public float nextFloat()
      返回:
      下一个伪随机数,均匀分布的浮点值 
      介于0.0和1.0之间 
      随机数发生器的序列
    9. java.util.Random.nextGaussian(): 返回下一个伪随机,高斯(“正常”)分布式double值,其均值为0.0,标准差为1.0,来自此随机数生成器的序列
      语法:

      public double nextGaussian()
      返回:
      下一个伪随机数,高斯(“正常”)分布为双
      平均值为0.0,标准偏差为1.0 
      随机数发生器的序列
    10. java.util.Random.nextInt(): 从此随机数生成器的序列中返回下一个伪随机,均匀分布的int值
      语法:

      public int nextInt()
      返回:
      下一个伪随机数,从中均匀分布的int值 
      这个随机数发生器的序列
    11. java.util.Random.nextInt(int bound): 返回0(包括)和指定值(不包括)之间的伪随机,均匀分布的int值,从该随机数生成器的序列中提取
      语法:

      public int nextInt(int bound)
      参数:
      bound  - 上限(不包括)。必须是积极的。
      返回:
      下一个伪随机数,均匀分布的int值 
      零(包括)和绑定之间 
      (独占)来自这个随机数发生器的序列
      抛出: 
      IllegalArgumentException  - 如果bound不是正数
    12. java.util.Random.nextLong(): 从这个随机数生成器的序列中返回下一个伪随机,均匀分布的长值
      语法:

      public long nextLong()
      返回:
      下一个伪随机,均匀分布的长值
      从这个随机数 
      发电机的顺序
    13. java.util.Random.setSeed(long seed): 使用单个长种子语法设置此随机数生成器的种子

      public void setSeed(长种子)
      参数: 
      seed  - 初始种子

    Java程序演示Random类的用法

    // Java program to demonstrate
    // method calls of Random class
    import java.util.Random;
    
    public class Test
    {
        public static void main(String[] args)
        {
            Random random = new Random();
            System.out.println(random.nextInt(10));
            System.out.println(random.nextBoolean());
            System.out.println(random.nextDouble());
            System.out.println(random.nextFloat());
            System.out.println(random.nextGaussian());
            byte[] bytes = new byte[10];
            random.nextBytes(bytes);
            System.out.printf("[");
            for(int i = 0; i< bytes.length; i++)
            {
                System.out.printf("%d ", bytes[i]);
            }
            System.out.printf("]\n");
            
              System.out.println(random.nextLong());  
          System.out.println(random.nextInt());
         
          long seed = 95;
          random.setSeed(seed);
          
          // Note: Running any of the code line below
          // will keep the program running as each of the 
          // methods below produces an unlimited random 
          // values of the corresponding type
    
          /* System.out.println("Sum of all the elements in the IntStream returned = " + 
            random.ints().count());
          System.out.println("Count of all the elements in the DoubleStream returned = " + 
            random.doubles().count());
          System.out.println("Count of all the elements in the LongStream returned = " + 
            random.longs().count());
         
          */
       
      }
    }  
    

    输出:

    4
    true
    0.19674934340402916
    0.7372021
    1.4877581394085997
    [-44 75 68 89 81 -72 -1 -66 -64 117 ]
    158739962004803677
    -1344764816
     
    转载请保留页面地址:https://www.breakyizhan.com/java/4897.html