JAVA中一类随机数生成方法设计思想

合集下载

Java生成随机数（random（）和Random类）

Java生成随机数（random（）和Random类）是调用Math类的random()方法，一种是使用Random类。

Random类提供了丰富的随机数生成方法，可以产生boolean、id main(String[] args) {Random r = new Random(); double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数int i1 = r.nextInt(10); // 生成[0,10]区间的整数int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数long l1 = r.nextLong(); // 生成一个随机长整型值boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值float f1 = r.nextFloat(); // 生成一个随机浮点型值System.out.println("生成的[0,1.0]区间的小数是：" + d1);System.out.println("生成的[0,7.0]区间的小数是：" + d2);System.out.println("生成的[0,10]区间的整数是：" + i1);System.out.println("生成的[-3,15]区间的整数是：" + i2);System.out.println("生成一个随机长整型值：" + l1);System.out.println("生成一个随机布尔型值：" + b1);System.out.println("生成一个随机浮点型值：" + f1);System.out.print("下期七星彩开奖号码预测："); for (int i = 1; i < 8; i++) { int num = r.nextInt(9); // 生成[0,9]区间的整数System.out.print(num);}}}12345678910111213141516171819202122232425复制代码类型：[java]本实例每次运行时结果都不相同，这就实现了随机产生数据的功能。

java随机数生成方法

java随机数生成方法Java是一种非常流行的编程语言，它提供了许多功能强大的工具和函数，用于生成随机数。

随机数在计算机编程中有着广泛的应用，可以用于模拟实验、加密算法、游戏开发等领域。

本文将介绍几种常见的Java随机数生成方法，并给出使用示例。

1. Math.random()方法Math类是Java中提供的一个数学工具类，其中的random()方法可以生成一个0到1之间的随机数。

具体用法如下：```javadouble randomNum = Math.random();System.out.println(randomNum);```上述代码将打印出一个0到1之间的随机数。

需要注意的是，Math.random()生成的随机数是一个double类型的值，范围是[0,1)，即包含0，不包含1。

2. Random类Java中的Random类提供了更加灵活和丰富的随机数生成方法。

该类可以用于生成不同类型的随机数，如整数、浮点数等。

下面是一个使用Random类生成随机整数的示例：```javaRandom random = new Random();int randomInt = random.nextInt(100); // 生成0到99之间的随机整数System.out.println(randomInt);```上述代码将生成一个0到99之间的随机整数，并将其打印出来。

3. ThreadLocalRandom类Java 7中引入了ThreadLocalRandom类，它是Random的一个线程安全版本，可以在多线程环境下使用。

下面是一个使用ThreadLocalRandom类生成随机浮点数的示例：```javadouble randomDouble = ThreadLocalRandom.current().nextDouble(0, 1);System.out.println(randomDouble);```上述代码将生成一个0到1之间的随机浮点数，并将其打印出来。

Java中产生随机数

一、利用random方法来生成随机数。

在Java语言中生成随机数相对来说比较简单，因为有一个现成的方法可以使用。

在Math类中，Java语言提供了一个叫做random的方法。

通过这个方法可以让系统产生随机数。

不过默认情况下，其产生的随机数范围比较小，为大于等于0到小于1的double型随机数。

虽然其随机数产生的范围比较小，不能够满足日常的需求。

如日常工作中可能需要产生整数的随机数。

其实，只要对这个方法进行一些灵活的处理，就可以获取任意范围的随机数。

如我们可以先通过random方法生成一个随机数，然后将结果乘以10。

此时产生的随机数字即为大于等于0小于10的数字。

然后再利用Int方法进行转换(它会去掉小数掉后面的数字，即只获取整数部分，不是四舍五入)。

最后即可获取一个0到9的整数型随机数字。

其实现方法很简单，就是对原有的random方法按照如下的格式进行变型：(int)(Math.Random()*10)即可。

其实我们还可以对这个方法进行扩展，让其产生任意范围内的随机数。

至需要将这个10换成n即可，如改为(int)(Math.Random()*n)。

此时应用程序就会产生一个大于等于0小与n之间的随机数。

如将n设置为5，那么其就会产生一个0到5之间的整数型的随机数。

如果将这个写成一个带参数的方法，那么只要用户输入需要生成随机数的最大值，就可以让这个方法来生成制定范围的随机数。

在Java中定义自己的工具库有时候程序员可能需要生成一个指定范围内的随机偶数或者奇数。

此时是否可以通过这个方法来实现呢?答案是肯定的。

如现在程序要需要生成一个1-100范围内的偶数。

此时该如何实现?首先，需要生成一个0到99之内的随机数(至于这里为什么是99，大家耐心看下去就知道原因了)。

要实现这个需求，很简单吧，只要通过如下语句就可以实现：i=1+(int)(Math.Random()*100)。

其中(int)(Math.Random()*99)产生0到99的整数型随机数。

java 生成随机数原理

java 生成随机数原理生成随机数是Java编程中常用的功能，遍布在各种应用领域。

在Java中，生成随机数的理论基础是伪随机数生成器（Pseudo-Random Number Generator，PRNG）。

伪随机数生成器是一种算法，根据一定规则生成一系列看似无规律的数列，用于模拟真实的随机数，但实际上是有规律的，并不能真正满足真正意义上的“随机”。

Java中自带了一个随机数生成器类：java.util.Random。

它的生成原理是以系统当前时间为种子，再用种子值通过一个算法计算出一系列看似无规律的数列。

因此，每次创建Random对象时，都会使用不同的种子值，生成不同的随机数序列（除非在创建Random对象时手动设置了seed种子值）。

在每次生成随机数时，Random对象使用了一个精心设计的算法来生成下一个随机数，这些算法必须满足一下原则：1. 易于计算–随机数生成器的算法必须是轻松计算的，否则就无法满足高效性的要求。

2. 在随机数被假名为接收者前无法预测–程序无法预知随机数生成器生成的值，这是制造真正的随机性的必要条件。

3. 均匀分布的数字–生成器的算法必须是均匀分布的，否则就会生成大量的某些数，而对其它值几乎没有覆盖。

Java中的Random类提供了nextInt()，nextDouble()等方法，用于生成不同类型的随机数。

通过这些方法产生的随机数是一系列介于0.0到1.0（大多数）之间的数字，这些数字可以被映射到要生成的范围内，例如范围在0和100之间的整数。

下面是一个简单的示例代码：在上述代码中，RandomNumberGenerator 类中生成了5个介于0和100之间的整数。

因为Random类使用当前时间作为种子，所以每次运行程序都会得到不同的结果。

在Java中，有时候我们需要保证生成的随机数是相同的，例如在测试中我们需要重现某段代码的执行结果。

为了实现这个目标，我们可以在Random类的构造函数中传入一个确定性的种子值，这个种子值保证在相同的环境下生成的随机数序列是相同的，示例如下：在上述代码中，使用了确定性的种子值123，结果将是相同的每一次运行，因为它确保了每次生成相同的随机数序列。

惊艳面试官-Java中关于随机数生成8种方式的思考

惊艳面试官-Java中关于随机数生成8种方式的思考Java中生成随机数常用的有下面这8种写法：简而言之，名称带安全的未必安全，名字简洁的未必简单。

o Math.random()o Randomo ThreadLocalRandomo SecureRandomo UUID.randomUUID()o RandomStringUtilso RandomUtilso RandomUtilMath.random()Talk is cheap, show me the code. 先上源码：public static double random() {returnRandomNumberGeneratorHolder.randomNumberGenerator.nex tDouble();}private static final class RandomNumberGeneratorHolder {static final Random randomNumberGenerator = new Random();}从源码可以看出：Math.random本质上用的就是new Random。

而且人家给了一个最佳实践：使用的时候不用每次就new一个对象，直接做成一个静态类就可以了。

RandomRandom是伪随机数类，采用线性同余算法产生的。

伪随机数是1946年冯诺依曼提出来的。

他在参加一个氢弹的制造项目，需要大量的随机数模拟核聚变、核裂变。

因为当时设备没办法去存储大量的随机数，所以就想到了这个办法。

伪随机数(或称伪乱数)这个称呼是因为真随机数都不是计算出来的。

这里是使用一个确定性的算法计算出来的似乎是随机的数序，因此伪随机数实际上并不随机。

从更宏大的视角看来，是非常有规律的，就像我在《大话高可用》里提到的炊烟。

下面来说说这个线性同余算法，大家不用担心。

我比大家还对算法一窍不通。

但是我有人类的常识，这个常识是什么呢？既然是计算得到的，并且人类看起来没有规律，那一定有一个外部因子(种子)，种子是一个变量。

随机数算法 java

随机数算法 java随机数是计算机程序设计中经常用到的一种算法，其主要作用是生成一个在一定范围内的随机数。

在Java中，有多种方式可以生成随机数，其中最常见的就是使用Java内置的随机数生成器类Random。

Random类的使用方法比较简单，我们只需要在需要随机数的地方对其进行实例化，然后调用其nextInt()方法即可。

例如，以下代码可以生成一个在1到100之间的随机整数：```Random random = new Random();int randNum = random.nextInt(100) + 1;```上述代码首先实例化了一个Random对象，然后调用nextInt()方法生成了一个在0到99之间的随机整数，并将其加1后赋值给randNum 变量。

除了上述方式外，我们还可以使用Math.random()方法生成一个在0到1之间的随机数，并根据需要进行转换：```double randDouble = Math.random(); // randDouble的值在0到1之间int randNum = (int)(Math.random() * 100) + 1; // randNum的值在1到100之间```需要注意的是，使用Math.random()方法生成随机数时需要进行类型转换，并根据需要进行范围限制。

除了上述两种方式外，我们还可以使用SecureRandom类生成更加安全的随机数。

SecureRandom类使用了更加复杂的算法，因此生成的随机数更加安全可靠。

以下是一个使用SecureRandom类生成随机数的示例代码：```SecureRandom random = new SecureRandom();byte[] bytes = new byte[16];random.nextBytes(bytes);```上述代码首先实例化了一个SecureRandom对象，然后调用nextBytes()方法生成一个由16个字节组成的随机数。

java随机数的用法

java随机数的用法1.介绍随机数在计算机领域是非常常见且重要的概念之一。

在Ja va编程语言中，我们可以使用内置的随机数生成器来创建随机数。

本文将介绍J a va中生成随机数的几种常用方法以及它们的用法。

2. ja va.util.Rando m类J a va提供了`ja va.u t il.R an do m`类来生成伪随机数。

下面是随机数生成的基本步骤：1.创建一个`R an do m`类的实例对象。

2.使用实例对象的方法来生成具有不同特性的随机数。

2.1生成随机整数`R an do m`类的`n ext I nt()`方法用于生成随机整数。

以下是一个使用`n ex tI nt()`方法生成随机整数的示例代码：i m po rt ja va.u ti l.R a nd om;p u bl ic cl as sR an dom E xa mp le{p u bl ic st at ic vo idm a in(S tr in g[]a rgs){R a nd om ra nd om=n ewR a nd om();i n tr an do mN um be r=r a nd om.n ex tI nt();S y st em.o ut.p ri ntl n("随机整数为："+r an do mN um be r);}}2.2生成指定范围的随机整数如果我们需要生成指定范围内的随机整数，可以使用`n ex tI nt(i nt bo und)`方法。

该方法将返回一个大于等于0且小于b o un d的随机整数。

下面是一个示例代码：i m po rt ja va.u ti l.R a nd om;p u bl ic cl as sR an dom E xa mp le{p u bl ic st at ic vo idm a in(S tr in g[]a rgs){R a nd om ra nd om=n ewR a nd om();i n tm in=10;i n tm ax=20;i n tr an do mN um be r=r a nd o m.n ex tI nt(ma x-m in)+mi n;S y st em.o ut.p ri ntl n("随机整数为："+r an do mN um be r);}}2.3生成随机浮点数`R an do m`类的`n ext D ou bl e()`方法用于生成0.0到1.0之间的随机浮点数。

java随机数random原理

java随机数random原理Java中的随机数（random）是非常常见和重要的一个功能，它在很多应用场景中被广泛使用。

随机数是指按照一定的规律，但是不可预测的方式生成的数值。

在Java中，我们可以使用Random类来生成随机数。

Random类是Java提供的一个伪随机数生成器，它使用一个48位的种子，通过线性同余法生成随机数序列。

它的种子可以手动设置，也可以由系统自动生成。

如果不指定种子，则会使用系统当前的时间作为种子。

在使用Random类生成随机数之前，我们需要先创建一个Random对象。

可以通过无参构造方法创建一个默认的Random 对象，也可以通过指定种子的方式创建一个Random对象。

例如，以下代码创建了一个默认的Random对象和一个指定种子的Random对象：```javaRandom random1 = new Random(); // 创建一个默认的Random对象Random random2 = new Random(12345); // 创建一个指定种子的Random对象```生成随机数的方法主要有两种：nextInt()和nextDouble()。

nextInt()方法可以生成一个整数类型的随机数，其范围是整个int 类型的取值范围（-2^31到2^31-1）。

nextDouble()方法可以生成一个双精度浮点数类型的随机数，其范围是0.0到1.0之间。

下面的代码演示了如何使用Random类生成随机数：```javaRandom random = new Random();int randomNumber = random.nextInt(); // 生成一个整数类型的随机数double randomDouble = random.nextDouble(); // 生成一个双精度浮点数类型的随机数```除了生成随机数之外，Random类还提供了一些其他的功能。

比如，我们可以通过设置种子的方式使得随机数序列可预测。

java随机数生成算法

Java随机数生成算法随机数在计算机领域中扮演着非常重要的角色，它们被广泛应用于密码学、模拟实验、游戏开发和随机算法等领域。

Java作为一种广泛使用的编程语言，提供了多种方法来生成随机数。

本文将深入探讨Java中随机数生成算法的原理、使用方法和最佳实践。

随机数的定义随机数是指按照某种规律在一定范围内生成的数序列，它们之间不存在明显的联系或规律。

随机数要具备以下特点：1.均匀性（Uniformity）：在理想情况下，随机数生成器应该能够生成均匀分布的随机数，即在给定的范围内，每个数字都有相同的概率被选中。

2.独立性（Independence）：生成的随机数应该相互独立，即前一个生成的随机数不应该影响后一个的生成。

3.复现性（Reproducibility）：为了调试和验证，随机数生成器应该具备可复现性，即相同的种子（seed）生成的随机数序列应该完全一致。

Java中的随机数生成器Java提供了两种不同的随机数生成器：java.util.Random类和java.security.SecureRandom类。

其中，java.util.Random类提供了伪随机数生成器，而java.security.SecureRandom类提供了加密级别的安全随机数生成器。

伪随机数生成器（Pseudo-random Number Generator，PRNG）java.util.Random类基于线性同余算法（Linear Congruential Generator，LCG）实现了随机数生成器。

它的生成规则可以表示为：Xn+1 = (a * Xn + c) mod m其中，Xn+1是下一个生成的随机数，Xn是当前的随机数，a、c、m是固定的常数。

通过不断迭代，可以生成一个伪随机数序列。

使用java.util.Random生成随机数的基本步骤如下：1.创建一个Random对象。

2.可选：设置随机数种子。

如果不设置种子，则使用系统时间作为默认种子。

java随机数生成算法

java随机数生成算法Java是一种广泛使用的编程语言，它有许多内置的函数和类库，可以帮助开发人员轻松生成随机数。

生成随机数在计算机科学中是一个非常重要的问题，因为许多应用程序需要使用随机数。

在本文中，我们将探讨Java中的随机数生成算法。

Java中的随机数生成算法Java提供了两种主要的随机数生成算法：伪随机数生成器和真随机数生成器。

伪随机数生成器伪随机数生成器是一种基于确定性算法的方法，它使用一个初始值（称为种子）来产生一个序列的数字。

这个序列看起来像是完全无序的，但实际上是由一个确定性算法产生的。

因此，这些数字被称为“伪”随机数。

在Java中，Random类是用于伪随机数生成器的主要类。

它可以使用默认构造函数创建实例，并且会自动使用当前时间作为种子值。

也可以通过传递一个long类型参数来指定种子值。

以下代码演示了如何使用Random类来生成一个0到99之间的整数：```javaimport java.util.Random;public class RandomNumberGenerator {public static void main(String[] args) {Random random = new Random();int randomNumber = random.nextInt(100);System.out.println("Random number: " + randomNumber); }}```这里，我们首先创建了一个Random对象。

然后，我们使用nextInt()方法来生成一个随机整数，并将其存储在randomNumber变量中。

最后，我们将其打印到控制台上。

真随机数生成器真随机数生成器是一种基于物理过程的方法，例如放射性衰变或热噪声。

这些过程是完全随机的，并且可以用来产生真正的随机数。

在Java中，可以使用SecureRandom类来实现真随机数生成器。

java指定范围生成随机数的方法

java指定范围生成随机数的方法Java是一种常用的编程语言，在编写程序时，随机数生成是重要的一环，因为它可以用来模拟一些场景，比如游戏中的随机事件、抽奖等等。

本文将介绍如何在Java中指定范围生成随机数。

一、使用Java Random类Java中提供了Random类，这个类可以用来生成随机数。

生成一个指定范围内的随机数，可以通过控制生成的随机数范围和基准值实现。

代码实例如下：```javaimport java.util.Random;public class RandomDemo {public static void main(String[] args) {Random random = new Random();int range = 100; // 生成随机数的范围，0-99int base = 1; // 生成随机数的基准值，1int num = random.nextInt(range) + base;System.out.println(num);}}```上述代码中，使用了Random类的nextInt方法生成一个指定范围内的随机数，通过设置基准值为1，控制生成的随机数的最小值为1，即使取到0，加上基准值后也是1。

二、使用Math.random方法Math.random()方法可以生成一个范围在0-1之间的double类型的随机数，其实我们可以通过计算，使得这个数范围变为我们需要的范围，然后将其强制类型转换为整数。

代码实例如下：```javapublic class RandomDemo {public static void main(String[] args) {int range = 100; // 生成随机数的范围，0-99int base = 1; // 生成随机数的基准值，1int num = (int) (Math.random() * range + base);System.out.println(num);}}```以上代码中，同样设置生成随机数的范围和基准值，并使用Math.random()方法生成随机数，然后通过计算和强转数据类型实现生成指定范围内的随机数。

介绍c、java等流行编程语言中随机数的生成算法。

中括号主题：随机数生成算法在编程语言中的应用及原理解析引言：随机数在计算机科学中具有重要的应用。

无论是在游戏开发、密码学、随机化算法、模拟实验还是统计学领域，随机数都起到至关重要的作用。

在本文中，我们将重点介绍在流行的编程语言中，如C和Java，常用的随机数生成算法及其原理。

一、C语言中的随机数生成算法C语言提供了一个标准的库函数`rand()`用于生成伪随机数。

这些随机数是伪随机数，即由确定性算法生成的，但它们在统计性质上表现得与真正的随机数相似。

1. 线性同余算法（Linear Congruential Generator, LCG）线性同余算法是C语言默认的随机数生成算法。

它通过递推式`X_{n+1} = (aX_{n} + c) mod m` 生成随机数序列。

其中，`X_{n}` 表示第n 个生成的随机数，`a` 是一个常数（称为乘数），`c` 是一个常数（称为增量），`m` 是一个常数（称为模）。

C语言中的`rand()`函数默认使用了线性同余算法，它的乘数`a`、增量`c`和模`m`的值是与编译器和实现有关的。

2. 梅森旋转算法（Mersenne Twister Algorithm）梅森旋转算法是一种更高质量的随机数生成算法，它能够生成更为均匀和随机的数值序列。

该算法是由Makoto Matsumoto 和Takuji Nishimura 于1997 年开发的。

C语言提供了`stdlib.h`头文件中的`rand()`函数的增强版本`rand48()`，使用了梅森旋转算法生成随机数。

此外，C语言中还提供了一个名为`random()`的函数，使用梅森旋转算法生成随机数。

二、Java中的随机数生成算法Java是一门广泛使用的编程语言，它提供了多种生成随机数的方式。

1. `java.util.Random`类Java提供了一个内置类`java.util.Random`用于生成随机数。

Java产生随机数的两种方式

Java产生随机数的两种方式
在java中，我们可以通过两种方式来获取随机数(generating a random number)一种是大家熟悉的ng.Math.Random()静态方法,另一种是创建java.util.Random对象。

下面是两种方法的使用过程:
一ng.Math.random()
在使用这一静态方法的时候，我们不需要import任何包，因为ng.*包是默认载入的,下面举例说面使用方法:
二.创建java.util.Random对象
random在产生随机数的时候使用当前的时间作为基数，我们可以同过System.currentTimeMillis()来获取这个基数。

当然我们也可以指定基数:
Random random=new Random(100);
同一基数所产生的随机数序列是一样的，可以用下面这一段程序进行印证:
我们可以发现random1和random2所产生的随机数是相同的。

史上最全的java随机数生成算法[转载]

史上最全的java随机数⽣成算法[转载] 1package com.zuidaima.core.util;23import java.util.Random;45public class RandomUtil {6public static final String ALLCHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";7public static final String LETTERCHAR = "abcdefghijkllmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";8public static final String NUMBERCHAR = "0123456789";910/**11 * 返回⼀个定长的随机字符串(只包含⼤⼩写字母、数字)12 *13 * @param length14 * 随机字符串长度15 * @return随机字符串16*/17public static String generateString(int length) {18 StringBuffer sb = new StringBuffer();19 Random random = new Random();20for (int i = 0; i < length; i++) {21 sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));22 }23return sb.toString();24 }2526/**27 * 返回⼀个定长的随机纯字母字符串(只包含⼤⼩写字母)28 *29 * @param length30 * 随机字符串长度31 * @return随机字符串32*/33public static String generateMixString(int length) {34 StringBuffer sb = new StringBuffer();35 Random random = new Random();36for (int i = 0; i < length; i++) {37 sb.append(ALLCHAR.charAt(random.nextInt(LETTERCHAR.length())));38 }39return sb.toString();40 }4142/**43 * 返回⼀个定长的随机纯⼤写字母字符串(只包含⼤⼩写字母)44 *45 * @param length46 * 随机字符串长度47 * @return随机字符串48*/49public static String generateLowerString(int length) {50return generateMixString(length).toLowerCase();51 }5253/**54 * 返回⼀个定长的随机纯⼩写字母字符串(只包含⼤⼩写字母)55 *56 * @param length57 * 随机字符串长度58 * @return随机字符串59*/60public static String generateUpperString(int length) {61return generateMixString(length).toUpperCase();62 }6364/**65 * ⽣成⼀个定长的纯0字符串66 *67 * @param length68 * 字符串长度69 * @return纯0字符串70*/71public static String generateZeroString(int length) {72 StringBuffer sb = new StringBuffer();73for (int i = 0; i < length; i++) {74 sb.append('0');75 }76return sb.toString();77 }7879/**80 * 根据数字⽣成⼀个定长的字符串，长度不够前⾯补081 *82 * @param num83 * 数字84 * @param fixdlenth85 * 字符串长度86 * @return定长的字符串87*/88public static String toFixdLengthString(long num, int fixdlenth) {89 StringBuffer sb = new StringBuffer();90 String strNum = String.valueOf(num);91if (fixdlenth - strNum.length() >= 0) {92 sb.append(generateZeroString(fixdlenth - strNum.length()));93 } else {94throw new RuntimeException("将数字" + num + "转化为长度为" + fixdlenth95 + "的字符串发⽣异常！");96 }97 sb.append(strNum);98return sb.toString();99 }100101/**102 * 每次⽣成的len位数都不相同103 *104 * @param param105 * @return定长的数字106*/107public static int getNotSimple(int[] param, int len) {108 Random rand = new Random();109for (int i = param.length; i > 1; i--) {110int index = rand.nextInt(i);111int tmp = param[index];112 param[index] = param[i - 1];113 param[i - 1] = tmp;114 }115int result = 0;116for (int i = 0; i < len; i++) {117 result = result * 10 + param[i];118 }119return result;120 }121122public static void main(String[] args) {123 System.out.println("返回⼀个定长的随机字符串(只包含⼤⼩写字母、数字):" + generateString(10)); 124 System.out125 .println("返回⼀个定长的随机纯字母字符串(只包含⼤⼩写字母):" + generateMixString(10)); 126 System.out.println("返回⼀个定长的随机纯⼤写字母字符串(只包含⼤⼩写字母):"127 + generateLowerString(10));128 System.out.println("返回⼀个定长的随机纯⼩写字母字符串(只包含⼤⼩写字母):"129 + generateUpperString(10));130 System.out.println("⽣成⼀个定长的纯0字符串:" + generateZeroString(10));131 System.out.println("根据数字⽣成⼀个定长的字符串，长度不够前⾯补0:"132 + toFixdLengthString(123, 10));133int[] in = { 1, 2, 3, 4, 5, 6, 7 };134 System.out.println("每次⽣成的len位数都不相同:" + getNotSimple(in, 3));135 }136 }。

[转]java的随机数生成原理

[转]java的随机数⽣成原理⼀.在j2se⾥我们可以使⽤Math.random()⽅法来产⽣⼀个随机数，这个产⽣的随机数是0-1之间的⼀个double，我们可以把他乘以⼀定的数，⽐如说乘以100，他就是个100以内的随机，这个在j2me中没有。

⼆.在java.util这个包⾥⾯提供了⼀个Random的类，我们可以新建⼀个Random的对象来产⽣随机数，他可以产⽣随机整数、随机float、随机double，随机long，这个也是我们在j2me的程序⾥经常⽤的⼀个取随机数的⽅法。

三.在我们的System类中有⼀个currentTimeMillis()⽅法，这个⽅法返回⼀个从1970年1⽉1号0点0分0秒到⽬前的⼀个毫秒数，返回类型是long，我们可以拿他作为⼀个随机数，我们可以拿他对⼀些数取模，就可以把他限制在⼀个范围之内啦其实在Random的默认构造⽅法⾥也是使⽤上⾯第三种⽅法进⾏随机数的产⽣的对于⽅法⼆中的Random类有以下说明：java.util.Random类有两种⽅式构建⽅式：带种⼦和不带种⼦不带种⼦：此种⽅式将会返回随机的数字，每次运⾏结果不⼀样public class RandomTest {public static void main(String[] args) {java.util.Random r=new java.util.Random();for(int i=0;i<10;i++){System.out.println(r.nextInt());}}带种⼦：此种⽅式，⽆论程序运⾏多少次，返回结果都是⼀样的public static void main(String[] args) {java.util.Random r=new java.util.Random(10);for(int i=0;i<10;i++){System.out.println(r.nextInt());}}两种⽅式的差别在于(1) ⾸先请打开Java Doc，我们会看到Random类的说明：此类的实例⽤于⽣成伪随机数流，此类使⽤ 48 位的种⼦，该种⼦可以使⽤线性同余公式对其进⾏修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。

JAVA中生成指定位数随机数的方法总结

JAVA中⽣成指定位数随机数的⽅法总结 JAVA中⽣成指定位数随机数的⽅法很多，下⾯列举⼏种⽐较常⽤的⽅法。

⽅法⼀、通过Math类1public static String getRandom1(int len) {2int rs = (int) ((Math.random() * 9 + 1) * Math.pow(10, len - 1));3return String.valueOf(rs);4 } 该⽅法是通过Math.random()获取[0.0, 1.0)的随机数，再乘以需要的位数。

这⾥⽤乘9，再加1，⽽没有⽤乘10的⽅式，是为了防⽌⽣成的随机数⽐较⼩，导致乘以位数后⼩于指定位数。

⽅法⼆、通过Random类1public static String getRandom2(int len) {2 Random r = new Random();3 StringBuilder rs = new StringBuilder();4for (int i = 0; i < len; i++) {5 rs.append(r.nextInt(10));6 }7return rs.toString();8 } 该⽅法是通过Random类的nextInt(9)⽅法可以直接获取⼀个[0,9]的随机整数，然后通过指定次数的循环，来拼接随机数。

Random类其实还有⼀些的⽣成随机数的⽅法，有兴趣可以了解⼀下。

⽅法三、通过Random类1public static String getRandom3(int len) {2int digit = (int) Math.pow(10, len - 1);3int rs = new Random().nextInt(digit * 10);4if (rs < digit) {5 rs += digit;6 }7return String.valueOf(rs);8 } 该⽅法也是通过Random类，不同的是，通过指定随机数的最⼤值，来⽣成指定位数的随机整数，因为有可能位数不⾜，所以当⼩于指定位数的时候需要加上指定位数的值。

Java随机数——Java.util.Random生成随机数

Java随机数——Java.util.Random⽣成随机数简介java.util.Random类中实现的随机算法是伪随机，也就是有规则的随机，所谓有规则的就是在给定种(seed)的区间内随机⽣成数字相同种⼦数的Random对象，相同次数⽣成的随机数字是完全相同的Random类中各⽅法⽣成的随机数字都是均匀分布的，也就是说区间内部的数字⽣成的⼏率均等47是⼀个产⽣随机数的魔法数字，这个问题到现在都没⼈能够解释，只是经过很多次试验得到的，包括《Thinking in java》的作者布鲁斯.艾克尔也这么提到：由47做种后，产⽣的随机数更加体现了随机性。

它没有什么具体的意义，只要理解随机数如果有⼀个种⼦，哪么出现了⽐较随即的随机数，⽽当种⼦是47的时候，随即率是最⼤的。

常⽤⽅法protected int next(int bits)：⽣成下⼀个伪随机数。

boolean nextBoolean()：返回下⼀个伪随机数，它是取⾃此随机数⽣成器序列的均匀分布的boolean值。

void nextBytes(byte[] bytes)：⽣成随机字节并将其置于⽤户提供的 byte 数组中。

double nextDouble()：返回下⼀个伪随机数，它是取⾃此随机数⽣成器序列的、在0.0和1.0之间均匀分布的 double值。

float nextFloat()：返回下⼀个伪随机数，它是取⾃此随机数⽣成器序列的、在0.0和1.0之间均匀分布float值。

double nextGaussian()：返回下⼀个伪随机数，它是取⾃此随机数⽣成器序列的、呈⾼斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。

int nextInt()：返回下⼀个伪随机数，它是此随机数⽣成器的序列中均匀分布的 int 值。

int nextInt(int n)：返回⼀个伪随机数，它是取⾃此随机数⽣成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。

java-随机生成10个数，填充一个数组并计算数组的和

java-随机⽣成10个数，填充⼀个数组并计算数组的和随机⽣成10个数，填充⼀个数组，然后⽤消息框显⽰数组内容，接着计算数组元素的和，将结果也显⽰在消息框中。

1.设计思路random随机⽣成10个数，赋值到数组中，然后对数组⾥的数进⾏相加，采⽤JOptionPane.showMessageDialog消息框进⾏输出。

2.程序流程图3.源程序代码1import javax.swing.*;23public class Array {456public static void main(String[] args) {78// TODO Auto-generated method stub910 String output = "";1112int n[]=new int[10];1314for(int i=0;i<10;i++)15 {16 n[i]=(int) ( Math.random() *100 );17 }18192021int a=0;2223 output += "数组为：\n ";2425for(int i=0;i<n.length;i++)2627 output += n[i] + "\n";2829 output += "数组和为：";3031for(int i=0;i<n.length;i++)3233 a += n[i];3435 output += a;3637 JTextArea outputArea = new JTextArea( 11, 10 );3839 outputArea.setText( output );4041 JOptionPane.showMessageDialog( null, outputArea, "Initializing an Array with a Declaration",RMATION_MESSAGE );//以对话框的形式出现4243 System.exit( 0 );4445 }4.结果截图5.编程总结int n[]=new int[10];[开辟新数组]Math.random()[产⽣随机数]JOptionPane.showMessageDialog()[对消息进⾏消息框的输出]。

随机数算法 java

随机数算法 java一、什么是随机数算法？随机数算法是一种通过计算机程序生成不确定的、无序的数字序列的方法。

在计算机科学中，随机数算法是非常重要的，因为它们可以用于模拟随机事件、生成密码、进行统计分析等多个领域。

二、常见的随机数算法1. 伪随机数生成算法伪随机数生成算法是一种通过确定性的计算步骤生成伪随机数的方法。

它们的生成过程是可重复的，并且只要知道了种子（即初始值），就可以预测后续的随机数序列。

常见的伪随机数生成算法包括： - 线性同余法：通过递推关系式生成随机数序列，常见的算法有乘法同余法和混合同余法。

- 梅森旋转算法：基于大整数模运算的算法，具有较高的随机性。

- 索引计算法：通过对序列中的元素进行重新排列来生成随机数序列。

2. 真随机数生成算法真随机数生成算法是一种通过物理过程生成真正随机数的方法。

与伪随机数算法不同，真随机数是不可重复的，并且无法预测。

常见的真随机数生成算法包括： - 环境噪声采集：通过采集来自物理设备的噪声来生成随机数。

例如，麦克风的噪声、温度传感器的噪声等。

- 环境特征采集：通过采集环境的特征，例如光照、压力等，来生成随机数。

- 量子物理过程：利用量子物理过程的不确定性生成真随机数。

三、Java中的随机数算法Java提供了多个生成随机数的类和方法，可以满足不同的需求。

Java的Math类中提供了静态方法random()，该方法可以生成一个0到1之间的伪随机数。

我们可以根据需要将该数映射到不同的范围。

double randomNum = Math.random(); // 生成0到1的随机数int rangeNum = (int) (randomNum * range) + min; // 将随机数映射到指定范围2. Random类Java的Random类提供了更强大的随机数生成功能。

我们可以使用该类来生成更丰富的随机数序列。

Random random = new Random();int randomInt = random.nextInt(); // 生成一个随机整数double randomDouble = random.nextDouble(); // 生成一个随机浮点数boolean randomBoolean = random.nextBoolean(); // 生成一个随机布尔值3. SecureRandom类Java的SecureRandom类提供了更安全的随机数生成功能。

Java 中随机数的生成、分析及其应用.doc

Java 中随机数的生成、分析及其应用摘要：介绍了Java 生成随机数的机制，通过具体的例子说明了在java 中如何实现常用伪随机数的生成，并进行了应用分析。

关键词: Java 语言; 随机数; 算法在计算机很多应用中，关于随机数的使用非常广泛而重要。

例如：考试系统中的随机抽题，扑克游戏的自动发牌等领域都有广泛应用。

随机数的产生总体上有两种方法。

一种是采用很多种原始的物理方法用于生成一定范围内满足精度的均匀分布序列，其缺点在于：速度慢、效率低、需占用大量存储空间且不可重现等，一般认为这是真正的随机序列。

另一种是用计算机软件模拟的方法产生。

这种利用数学递推公式所产生的随机数只能满足一定的概率分布，所以就不可能是真正的随机数，而是伪随机数。

从实用的角度看，只要伪随机数具有真正随机数的一些统计性质，我们就可以把伪随机数作为真正随机数来使用。

Java 作为一种极具生命力的完全面向对象的网络编程开发语言，对伪随机数生成提供了多种方法，以适应各种不同的设计要求1、Java 生成随机数的机制Java[1]语言是采用数学方法--线性同余法（Liner CongruenceGenerator，即LCG 法）产生随机数的。

优点是随机性好、周期长,易于计算机实现和速度快、广泛采用。

缺点是该法产生的随机数因受到数学规律的影响而具有周期性和相关性。

在Java 中随机数概念从广义上将有3 种：1、通过currentTimeMillis()方法来获取个当前时间毫秒数long 型数字2、通过Math.random()方法返回个0 到1 的间double 值3、通过Random 类来产生个随机数，这个是专业Random 工具类，功能强大在实际应用中，使用后两种生成伪随机数的方式：java.util 包中的Random 类和ng 包中的Math.Random()方法。

Java 实用工具类库中的类java.util.Random 提供了产生各种类型随机数的方法。