简介：在Java中，生成随机数是一项常用任务，涉及模拟、游戏编程、加密算法等场景。本文将介绍Java随机数生成的核心工具 java.util.Random 类及其使用方法，包括生成随机整数、浮点数、布尔值等。同时，对于多线程环境，将讨论 ThreadLocalRandom 类的性能优势。此外，文章还将探讨如何生成特定分布的随机数，例如正态分布，以及如何通过使用种子（seed）生成可重现的随机数序列。Java提供的随机数功能丰富，满足不同编程需求。 
1. Java随机数生成概述
在Java编程中，随机数生成是一个常见的需求，无论是进行算法测试、模拟抽奖、数据分析，还是实现游戏中的各种随机事件，都需要用到随机数。Java提供了多种方式来生成随机数，其中最常用的是 Random 类和 ThreadLocalRandom 类。本章将概述Java中随机数生成的基本概念、类的使用方法以及随机数生成在实际应用中的重要性。我们将从基础知识入手，逐步深入到高级特性和性能优化，帮助读者构建对Java随机数生成的全面理解。
2. Random类使用方法
2.1 Random类的基本使用
2.1.1 Random类的构造函数
Random类是Java中用于生成伪随机数的基础类。在Java中，伪随机数是由算法生成的看似随机的数，它们在多次运行中表现出随机性，但实际上是通过确定性计算得到的。Random类提供了一系列生成随机数的方法，包括整数、浮点数、布尔值等。
在使用Random类之前，我们通常需要调用它的构造函数来创建一个Random对象。Random类提供了两种构造函数：
public Random()
public Random(long seed)
第一种构造函数不带参数，它会根据系统时间自动生成一个种子值（seed），这个种子值用于初始化随机数生成器。第二种构造函数接受一个种子值作为参数，允许用户自定义种子值。使用相同的种子值多次实例化Random类将生成相同的随机数序列，这在调试和测试中非常有用。
2.1.2 常用的随机数生成方法
Random类提供了多个方法来生成不同类型的随机数，以下是一些常用的生成随机整数的方法：
public int nextInt()
public int nextInt(int bound)
public int nextInt(int origin, int bound)
nextInt() 方法生成一个随机的 int 值，范围从负无穷大到正无穷大。 nextInt(int bound) 生成一个随机的 int 值，范围从0（包含）到指定的上限 bound （不包含）。 nextInt(int origin, int bound) 生成一个随机的 int 值，范围从指定的下限 origin （包含）到上限 bound （不包含）。
下面是生成随机浮点数的方法：
public double nextDouble()
public float nextFloat()
nextDouble() 生成一个随机的 double 值，范围从0.0（包含）到1.0（不包含）。 nextFloat() 生成一个随机的 float 值，范围也是从0.0（包含）到1.0（不包含）。
代码逻辑解读
Random random = new Random();
int randomInt = random.nextInt(); // 生成一个随机整数
double randomDouble = random.nextDouble(); // 生成一个随机浮点数
float randomFloat = random.nextFloat(); // 生成一个随机浮点数
在上述代码中，我们首先创建了一个Random对象。然后，我们调用了 nextInt() 方法来生成一个随机整数。接着，我们使用 nextDouble() 和 nextFloat() 方法生成了一个随机浮点数和一个随机单精度浮点数。这些方法都是基于当前随机数生成器的状态来生成随机数，这个状态是由种子值（seed）和内部算法决定的。
参数说明
-
nextInt()：不接受参数，返回一个随机整数。 -
nextInt(int bound)：接受一个整数参数bound，返回一个范围在[0, bound)的随机整数。 -
nextInt(int origin, int bound)：接受两个整数参数origin和bound，返回一个范围在[origin, bound)的随机整数。 -
nextDouble()：不接受参数，返回一个范围在[0.0, 1.0)的随机双精度浮点数。 -
nextFloat()：不接受参数，返回一个范围在[0.0, 1.0)的随机单精度浮点数。
通过本章节的介绍，我们了解了Random类的基本构造函数和常用的随机数生成方法。这些基础知识为我们后续深入学习和应用Random类打下了坚实的基础。在下一节中，我们将探讨Random类的高级使用技巧，包括生成随机布尔值和指定整数范围的随机数。
2.2 Random类的高级使用
2.2.1 使用Random类生成随机布尔值
Random类提供了生成随机布尔值的方法，这对于需要随机决策的场景非常有用。例如，在游戏开发中，你可能需要随机决定玩家是否成功跳跃或者敌人是否被击败。
public boolean nextBoolean()
nextBoolean() 方法返回一个随机的布尔值，其概率为50/50，即返回true或false的概率大致相等。
代码逻辑解读
Random random = new Random();
boolean randomBoolean = random.nextBoolean();
在上述代码中，我们创建了一个Random对象，然后调用了 nextBoolean() 方法来生成一个随机的布尔值。这个方法非常简单，直接返回true或false。
参数说明
-
nextBoolean()：不接受参数，返回一个随机的布尔值。
2.2.2 使用Random类生成随机浮点数
除了整数和布尔值，Random类还可以生成随机的浮点数。这对于需要模拟现实世界中的不确定性的应用程序非常有用，例如模拟股票价格的波动。
public double nextDouble()
nextDouble() 方法生成一个随机的 double 值，范围从0.0（包含）到1.0（不包含）。这个方法是生成随机浮点数最常用的方法。
代码逻辑解读
Random random = new Random();
double randomDouble = random.nextDouble();
在上述代码中，我们创建了一个Random对象，然后调用了 nextDouble() 方法来生成一个随机的浮点数。这个方法返回一个范围在[0.0, 1.0)的随机 double 值。
参数说明
-
nextDouble()：不接受参数，返回一个范围在[0.0, 1.0)的随机double值。
2.2.3 使用Random类生成随机整数范围的指定
在很多场景下，我们可能需要生成一个指定范围内的随机整数。例如，在用户注册时，可能需要生成一个随机的验证码，这个验证码通常由数字组成，长度为6位。
public int nextInt(int bound)
public int nextInt(int origin, int bound)
nextInt(int bound) 生成一个随机的 int 值，范围从0（包含）到指定的上限 bound （不包含）。 nextInt(int origin, int bound) 生成一个随机的 int 值，范围从指定的下限 origin （包含）到上限 bound （不包含）。
代码逻辑解读
Random random = new Random();
int randomInt1 = random.nextInt(10); // 生成一个范围在[0, 10)的随机整数
int randomInt2 = random.nextInt(5, 10); // 生成一个范围在[5, 10)的随机整数
在上述代码中，我们创建了一个Random对象，然后调用了 nextInt(int bound) 方法来生成一个范围在[0, 10)的随机整数。接着，我们调用了 nextInt(int origin, int bound) 方法来生成一个范围在[5, 10)的随机整数。
参数说明
-
nextInt(int bound)：接受一个整数参数bound，返回一个范围在[0, bound)的随机整数。 -
nextInt(int origin, int bound)：接受两个整数参数origin和bound，返回一个范围在[origin, bound)的随机整数。
在本章节中，我们深入探讨了Random类的高级使用技巧，包括生成随机布尔值、随机浮点数以及指定整数范围的随机数。这些高级技巧为我们提供了更多的随机数生成选择，使我们能够更好地适应不同的应用场景。在下一节中，我们将了解如何将Random类与Java集合类和IO类结合使用，以实现更复杂的功能。
3. ThreadLocalRandom类性能优势
在多线程环境中，生成随机数的需求是非常普遍的。Java 提供了 ThreadLocalRandom 类，它是 Random 类的一个线程安全的替代品，专门为并发环境设计。本章节将详细介绍 ThreadLocalRandom 类的基本使用、性能优势分析以及实际应用场景。
3.1 ThreadLocalRandom类的基本使用
ThreadLocalRandom 是 Java 7 引入的一个线程本地的随机数生成器，用于替代 Random 类中的 next() 方法在多线程环境下的线程安全问题。 ThreadLocalRandom 通过使用线程局部变量的方式来保证线程安全。
3.1.1 ThreadLocalRandom类的构造函数
ThreadLocalRandom 类没有公开的构造函数，它提供了一个 current() 方法来获取当前线程的随机数生成器实例。这个方法会为每个线程创建或获取一个 ThreadLocalRandom 实例，确保每个线程使用独立的随机数生成器，避免了锁竞争。
ThreadLocalRandom current = ThreadLocalRandom.current();
3.1.2 ThreadLocalRandom类的常用方法
ThreadLocalRandom 提供了一系列的常用方法来生成不同类型的随机数，包括整数、长整数、布尔值、双精度浮点数等。
-
nextInt(int bound)：生成一个范围在 [0, bound) 的随机整数。 -
nextLong()：生成一个随机长整数。 -
nextBoolean()：生成一个随机布尔值。 -
nextDouble()：生成一个随机双精度浮点数。
int randomInt = current.nextInt(100); // 生成一个[0, 100)范围内的随机整数
long randomLong = current.nextLong(); // 生成一个随机长整数
boolean randomBoolean = current.nextBoolean(); // 生成一个随机布尔值
double randomDouble = current.nextDouble(); // 生成一个随机双精度浮点数
3.2 ThreadLocalRandom类的性能优势分析
ThreadLocalRandom 类的主要优势在于性能，特别是在高并发环境下。
3.2.1 与Random类的性能对比
在多线程环境中，使用 Random 类的 next() 方法可能会导致线程竞争，因为多个线程可能会共享同一个 Random 实例。每次生成随机数时，可能需要通过内部锁来同步，这会导致性能下降。相比之下， ThreadLocalRandom 为每个线程提供了独立的随机数生成器，从而避免了锁竞争，提高了性能。
3.2.2 在并发环境下的性能优势
ThreadLocalRandom 在并发环境下具有显著的性能优势。由于每个线程都有自己的随机数生成器实例，因此它们之间不会相互干扰。这不仅减少了锁的开销，而且还可以避免伪随机数生成器在多个线程之间共享种子值时可能出现的相关性问题。
3.3 ThreadLocalRandom类的实际应用场景
ThreadLocalRandom 类适用于任何需要多线程安全地生成随机数的场景。
3.3.1 多线程环境下的随机数生成
在多线程环境下的随机数生成是 ThreadLocalRandom 最典型的应用场景。例如，在多线程池中进行任务处理时，每个任务需要一个唯一的随机数序列。
3.3.2 大数据环境下的随机数生成
在大数据处理中，数据分割和并行计算是常见的处理方式。 ThreadLocalRandom 可以用于在并行计算的不同分支中生成随机数，以保证数据分割的随机性和均匀性。
public class ThreadLocalRandomExample {
public static void main(String[] args) {
// 示例：使用ThreadLocalRandom生成随机数
ThreadLocalRandom current = ThreadLocalRandom.current();
for (int i = 0; i < 10; i++) {
int randomInt = current.nextInt(100);
System.out.println("Generated random integer: " + randomInt);
}
}
}
以上代码展示了如何在多线程环境下使用 ThreadLocalRandom 生成随机整数。每个线程都会有自己的随机数生成器实例，因此不会出现线程间的竞争。
在本章节中，我们介绍了 ThreadLocalRandom 类的基本使用方法、性能优势以及实际应用场景。通过与 Random 类的对比，我们可以看到 ThreadLocalRandom 在多线程环境下的显著优势。下一章节将继续深入探讨特定分布随机数生成的原理和方法。
4. 特定分布随机数生成
在本章节中，我们将深入探讨如何在Java中生成具有特定分布的随机数。这包括均匀分布、正态分布以及其他类型的分布，如指数分布和泊松分布。我们将从每个分布的基本原理开始，然后展示如何使用 Random 类和 ThreadLocalRandom 类来生成这些分布的随机数。
4.1 均匀分布随机数生成
4.1.1 均匀分布随机数生成的基本原理
均匀分布，也称为矩形分布，是一种每个值出现概率相同的随机分布。在均匀分布中，所有值的概率密度是常数，这意味着在给定的区间内每个值出现的概率是相等的。均匀分布通常用于模拟随机事件，其中每个可能的结果都是等可能的。
4.1.2 使用Random类生成均匀分布随机数
Random 类提供了 nextDouble() 和 nextInt() 等方法，可以用来生成均匀分布的随机数。例如， nextDouble() 方法生成一个0.0到1.0之间的随机浮点数，而 nextInt(int bound) 方法生成一个从0（包含）到指定边界（不包含）之间的随机整数。
Random random = new Random();
double uniformDouble = random.nextDouble(); // 生成0.0到1.0之间的均匀分布随机浮点数
int uniformInt = random.nextInt(10); // 生成0到9之间的均匀分布随机整数
4.1.3 使用ThreadLocalRandom类生成均匀分布随机数
ThreadLocalRandom 类是Java并发包中的一个工具类，用于在多线程环境下生成线程安全的随机数。它的 nextDouble() 和 nextInt(int bound) 方法也可以用于生成均匀分布的随机数。
ThreadLocalRandom random = ThreadLocalRandom.current();
double uniformDouble = random.nextDouble(); // 生成0.0到1.0之间的均匀分布随机浮点数
int uniformInt = random.nextInt(10); // 生成0到9之间的均匀分布随机整数
4.1.4 均匀分布随机数生成的表格展示
| 方法 | 描述 | 示例 | | --- | --- | --- | | Random.nextDouble() | 生成一个0.0到1.0之间的均匀分布随机浮点数 | double uniformDouble = random.nextDouble(); | | Random.nextInt(int bound) | 生成一个0到指定边界之间的均匀分布随机整数 | int uniformInt = random.nextInt(10); | | ThreadLocalRandom.nextDouble() | 生成一个0.0到1.0之间的均匀分布随机浮点数（线程安全） | double uniformDouble = ThreadLocalRandom.current().nextDouble(); | | ThreadLocalRandom.nextInt(int bound) | 生成一个0到指定边界之间的均匀分布随机整数（线程安全） | int uniformInt = ThreadLocalRandom.current().nextInt(10); |
4.2 正态分布随机数生成
4.2.1 正态分布随机数生成的基本原理
正态分布，也称为高斯分布，是一种常见的连续概率分布。它的图形呈现出对称的钟形曲线，大部分的数据值集中在平均值附近，而数据值远离平均值的概率逐渐减小。正态分布通常用于模拟自然和社会现象中的随机变量。
4.2.2 使用Random类生成正态分布随机数
Random 类的 nextGaussian() 方法可以用来生成正态分布的随机数。该方法返回一个均值为0，标准差为1的正态分布随机数。
Random random = new Random();
double gaussian = random.nextGaussian(); // 生成均值为0，标准差为1的正态分布随机数
4.2.3 使用ThreadLocalRandom类生成正态分布随机数
虽然 ThreadLocalRandom 类没有直接提供正态分布随机数的生成方法，但可以通过组合 nextDouble() 方法和数学公式来实现。
ThreadLocalRandom random = ThreadLocalRandom.current();
double mean = 50.0; // 均值
double stdDev = 10.0; // 标准差
double normalRandom = mean + stdDev * Math.sqrt(-2 * Math.log(random.nextDouble())) * Math.cos(2 * Math.PI * random.nextDouble());
4.2.4 正态分布随机数生成的流程图展示
graph LR
A[开始] --> B{生成均匀分布随机数}
B --> C{应用Box-Muller变换}
C --> D[得到正态分布随机数]
D --> E[结束]
4.3 其他分布随机数生成
4.3.1 指数分布随机数生成
指数分布是一种描述独立随机事件发生时间间隔的概率分布。在Java中，可以使用Apache Commons Math库中的 ExponentialDistribution 类来生成指数分布的随机数。
4.3.2 泊松分布随机数生成
泊松分布是一种描述单位时间（或单位面积）内随机事件发生次数的概率分布。在Java中，可以使用Apache Commons Math库中的 PoissonDistribution 类来生成泊松分布的随机数。
PoissonDistribution poisson = new PoissonDistribution(0.5); // 创建泊松分布实例，平均发生率为0.5
int poissonRandom = poisson.nextInt(); // 生成一个泊松分布随机数
在本章节中，我们介绍了如何在Java中使用 Random 类和 ThreadLocalRandom 类生成均匀分布、正态分布、指数分布和泊松分布的随机数。我们从每个分布的基本原理开始，然后展示了如何使用Java中的类和方法来实现这些分布的随机数生成。通过这些示例，我们可以看到Java提供了强大的工具来满足各种随机数生成需求。
5. 种子（seed）的作用与实现
5.1 种子（seed）的基本概念
5.1.1 种子的定义
在Java的随机数生成过程中，种子（seed）是一个关键的概念，它是一个初始化随机数生成器的数值。随机数生成器会根据种子值产生一系列看似随机的数值序列。种子的值相同，产生的随机数序列也将相同。这意味着，如果两个随机数生成器使用了相同的种子值，那么它们在完全相同的条件下将生成完全相同的随机数序列。
5.1.2 种子的作用
种子的主要作用是为随机数生成器提供一个起始点，确保随机数生成的可重现性。在某些情况下，例如在进行软件测试或者需要重复实验结果时，能够生成相同的随机数序列是非常重要的。此外，合理的种子选择和管理还能够提高随机数生成的性能和质量。
5.2 种子的设置与获取
5.2.1 Random类的种子设置与获取
在Java中， Random 类的实例默认使用一个种子值，这个种子值是基于系统时钟的当前时间。然而，我们也可以手动设置种子值，以确保随机数生成的可重现性。
import java.util.Random;
public class SeedExample {
public static void main(String[] args) {
Random random = new Random();
// 获取当前种子值
int seed = random.nextInt();
System.out.println("Current seed: " + seed);
// 使用种子值创建新的Random实例
Random seededRandom = new Random(seed);
// 生成随机数
for (int i = 0; i < 10; i++) {
System.out.println(seededRandom.nextInt());
}
}
}
在上述代码中，我们首先创建了一个 Random 实例，并打印了它的种子值。然后，我们使用这个种子值创建了一个新的 Random 实例，并生成了一系列随机数。由于种子值相同，因此两个实例生成的随机数序列也将相同。
5.2.2 ThreadLocalRandom类的种子设置与获取
ThreadLocalRandom 类是Java 7中引入的，用于在多线程环境下生成更加高效的随机数。它不提供直接获取或设置种子的方法，而是通过内部机制来管理种子值，以确保多线程环境下的线程安全。
import java.util.concurrent.ThreadLocalRandom;
public class ThreadLocalSeedExample {
public static void main(String[] args) {
// 获取当前种子值
long seed = ThreadLocalRandom.current().nextLong();
System.out.println("Current seed: " + seed);
// 生成随机数
for (int i = 0; i < 10; i++) {
System.out.println(ThreadLocalRandom.current().nextInt());
}
}
}
在上述代码中，我们使用 ThreadLocalRandom.current() 方法获取当前线程的 ThreadLocalRandom 实例，并打印了它的种子值。但是，由于 ThreadLocalRandom 的设计，我们无法直接获取或设置其种子值。
5.3 种子的重置与影响
5.3.1 种子重置的原理
种子重置是指修改随机数生成器内部种子值的过程。在 Random 类中，种子值是通过 java.util.Random.SeedGenerator 类生成的，它基于系统时钟。种子重置通常用于测试或者确保随机数生成的可重现性。
5.3.2 种子对随机数生成的影响
种子值对于随机数生成器的行为有着直接的影响。相同的种子值会产生相同的随机数序列，这在需要重复实验或者调试程序时非常有用。然而，在大多数应用场景中，我们希望随机数生成器能够产生不同且不可预测的随机数序列，因此通常使用系统时钟作为种子值。
表格：种子值对随机数序列的影响
| 种子值 | 随机数序列 | |--------|------------| | 12345 | 4, 12, 8, ... | | 12345 | 4, 12, 8, ... | | 67890 | 23, 5, 11, ... |
在上表中，我们展示了相同的种子值产生相同的随机数序列，以及不同的种子值产生不同的随机数序列的例子。
总结：
本章节介绍了Java中随机数生成器的种子（seed）的概念、种子的设置与获取方法以及种子重置对随机数生成的影响。通过理解种子的作用和如何管理种子值，开发者可以更好地控制随机数生成的过程，以适应不同的应用需求。
6. Java随机数算法实践应用
6.1 随机数算法的理论基础
随机数算法是计算机程序设计中的一个重要组成部分，它在各种应用领域中扮演着关键角色，从游戏开发到科学研究，再到安全加密，随机数都发挥着不可替代的作用。随机数生成算法的基本原理涉及到数学统计学中的随机性理论，其核心在于生成具有统计特性的伪随机数序列。
6.1.1 随机数生成算法的原理
随机数生成算法通常基于一定的数学模型，这些模型可以是线性同余生成器、逆变换法、Ziggurat算法等。这些算法通过对数学模型的迭代，生成一系列在数学期望上均匀分布的随机数。例如，线性同余生成器通过以下递推关系生成随机数序列：
X_{n+1} = (aX_n + c) mod m
其中， a 、 c 、 m 是算法的参数，它们决定了随机数序列的周期性和均匀性。逆变换法则是基于累积分布函数的逆函数来生成随机数，它首先生成一个[0, 1]区间内的均匀随机数，然后通过逆累积分布函数转换成目标分布的随机数。
6.1.2 随机数生成算法的选择
选择合适的随机数生成算法需要考虑多个因素，包括随机性质量、性能、生成速度、内存消耗等。例如，对于高性能要求的应用场景，可能会选择基于硬件的随机数生成器或快速的伪随机数生成算法。而对于需要高质量随机性的场景，如安全加密，可能会选择基于密码学原理的随机数生成算法，这些算法通常提供更好的随机性和不可预测性。
6.2 随机数算法的应用实践
随机数算法在实际应用中的场景非常广泛，它们在游戏、安全加密、科学研究等领域中发挥着至关重要的作用。
6.2.1 随机数算法在游戏中的应用
在游戏开发中，随机数算法被用来生成各种随机事件，如角色位置、敌人出现的概率、掉落物品的随机性等。这不仅增加了游戏的可玩性，也是实现游戏平衡的重要手段。例如，在一个RPG游戏中，玩家可能会遇到随机的NPC，这些NPC的行为或对话可以通过随机数算法来控制。
// 示例：使用Random类生成一个随机事件
Random random = new Random();
int eventType = random.nextInt(10); // 生成一个[0, 9]之间的随机数
switch (eventType) {
case 0:
// 遇到商人
break;
case 1:
// 遇到敌人
break;
// 其他事件...
}
6.2.2 随机数算法在安全加密中的应用
在安全加密领域，随机数算法是构建加密系统的基础。加密算法中的密钥往往需要是随机且不可预测的，以确保通信的安全性。例如，TLS协议中使用随机数来生成会话密钥，这个随机数需要高质量的随机性来防止被预测和攻击。
6.2.3 随机数算法在科学研究中的应用
在科学研究中，随机数算法被用来模拟各种自然现象或社会行为。例如，在物理模拟中，随机数可以用来模拟粒子的运动轨迹，或者在经济学研究中模拟市场行为。在这些场景中，随机数的高质量直接关系到模拟结果的准确性和可靠性。
6.3 随机数算法的性能优化
随着应用场景的复杂化，对随机数生成算法的性能要求也越来越高。性能优化不仅涉及算法本身，还包括随机数生成的上下文环境。
6.3.1 随机数算法的优化策略
优化随机数生成算法的策略包括使用更高效的算法实现、减少随机数生成的开销、并行化随机数生成等。例如， ThreadLocalRandom 类在多线程环境下提供比 Random 类更好的性能，因为它避免了线程间的竞争。
6.3.2 随机数算法的性能评估方法
性能评估通常涉及到随机数生成的速度、均匀性、随机性质量等指标。可以通过统计测试和随机性分析工具来评估随机数算法的性能。例如，可以使用 Dieharder 这样的工具来测试随机数序列的随机性质量。
6.3.3 随机数算法的优化实例分析
在实际应用中，优化随机数算法往往需要结合具体的应用场景。例如，在需要高性能的并发环境中，可以结合 ThreadLocalRandom 类和并发集合来优化随机数的生成效率。
// 示例：使用ThreadLocalRandom生成并行随机数
ExecutorService executorService = Executors.newFixedThreadPool(10);
IntStream.range(0, 100).forEach(i -> executorService.submit(() -> {
int randomValue = ThreadLocalRandom.current().nextInt(100);
System.out.println("Random Value: " + randomValue);
}));
executorService.shutdown();
这个示例展示了如何在并行环境中使用 ThreadLocalRandom 生成随机数，每个线程都有自己独立的随机数生成器实例，避免了线程间的竞争，提高了性能。
简介：在Java中，生成随机数是一项常用任务，涉及模拟、游戏编程、加密算法等场景。本文将介绍Java随机数生成的核心工具 java.util.Random 类及其使用方法，包括生成随机整数、浮点数、布尔值等。同时，对于多线程环境，将讨论 ThreadLocalRandom 类的性能优势。此外，文章还将探讨如何生成特定分布的随机数，例如正态分布，以及如何通过使用种子（seed）生成可重现的随机数序列。Java提供的随机数功能丰富，满足不同编程需求。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
