Java 中的随机数

在 Java 编程中，随机数生成是一个常见需求，广泛应用于游戏、加密、测试等领域。Java 提供了多种生成随机数的方式，每种方式都有其特点和适用场景。本文将详细介绍 Java 中常用的随机数生成方法，并通过代码示例展示其使用方式。

一、java.util.Random 类

基本用法

Random类是 Java 最早提供的随机数生成器，位于java.util包下。它通过线性同余算法生成伪随机数。

java

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        // 创建Random对象
        Random random = new Random();
        
        // 生成随机整数
        int randomInt = random.nextInt();
        System.out.println("随机整数: " + randomInt);
        
        // 生成0到99之间的随机整数
        int randomIntBound = random.nextInt(100);
        System.out.println("0-99之间的随机整数: " + randomIntBound);
        
        // 生成随机布尔值
        boolean randomBoolean = random.nextBoolean();
        System.out.println("随机布尔值: " + randomBoolean);
        
        // 生成随机浮点数(0.0到1.0之间)
        double randomDouble = random.nextDouble();
        System.out.println("随机浮点数: " + randomDouble);
    }
}

特点

1. 线程安全：Random类是线程安全的，可以在多线程环境下使用，但性能较低。
2. 伪随机数：生成的是伪随机数，相同种子会生成相同的随机序列。
3. 种子控制：可以通过构造函数指定种子，如Random(long seed)。

示例：指定种子生成随机数

java

import java.util.Random;

public class SeededRandomExample {
    public static void main(String[] args) {
        // 使用相同的种子创建两个Random对象
        Random random1 = new Random(123);
        Random random2 = new Random(123);
        
        // 生成相同的随机序列
        System.out.println("random1生成的随机数:");
        for (int i = 0; i < 3; i++) {
            System.out.print(random1.nextInt(100) + " ");
        }
        
        System.out.println("\nrandom2生成的随机数:");
        for (int i = 0; i < 3; i++) {
            System.out.print(random2.nextInt(100) + " ");
        }
    }
}

二、java.security.SecureRandom 类

基本用法

SecureRandom类提供了更安全的随机数生成，适用于加密、安全认证等场景。

java

import java.security.SecureRandom;

public class SecureRandomExample {
    public static void main(String[] args) throws Exception {
        // 创建SecureRandom对象
        SecureRandom secureRandom = SecureRandom.getInstanceStrong();
        
        // 生成随机字节数组
        byte[] bytes = new byte[16];
        secureRandom.nextBytes(bytes);
        System.out.println("随机字节数组: " + bytesToHex(bytes));
        
        // 生成安全的随机整数
        int secureRandomInt = secureRandom.nextInt(100);
        System.out.println("安全的随机整数: " + secureRandomInt);
    }
    
    // 辅助方法：将字节数组转换为十六进制字符串
    private static String bytesToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        return result.toString();
    }
}

特点

1. 高安全性：使用更复杂的算法生成随机数，适用于安全敏感场景。
2. 性能较低：相比Random类，生成随机数的性能较低。
3. 不可预测性：生成的随机数更难预测，种子通常来源于系统熵。

常见算法

• SHA1PRNG：基于 SHA-1 算法的伪随机数生成器。
• NativePRNG：使用操作系统提供的随机数生成器。

三、Java 8+ 的 ThreadLocalRandom 类

基本用法

ThreadLocalRandom是 Java 8 引入的线程局部随机数生成器，继承自Random类。

java

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomExample {
    public static void main(String[] args) {
        // 获取当前线程的ThreadLocalRandom实例
        ThreadLocalRandom random = ThreadLocalRandom.current();
        
        // 生成随机整数
        int randomInt = random.nextInt(10, 20);
        System.out.println("10-19之间的随机整数: " + randomInt);
        
        // 生成随机长整型
        long randomLong = random.nextLong(1000);
        System.out.println("0-999之间的随机长整型: " + randomLong);
        
        // 生成随机浮点数
        double randomDouble = random.nextDouble(5.0, 10.0);
        System.out.println("5.0-10.0之间的随机浮点数: " + randomDouble);
    }
}

特点

1. 线程安全且高效：每个线程独立维护一个随机数生成器，避免了多线程竞争，性能优于Random。
2. 不可实例化：通过静态方法current()获取实例。
3. 范围生成：支持直接生成指定范围内的随机数。

四、Java 8+ 的 Random API 增强

Java 8 在java.util.Random类中新增了一些方法，支持生成流和并行生成随机数。

生成随机数流

java

import java.util.Random;
import java.util.stream.IntStream;

public class RandomStreamExample {
    public static void main(String[] args) {
        Random random = new Random();
        
        // 生成10个0-99之间的随机整数流
        IntStream intStream = random.ints(10, 0, 100);
        intStream.forEach(System.out::println);
        
        // 生成无限的随机整数流
        // random.ints().limit(5).forEach(System.out::println);
    }
}

并行生成随机数

java

import java.util.Random;

public class ParallelRandomExample {
    public static void main(String[] args) {
        Random random = new Random();
        
        // 并行生成1000个随机整数，并计算平方和
        long sum = random.ints(1000)
                       .parallel()
                       .mapToLong(i -> (long) i * i)
                       .sum();
        
        System.out.println("随机整数的平方和: " + sum);
    }
}

特点

1. 流式 API 支持
   通过ints()、longs()、doubles()方法返回随机数流，支持函数式编程和链式调用，便于集合操作。

2. 并行生成能力
   配合 Java 8 的并行流（parallel()），可充分利用多核 CPU 并行生成随机数，大幅提升吞吐量。

3. 范围定制
   支持直接指定生成随机数的范围，如ints(origin, bound)生成[origin, bound)区间的整数，减少手动边界处理。

4. 无限流与限制
   可生成无限随机数流（如random.ints()），结合limit()方法按需截断，适用于需要大量随机数的场景。

五、Math.random () 方法

基本用法

Math.random()是一个静态方法，返回一个[0.0, 1.0)之间的双精度浮点数。

java

public class MathRandomExample {
    public static void main(String[] args) {
        // 生成随机浮点数
        double random = Math.random();
        System.out.println("随机浮点数: " + random);
        
        // 生成1-10之间的随机整数
        int randomInt = (int) (Math.random() * 10) + 1;
        System.out.println("1-10之间的随机整数: " + randomInt);
    }
}

实现原理

Math.random()内部使用Random类实现，等价于：

java

new Random().nextDouble()

特点

1. 简洁易用
   无需创建实例，直接通过静态方法调用，适合快速生成简单随机数。

2. 内部实现
   基于Random类实现，等价于new Random().nextDouble()，生成[0.0, 1.0)区间的双精度浮点数。

3. 线程安全
   内部使用Random实例，通过原子操作保证线程安全，但多线程环境下存在竞争。

4. 局限性

   • 仅支持生成double类型随机数，范围固定为[0.0, 1.0)。
   • 生成整数需手动转换，如(int)(Math.random() * n)生成[0, n-1]之间的整数，可能导致精度丢失。

六、各随机数生成方式对比

方式	线程安全性	性能	随机性强度	适用场景
Random	安全	中等	中等	普通场景，如游戏、模拟
SecureRandom	安全	低	高	安全敏感场景，如加密、认证
ThreadLocalRandom	安全	高	中等	多线程环境
Math.random()	安全	中等	中等	简单随机数需求

七、面试题

1. Random 类是线程安全的吗？

是的，Random类是线程安全的，但在多线程环境下性能较低，因为多个线程共享同一个随机数生成器，需要竞争锁。

2. SecureRandom 与 Random 的区别是什么？

• SecureRandom提供更高的安全性，生成的随机数更难预测，适用于安全敏感场景。
• Random性能更高，但随机性较弱，适用于普通场景。

3. 如何在 Java 中生成安全的随机密码？

可以使用SecureRandom生成随机字节数组，并将其转换为 Base64 或十六进制字符串：

java

import java.security.SecureRandom;
import java.util.Base64;

public class SecurePasswordGenerator {
    public static String generatePassword(int length) {
        SecureRandom secureRandom = new SecureRandom();
        byte[] bytes = new byte[length];
        secureRandom.nextBytes(bytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
    }
    
    public static void main(String[] args) {
        System.out.println("安全随机密码: " + generatePassword(16));
    }
}

总结

Java 提供了多种随机数生成方式，开发者应根据具体需求选择合适的方法：

• 普通场景使用Random或Math.random()。
• 多线程环境使用ThreadLocalRandom。
• 安全敏感场景使用SecureRandom。

掌握这些随机数生成方法的特点和适用场景，能够帮助开发者在实际项目中更好地应用随机数，提高程序的安全性和性能。