Java随机数总结

女爷i 2022-08-18 15:25 137阅读 0赞

随机数在实际中使用很广泛，比如要随即生成一个固定长度的字符串、数字。或者随即生成一个不定长度的数字、或者进行一个模拟的随机选择等等。Java提供了最基本的工具，可以帮助开发者来实现这一切。

## Java随机数的产生方式 ##

在Java中，随机数的概念从广义上将，有三种。  
1、通过System.currentTimeMillis()来获取一个当前时间毫秒数的long型数字。

2、通过Math.random()返回一个0到1之间的double值。

3、通过java.util.Random类来产生一个随机数，这个是专业的Random工具类，功能强大。

## Random类API说明 ##

### Java API说明 ###

Random类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证属性的实现，为类 Random 指定了特定的算法。

很多应用程序会发现 Math 类中的 random 方法更易于使用。

### 方法摘要 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">函数名</th> 
   <th align="center">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Random()</td> 
   <td align="center">创建一个新的随机数生成器。</td> 
  </tr> 
  <tr> 
   <td align="center">Random(long seed)</td> 
   <td align="center">使用单个 long 种子创建一个新随机数生成器： public Random(long seed) { setSeed(seed); } next 方法使用它来保存随机数生成器的状态。</td> 
  </tr> 
  <tr> 
   <td align="center">protected int next(int bits)</td> 
   <td align="center">生成下一个伪随机数。</td> 
  </tr> 
  <tr> 
   <td align="center">boolean nextBoolean()</td> 
   <td align="center">返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。</td> 
  </tr> 
  <tr> 
   <td align="center">void nextBytes(byte[] bytes)</td> 
   <td align="center">生成随机字节并将其置于用户提供的字节数组中。</td> 
  </tr> 
  <tr> 
   <td align="center">double nextDouble()</td> 
   <td align="center">返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的double 值。</td> 
  </tr> 
  <tr> 
   <td align="center">float nextFloat()</td> 
   <td align="center">返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。</td> 
  </tr> 
  <tr> 
   <td align="center">double nextGaussian()</td> 
   <td align="center">返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。</td> 
  </tr> 
  <tr> 
   <td align="center">int nextInt()</td> 
   <td align="center">返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。</td> 
  </tr> 
  <tr> 
   <td align="center">int nextInt(int n)</td> 
   <td align="center">返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。</td> 
  </tr> 
  <tr> 
   <td align="center">long nextLong()</td> 
   <td align="center">返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。</td> 
  </tr> 
  <tr> 
   <td align="center">void setSeed(long seed)</td> 
   <td align="center">使用单个 long 种子设置此随机数生成器的种子。</td> 
  </tr> 
 </tbody> 
</table>

## Random类使用说明 ##

### 带种子与不带种子的区别 ###

Random类使用的根本是策略分带种子和不带种子的Random的实例。

通俗说，两者的区别是：

带种子的，每次运行生成的结果都是一样的。  
不带种子的，每次运行生成的都是随机的，没有规律可言。

### 创建不带种子的Random对象 ###

Random random = new Random();

### 创建不带种子的Random对象 ###

有两种方法：

1） Random random = new Random(555L);
           2） Random random = new Random();
                    random.setSeed(555L);

## 测试 ##

import java.util.Random;
    
    /** * Java随机数测试 * User: Phoebe * Date: 2015-12-27 11:00:50 */
    public class Main {
        public static void main(String[] args) {
            randomTest();
            testNoSeed();
            testSeed1();
            testSeed2();
        }
    
        public static void randomTest() {
            System.out.println("--------------test()--------------");
            //返回以毫秒为单位的当前时间。
            long r1 = System.currentTimeMillis();
            //返回带正号的 double 值，大于或等于 0.0，小于 1.0。
            double r2 = Math.random();
            //通过Random类来获取下一个随机的整数
            int r3 = new Random().nextInt();
            System.out.println("r1 = " + r1);
            System.out.println("r3 = " + r2);
            System.out.println("r2 = " + r3);
        }
    
        public static void testNoSeed() {
            System.out.println("--------------testNoSeed()--------------");
            //创建不带种子的测试Random对象
            Random random = new Random();
            for (int i = 0; i < 3; i++) {
                System.out.println(random.nextInt());
            }
        }
    
        public static void testSeed1() {
            System.out.println("--------------testSeed1()--------------");
            //创建带种子的测试Random对象
            Random random = new Random(555L);
            for (int i = 0; i < 3; i++) {
                System.out.println(random.nextInt());
            }
        }
    
        public static void testSeed2() {
            System.out.println("--------------testSeed2()--------------");
            //创建带种子的测试Random对象
            Random random = new Random();
            random.setSeed(555L);
            for (int i = 0; i < 3; i++) {
                System.out.println(random.nextInt());
            }
        }
    }

运行结果：

> ————–test()————–  
> r1 = 1227108626582  
> r3 = 0.5324887850155043  
> r2 = -368083737  
> ————–testNoSeed()————–  
> 809503475  
> 1585541532  
> \-645134204  
> ————–testSeed1()————–  
> \-1367481220  
> 292886146  
> \-1462441651  
> ————–testSeed2()————–  
> \-1367481220  
> 292886146  
> \-1462441651

通过testSeed1()与testSeed2()方法的结果可以看到，两个打印结果相同，因为他们种子相同，再运行一次，结果还是一样的，这就是带种子随机数的特性。

而不带种子的，每次运行结果都是随机的。

## 综合应用 ##

import java.util.Random; 
    
    /** * Java随机数测试 * User: Phoebe * Date: 2015-12-04 19:44:50 */ 
    public class RandomUtils {  
            public static final String allChar = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
            public static final String letterChar = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
            public static final String numberChar = "0123456789"; 
    
            /** * 返回一个定长的随机字符串(只包含大小写字母、数字) * * @param length 随机字符串长度 * @return 随机字符串 */ 
            public static String generateString(int length) { 
                    StringBuffer sb = new StringBuffer(); 
                    Random random = new Random(); 
                    for (int i = 0; i < length; i++) { 
                            sb.append(allChar.charAt(random.nextInt(allChar.length()))); 
                    } 
                    return sb.toString(); 
            } 
    
            /** * 返回一个定长的随机纯字母字符串(只包含大小写字母) * * @param length 随机字符串长度 * @return 随机字符串 */ 
            public static String generateMixString(int length) { 
                    StringBuffer sb = new StringBuffer(); 
                    Random random = new Random(); 
                    for (int i = 0; i < length; i++) { 
                            sb.append(allChar.charAt(random.nextInt(letterChar.length()))); 
                    } 
                    return sb.toString(); 
            } 
    
            /** * 返回一个定长的随机纯大写字母字符串(只包含大小写字母) * * @param length 随机字符串长度 * @return 随机字符串 */ 
            public static String generateLowerString(int length) { 
                    return generateMixString(length).toLowerCase(); 
            } 
    
            /** * 返回一个定长的随机纯小写字母字符串(只包含大小写字母) * * @param length 随机字符串长度 * @return 随机字符串 */ 
            public static String generateUpperString(int length) { 
                    return generateMixString(length).toUpperCase(); 
            } 
    
            /** * 生成一个定长的纯0字符串 * * @param length 字符串长度 * @return 纯0字符串 */ 
            public static String generateZeroString(int length) { 
                    StringBuffer sb = new StringBuffer(); 
                    for (int i = 0; i < length; i++) { 
                            sb.append('0'); 
                    } 
                    return sb.toString(); 
            } 
    
            /** * 根据数字生成一个定长的字符串，长度不够前面补0 * * @param num 数字 * @param fixdlenth 字符串长度 * @return 定长的字符串 */ 
            public static String toFixdLengthString(long num, int fixdlenth) { 
                    StringBuffer sb = new StringBuffer(); 
                    String strNum = String.valueOf(num); 
                    if (fixdlenth - strNum.length() >= 0) { 
                            sb.append(generateZeroString(fixdlenth - strNum.length())); 
                    } else { 
                            throw new RuntimeException("将数字" + num + "转化为长度为" + fixdlenth + "的字符串发生异常！"); 
                    } 
                    sb.append(strNum); 
                    return sb.toString(); 
            } 
    
            /** * 根据数字生成一个定长的字符串，长度不够前面补0 * * @param num 数字 * @param fixdlenth 字符串长度 * @return 定长的字符串 */ 
            public static String toFixdLengthString(int num, int fixdlenth) { 
                    StringBuffer sb = new StringBuffer(); 
                    String strNum = String.valueOf(num); 
                    if (fixdlenth - strNum.length() >= 0) { 
                            sb.append(generateZeroString(fixdlenth - strNum.length())); 
                    } else { 
                            throw new RuntimeException("将数字" + num + "转化为长度为" + fixdlenth + "的字符串发生异常！"); 
                    } 
                    sb.append(strNum); 
                    return sb.toString(); 
            } 
    
            public static void main(String[] args) { 
                    System.out.println(generateString(15)); 
                    System.out.println(generateMixString(15)); 
                    System.out.println(generateLowerString(15)); 
                    System.out.println(generateUpperString(15)); 
                    System.out.println(generateZeroString(15)); 
                    System.out.println(toFixdLengthString(123, 15)); 
                    System.out.println(toFixdLengthString(123L, 15)); 
            } 
    }

运行结果：

> vWMBPiNbzfGCpHG  
> 23hyraHdJkKPwMv  
> tigowetbwkm1nde  
> BPZ1KNEJPHB115N  
> 000000000000000  
> 000000000000123  
> 000000000000123

## 总结 ##

1、随机数很常用，在Java有三种产生方式，以Random随机数的使用最为复杂。  
2、Random类对象有是否带种子之分，带种子的只要种子相同，多次运行，生成随机数的结果总是那样。  
3、带种子随机数的带种子的对象创建方式有两种，效果一样。但是带种子的随机数用处似乎不大。  
4、Random的功能涵盖了Math.random()的功能。  
5、可以通过随机数去做实现随机字符串等复杂的随机数据。  
6、不要研究不重复的随机数，意义不大。