Java中Math.random()和java.util.random的区别

合集下载

java中数学函数

java中数学函数Java中的数学函数是开发者们在编写数学计算程序和算法时必不可少的基础，提供了一系列常用的数学计算函数，能够方便、高效地实现数字计算和数据处理，包括基本数学操作、三角函数、指数和对数函数、绝对值、向上取整、向下取整、舍入等数值运算。

本文将围绕这些数学函数介绍Java中常用的数学运算方法，帮助读者深入学习和了解这一领域。

一、基本数学运算方法在Java中，基本数学运算是计算机程序中最重要和最基础的运算方法，常见的包括加减乘除、取模、幂次等运算，Java内置了许多基本数学运算的函数以支持开发者进行数值计算。

下面分别介绍几个常用的基本数学运算方法：1. 取模运算：取模运算符为%，用于计算两个数相除的余数。

示例代码：int a = 20;int b = 7;int remainder = a % b;System.out.println(remainder); 输出62. 幂次运算：幂次运算使用符号或者Math.pow() 函数进行计算。

示例代码：int base = 2;int exponent = 4;int result = (int) Math.pow(base, exponent);System.out.println(result); 输出16int result2 = base exponent;System.out.println(result2); 输出163. 四舍五入：四舍五入是将一个数值按照特定规则四舍五入到最接近的整数，可以使用Math.round()函数实现。

示例代码：double number = 3.45;long rounded = Math.round(number);System.out.println(rounded); 输出34. 随机数：在Java中，可以使用Math.random()函数生成一个0.0到1.0之间的随机数，也可以指定上、下界生成范围内的随机整数。

java随机生成数字的三种方法

java随机⽣成数字的三种⽅法随机数的产⽣在⼀些代码中很常⽤，也是我们必须要掌握的。

⽽java中产⽣随机数的⽅法主要有三种：第⼀种：new Random() 第⼆种：Math.random() 第三种：currentTimeMillis() 第⼀种需要借助java.util.Random类来产⽣⼀个随机数发⽣器，也是最常⽤的⼀种，构造函数有两个，Random()和Random(long seed)。

第⼀个就是以当前时间为默认种⼦，第⼆个是以指定的种⼦值进⾏。

产⽣之后，借助不同的语句产⽣不同类型的数。

种⼦就是产⽣随机数的第⼀次使⽤值,机制是通过⼀个函数,将这个种⼦的值转化为随机数空间中的某⼀个点上,并且产⽣的随机数均匀的散布在空间中。

以后产⽣的随机数都与前⼀个随机数有关。

以代码为例。

public static void main(String[] args){ Random r = new Random(1); for(int i=0 ; i<5 ; i++) { int ran1 = r.nextInt(100); System.out.println(ran1); }}在我的编译器下产⽣的五个数均为85,88,47,13,54，如果采⽤Random r = new Random()，产⽣的随机数就不同，这就是确定种⼦导致的结果。

⽽第⼆种⽅法返回的数值是[0.0,1.0）的double型数值，由于double类数的精度很⾼，可以在⼀定程度下看做随机数，借助（int）来进⾏类型转换就可以得到整数随机数了，代码如下。

public static void main(String[] args) {int max=100,min=1;int ran2 = (int) (Math.random()*(max-min)+min);System.out.println(ran2);}⾄于第三种⽅法虽然不常⽤，但是也是⼀种思路。

第5章JavaAPI练习题2

第5章JavaAPI练习题2⼀、填空题1. 通过循环完成查找，直到找不到⼦串为⽌，此时indexOf()⽅法返回值为【】。

2. 可以使⽤【】类的contains()⽅法，判断整串中是否包含⼦串。

3. JAVA中 int类型对应的包装类是【】。

4. 针对字符串的操作，Java提供了两个字符串类，分别是String和【】。

5. System类的【】静态⽅法可以启动垃圾回收器。

⼆、判断题1. 在JDK5.0中，switch语句可以⽀持字符串类型。

（）2. StringBuffer类的append()⽅法可以将数组元素和空格连接成字符串。

（）3. ceil()、floor()和round()⽅法返回的都是double类型的数。

（）4. java.util.Random的nextInt( )⽅法会⽣成⼀个正整数类型的伪随机数。

（）5. JAVA中拆箱是指将引⽤数据类型的对象转为基本数据类型。

（）三、选择题1. 下⾯哪个选项可以获取Runtime类的实例（）A: Runtime r = new Runtime();B: Runtime r = Runtime.getRuntime();C: Runtime r = Runtime.getInstance();D: 以上选项都不能获取Runtime实例2. 下列选项中，可以正确实现String初始化的是（）A: String str = "abc";B: String str = 'abc';C: String str = abc;D: String str = 0;3. 若double val = Math.ceil(-11.9);，则val的值是（）A: 11.9B: -11.0C: -11.5D: -12.04. 下列关于System类的描述中，错误的是（）A: System类是final关键字修饰的类，它不能被其他类所继承B: System类不能被实例化C: System类中定义了许多⽅法，但是没有定义字段D: System类中提供了获取当前系统属性的⽅法5. 下列选项中，对Math.random()⽅法描述正确的是( )A: 返回⼀个不确定的整数B: 返回0或是1C: 返回⼀个随机的double类型数，该数⼤于等于0.0⼩于1.0D: 返回⼀个随机的int类型数，该数⼤于等于0.0⼩于1.0四、简答题1. 在Java中可以通过哪些⽅式对String进⾏初始化？。

Jav中Random函数

关于Java中的Random（）函数今天在做Java练习的时候注意到了Java里面的一个随机函数——Random，刚开始只是知道这个函数具有随机取值的作用，于是上网搜索了资料一番，做了一下一些关于Random 函数的总结：Java中其实存在着两种Random函数：一、ng.Math.Random;调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

例如我下面的实验代码编译通过后运行结果如下图大家观察会发现代码的用一个循环10次循环输出num的取值，均随机分布在[0,3)之间！在使用Math.Random()的时候需要注意的地方时该函数是返回double类型的值，所以在要赋值给其他类型的变量的时候注意需要进行塑形转换。

二、java.util.Random;在Java的API帮助文档中，总结了一下对这个Random()函数功能的描述：1、java.util.Random类中实现的随机算法是伪随机，也就是有规则的随机，所谓有规则的就是在给定种子(seed)的区间内随机生成数字；2、相同种子数的Random对象，相同次数生成的随机数字是完全相同的.3、Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率均等.我们可以在构造Random对象的时候指定种子（这里指定种子有何作用，请接着往下看），如：Random r1 = new Random(20);或者默认当前系统时间对应的相对时间有关的数字作为种子数:Random r1 = new Random();需要说明的是：你在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。

如下面的Java代码：Random rand =new Random(25);int i;i=rand.nextInt(100);初始化时25并没有起直接作用（注意：不是没有起作用）,rand.nextInt(100);中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。

java中随机生成数字的方法

Java中随机生成数字的方法在Java编程中，经常需要生成随机数字。

随机数字的生成可以用于各种场景，例如游戏开发、密码生成、数据模拟等。

本文将介绍Java中常用的几种随机生成数字的方法，并提供示例代码和解释。

Random类Java提供了Random类来生成伪随机数。

Random类的实例可以通过调用其方法来生成不同类型的随机数。

1. 生成整数使用Random类的nextInt()方法可以生成一个范围内的随机整数。

以下是一个示例代码：import java.util.Random;public class RandomExample {public static void main(String[] args) {Random random = new Random();int randomNumber = random.nextInt(100); // 生成0到99之间的随机整数System.out.println(randomNumber);}}上述代码创建了一个Random对象，然后调用nextInt(100)方法来生成0到99之间的随机整数。

运行程序会输出一个不同的整数。

2. 生成浮点数使用Random类的nextDouble()方法可以生成0到1之间（包括0但不包括1）的伪随机浮点数。

以下是一个示例代码：import java.util.Random;public class RandomExample {public static void main(String[] args) {Random random = new Random();double randomNumber = random.nextDouble(); // 生成0到1之间（包括0但不包括1）的随机浮点数System.out.println(randomNumber);}}上述代码创建了一个Random对象，然后调用nextDouble()方法来生成0到1之间的随机浮点数。

java获取固定长度的随机数方法

在Java编程中，获取固定长度的随机数是一项常见的需求。

在本文中，我将探讨如何使用Java语言来实现这一功能，并对获取固定长度的随机数方法进行全面介绍。

1. 随机数的重要性在计算机科学和编程中，随机数起着至关重要的作用。

它们被广泛应用于密码学、模拟、游戏开发、随机化算法等领域。

对于编程人员来说，学习如何生成和处理随机数是至关重要的。

2. Java中获取随机数的基本方法在Java中，我们可以使用java.util.Random类来生成随机数。

这个类提供了丰富的方法来获取各种类型的随机数，包括整数、长整型、浮点数等。

下面是一个简单的例子：```javaimport java.util.Random;public class RandomNumberGenerator {public static void main(String[] args) {Random random = new Random();int randomNumber = random.nextInt();System.out.println("随机整数：" + randomNumber);}```在这个例子中，我们创建了一个Random对象，并使用nextInt()方法来获取一个随机的整数。

然而，这种方法并不能满足我们获取固定长度随机数的需求。

接下来，我将介绍一种实现固定长度随机数的方法。

3. 获取固定长度的随机数为了获取固定长度的随机数，我们可以利用Java中其他的一些类和方法。

一种常见的方法是使用Math.random()函数，结合StringBuilder来生成指定长度的随机数。

下面是一个示例代码：```javapublic class FixedLengthRandomNumber {public static void main(String[] args) {int length = 6;StringBuilder sb = new StringBuilder();for (int i = 0; i < length; i++) {sb.append((int) (Math.random() * 10));}System.out.println("固定长度的随机数：" + sb.toString());}}在这个例子中，我们利用Math.random()函数生成了一个[0,1)之间的随机浮点数，并将其转换为一个0到9之间的整数，然后将这些数字拼接到StringBuilder中，最终得到了指定长度的随机数。

java生成六位验证码

java⽣成六位验证码import java.util.Random;public class random {public static String getrandom(){String code = "";Random random = new Random();for (int i = 0; i < 6; i++) {int r = random.nextInt(10); //每次随机出⼀个数字（0-9）code = code + r; //把每次随机出的数字拼在⼀起}return code;}}以上代码是复制⽹上的，也运⽤到了⾃⼰的练习项⽬中。

以前⽼师讲过⼀种⽤Math.random()实现。

random.nextInt()与Math.random()的区别是：Math.random()是⽅法，random.nextInt()是⼀个类。

Math.random()是Random.nextDouble（）的⼀个内部⽅法.java中⽣成的随机数都是伪随机，也就是根据特定算法算出来的，只要理解了算法，下⼀个随机数是可以算出来的。

不过在我们平时使⽤中够⽤了在百度中看到random.nextInt()的效率⽐Math.random()⾼50%-80%。

所以就⽤了上⾯代码的⽅法。

附上Math.random()⽣成六位验证码的⽅法public class Random {public static Integer getRandom(){String randomString=null;Integer random = null;do{random=(int)(Math.random()*1000000);randomString=random+"";}while(randomString.length()<6);return random;}}。

JAVA各种计算工具类

JAVA各种计算工具类Java是一种面向对象的编程语言，它提供了丰富的类库和工具来实现各种计算任务。

在以下内容中，我将介绍一些常用的Java计算工具类。

1. Math类：这是Java中提供基本数学运算的工具类。

它包含的方法可以进行基本的运算，如加减乘除、取整、取余等。

此外，Math类还提供了一些常用的数学函数，如指数函数、对数函数、三角函数等。

2. BigDecimal类：在Java中，浮点数的精度是有限的，可能会导致精度丢失的问题。

为了解决这个问题，可以使用BigDecimal类进行高精度计算。

BigDecimal类提供了方法来执行加减乘除等基本运算，同时具有设置精度和舍入模式的功能。

3. Random类：这个类提供了生成伪随机数的方法。

可以使用Random类来生成随机的整数、浮点数或布尔值。

另外，Random类还可以生成符合特定分布的随机数。

4. BitSet类：BitSet类用于处理位数据，它提供了一组方法来操作位集合。

使用BitSet类可以进行位运算，如位与、位或、位异或等。

此外，BitSet类还提供了方法来进行位集合的操作，如设置位、清除位、翻转位等。

5. Calendar类：这个类用于处理日期和时间。

Calendar类提供了一组方法来获取日期和时间的各个部分，如年、月、日、时、分、秒等。

它还提供了一组方法来进行日期和时间的计算和格式化。

6. Arrays类：这个类用于处理数组。

Arrays类提供了一组方法来对数组进行排序、查找、比较等操作。

它还提供了方法来生成数组的字符串表示。

9. BigInteger类：与BigDecimal类类似，BigInteger类用于处理大整数运算。

它提供了一组方法来进行基本运算，如加减乘除、取模等。

BigInteger类还提供了方法来处理特定的整数操作，如计算阶乘、计算幂等。

10. DecimalFormat类：这个类用于格式化数值。

DecimalFormat类提供了一组方法来控制数值的格式，如设置小数位数、设置千位分隔符、设置正负号等。

Math.random（）详解

Math.random（）详解Math.random()是令系统随机选取⼤于等于 0.0 且⼩于 1.0 的伪随机 double 值，是Java语⾔常⽤代码。

例如：double a=Math.random()*(3-1)+1，设置⼀个随机1到3的变量。

代码Math.random()：产⽣⼀个[0，1)之间的随机数。

返回指定范围的随机数(m-n之间)的公式 [1] ：1 2Math.random()*(n-m)+m；改正公式:Math.random()*(n+1-m)+m例：⽣成⼀个6位的随机字符串：12 3 4 5 6 7 8 9 10 11public static void main(String[]args){String result="";for(inti=0;i<6;i++){//⽣成97-122的int型的整型int intValue=(int)(Math.random()*26+97);//将intValue强制转化成char类型后接到result后⾯result=result+(char)intValue;}//输出字符串System.out.println(result);}使⽤⽅法例：⽤Math类的random()⽅法产⽣⼀个字符，若该字符是⼀个⼤写英⽂字母，则输⼊ "Yes!"，否则输出“NO”。

random()⽅法产⽣的在0.0和1.0之间，乘以128后，其值在0.0和128.0之间，将它转换为类型后，⽤if来判断是否在'A' 和'Z'之间。

程序如下：12 3 4 5 6 7 8 9 10classIsUpper{ publicstaticvoidmain(String[]args){ charch;ch=(char)(Math.random()*128);if(ch>='A'&&ch<='Z')System.out.println("Yes!");elseSystem.out.println("No!");}}JavaScript Math.random() 函数Math.random() -- 返回0和1之间的伪随机数可能为0，但总是⼩于1，[0,1) 1document.write(Math.random());返回随机数1document.write(Math.random()*(20-10+1)+10);返回10-20的随机数1document.write(Math.random()*(n+1-m)+m);返回指定范围的随机数(m-n之间)的公式。

math.random()方法生成的随机整数_概述说明以及解释

math.random()方法生成的随机整数概述说明以及解释1. 引言1.1 概述在计算机编程中，随机数的生成对于许多应用程序来说是至关重要的。

而在JavaScript语言中，我们可以使用Math对象的random()方法来生成随机数。

本文将对这个方法进行全面的概述和解释。

1.2 目的本篇文章旨在介绍Math对象的random()方法以及通过该方法生成的随机整数。

我们将详细探讨该方法的使用注意事项、原理分析、优缺点分析，并与其他随机数生成方法进行比较。

通过深入了解这个方法，读者能够更好地理解它的特点和适用场景，并且能够在实际应用中做出明智的决策。

1.3 结构本文将按照以下结构展开对Math.random()方法生成随机整数的说明：第2部分：math.random()方法简介2.1 方法概述2.2 随机整数生成范围2.3 使用注意事项第3部分：随机整数生成原理分析3.1 伪随机性说明3.2 算法基础介绍3.3 实际应用举例第4部分：math.random()方法优缺点分析4.1 优势总结4.2 不足之处展示4.3 与其他随机数方法对比第5部分：结论与展望5.1 总结论述5.2 展望未来发展方向5.3 实际应用建议通过以上划分的章节，读者将能够全面了解math.random()方法生成的随机整数，并且可以根据自己的需求和实际情况做出合理的选择与应用。

2. math.random()方法简介2.1 方法概述math.random()是JavaScript中的一个用于生成随机数的函数。

它返回一个0到1之间的随机浮点数，包含0但不包含1。

2.2 随机整数生成范围尽管math.random()生成的是浮点数，我们可以利用一些技巧将其转换为整数。

例如，要生成0到9之间（包含0和9）的随机整数，我们可以使用以下代码：```Math.floor(Math.random() * 10)```其中Math.floor()函数会将参数向下取整，即去除小数部分，保留整数部分。

java中math用法

在Java中，Math类是ng包的一部分，它提供了基础数学函数和常量。

以下是一些常用的Math类方法和常量：1. 常量：* PI：圆周率π* E：自然对数的底数e* MAX_VALUE：Java能处理的最大数值（double类型）* MIN_VALUE：Java能处理的最小数值（double类型）* NaN：非数字（Not a Number）* INFINITY：无穷大（正无穷或负无穷）2. 方法：* abs(double)：返回参数的绝对值。

* ceil(double)：返回大于或等于给定参数的最小整数。

* floor(double)：返回小于或等于给定参数的最大整数。

* rint(double)：返回最接近给定参数的双精度浮点数。

* round(float)：返回最接近给定参数的整数。

* sin(double)：返回给定角度（以弧度为单位）的正弦值。

* cos(double)：返回给定角度（以弧度为单位）的余弦值。

* tan(double)：返回给定角度（以弧度为单位）的正切值。

* exp(double)：返回e的给定指数次幂的值。

* log(double)：返回自然对数（底为e）的参数的值。

* log10(double)：返回以10为底的对数参数的值。

* sqrt(double)：返回给定参数的平方根。

* pow(double, double)：返回第一个参数的第二个参数次幂的值。

* random()：返回一个0.0到1.0之间的随机浮点数。

* IEEEremainder(double, double)：返回两个参数相除后的余数。

* max(double, double)：返回两个参数中的最大值。

* min(double, double)：返回两个参数中的最小值。

以上是Math类的一些基本用法，这个类还包含其他许多方法和常量，可以满足各种数学计算的需求。

实用的随机数生成类Random：测试（随机产生100个不重复的正整数）

实⽤的随机数⽣成类Random：测试（随机产⽣100个不重复的正整数）实⽤的随机数⽣成类Random：测试（使⽤Random类随机⽣成100个不重复的正整数）⼀、之前我们使⽤随机数⽤的是Math类的random()⽅法：tips:产⽣随机数（0~9中任意整数）的⽅法：int random = (int)(Math.random()*10);1.商场幸运抽奖程序。

会员号的百位数字等于产⽣的随机数即为幸运会员。

public class GoodLuck{ public static void main(String[] args){ //产⽣随机数 int random = (int)(Math.random()*10); //从控制台接收⼀个4位会员号 System.out.println("我⾏我素购物管理系统>幸运抽奖\n"); System.out.print("请输⼊4位会员号："); Scanner input = new Scanner(System.in); int custNo = input.nextInt(); //分解获得百位 int baiwei = custNo/100%10; //判断是否是会员 if(baiwei = random){ System.out.println(custNo+"是幸运客户，获精美MP3⼀个。

"); }else{ System.out.println(custNo+"谢谢您的⽀持！"); } }}⼆、其实，Math类的random⽅法的底层就是使⽤Random类实现的。

1.给构造⽅法有两种重载⽅法：Random();创建⼀个新的随机数⽣成器。

Random(long seed);使⽤单个long种⼦创建⼀个新的随机数⽣成器。

tips:如果⽤同样⼀个种⼦值来初始化两个Random对象，然后⽤每个对象调⽤相同的⽅法，那么得到的随机数也是相同的（令牌）2.返回下⼀个伪随机数的⽅法：int nextInt();返回下⼀个伪随机数，它是此随机数⽣成器的序列中均匀分布的int值。

java获取随机数的方法

java获取随机数的方法在Java中，获取随机数是非常常见的操作，而且是很多应用程序所必需的。

随机数可以用来创建随机数据，制造游戏中的随机事件，以及伪随机数生成器的使用等。

本文将介绍一些在Java中生成随机数的方法，以及如何在代码中使用它们。

Java中的随机数生成器Java中的随机数生成器对于生成均匀分布的随机数是很有用的。

在Java中，我们可以使用Java.util.Random类和Java.security.SecureRandom类来生成随机数。

两者的主要区别在于SecureRandom类可以生成更安全的随机数，而且它可以用来产生加密密钥等。

使用Java.util.Random类Java.util.Random类是Java内置的随机数生成器。

它可以生成均匀分布的随机数，而且是线程安全的，多个线程可以同时访问。

以下是使用Java.util.Random类生成随机数的示例：```javaimport java.util.Random;public class RandomNumberGenerator {public static void main(String[] args) {Random rand = new Random();int randNum1 = rand.nextInt(); // 生成随机整数double randNum2 = rand.nextDouble(); // 生成随机小数float randNum3 = rand.nextFloat(); // 生成随机小数boolean randNum4 = rand.nextBoolean(); // 生成随机布尔值System.out.println("Random number 1: " + randNum1);System.out.println("Random number 2: " + randNum2);System.out.println("Random number 3: " + randNum3);System.out.println("Random number 4: " + randNum4);}}```在上面的代码中，我们使用Random类生成了四种不同类型的随机数，包括整数、小数和布尔值。

math.random 函数用法

math.random 函数用法math.random函数是Lua中用于生成随机数的函数。

它可以接受一个或两个参数。

如果只传递一个参数n，则函数会返回一个[1, n]之间的整数随机数。

例如，math.random(10)会返回一个1~10之间的整数。

如果传递两个参数min和max，则函数会返回一个[min, max]之间的整数随机数。

例如，math.random(1, 10)会返回一个1~10之间的整数。

需要注意的是，math.random函数在每次调用时会返回一个完全随机的值，即使传递的参数相同也会返回不同的随机数。

如果需要生成伪随机数序列，应该使用math.randomseed函数来初始化随机数种子。

下面举例详细说明。

当我们使用math.random函数时，它会生成一个随机数。

为了方便演示，我们假设我们正在开发一个随机点名的程序，需要在已有姓名列表中随机选择一个人进行点名。

首先，我们需要定义一个含有所有姓名的列表：```names = {"Tom", "Jack", "Sarah", "Amy", "John", "Kate"}```然后，我们可以使用math.random函数来选择一个随机的姓名。

我们可以使用列表的长度作为上限，最终得到一个[1, length]之间的整数，这个整数对应着一个姓名：```--生成一个随机的姓名randomIndex = math.random(#names)selectedName = names[randomIndex]--输出随机的姓名print("The selected name is: " .. selectedName)```这段代码会输出一个随机的姓名，例如："The selected name is: Kate"。

Java获得指定区间数的方法

Java获得指定区间数的⽅法本⽂实例讲述了Java获得指定区间数的⽅法。

分享给⼤家供⼤家参考。

具体如下：在编写Java程序的时候很多时候都⽤到了随机数，但是⼀直都是⽤⼀次查⼀次，这次来⼀个总结吧，把Java中得随机数的产⽣弄的清晰⼀些，以后就直接⾃⼰参考⾃⼰的这篇⽂章就好了。

Java中有两个类可以产⽣随机数：java.util.Random和java.Math.RandomJava实⽤⼯具类库中的类java.util.Random提供了产⽣各种类型随机数的⽅法。

它可以产⽣int、long、float、double以及Goussian等类型的随机数。

这也是它与ng.Math中的⽅法Random()最⼤的不同之处，后者只产⽣double型的随机数。

类Random中的⽅法⼗分简单，它只有两个构造⽅法和六个普通⽅法。

构造⽅法：(1)public Random()(2)public Random(long seed)Random()使⽤当前时间即System.currentTimeMillis()作为发⽣器的种⼦，Random(long seed)使⽤指定的seed作为发⽣器的种⼦。

Java产⽣随机数需要有⼀个基值seed，在第⼀种⽅法中基值缺省，则将系统时间作为seed。

普通⽅法：(1)public synonronized void setSeed(long seed)该⽅法是设定基值seed。

(2)public int nextInt()该⽅法是产⽣⼀个整型随机数。

(3)public long nextLong()该⽅法是产⽣⼀个long型随机数。

(4)public float nextFloat()该⽅法是产⽣⼀个Float型随机数。

(5)public double nextDouble()该⽅法是产⽣⼀个Double型随机数。

(6)public synchronized double nextGoussian()该⽅法是产⽣⼀个double型的Goussian随机数。

java生成随机字符串的两种方法

java⽣成随机字符串的两种⽅法本⽂实例为⼤家分享了java⽣成随机字符串的具体代码，供⼤家参考，具体内容如下import java.util.Random;public class CharacterUtils {//⽅法1：length为产⽣的位数public static String getRandomString(int length){//定义⼀个字符串（A-Z，a-z，0-9）即62位；String str="zxcvbnmlkjhgfdsaqwertyuiopQWERTYUIOPASDFGHJKLZXCVBNM1234567890";//由Random⽣成随机数Random random=new Random();StringBuffer sb=new StringBuffer();//长度为⼏就循环⼏次for(int i=0; i<length; ++i){//产⽣0-61的数字int number=random.nextInt(62);//将产⽣的数字通过length次承载到sb中sb.append(str.charAt(number));}//将承载的字符转换成字符串return sb.toString();}/*** 第⼆种⽅法*/public static String getRandomString2(int length){//产⽣随机数Random random=new Random();StringBuffer sb=new StringBuffer();//循环length次for(int i=0; i<length; i++){//产⽣0-2个随机数，既与a-z，A-Z，0-9三种可能int number=random.nextInt(3);long result=0;switch(number){//如果number产⽣的是数字0；case 0://产⽣A-Z的ASCII码result=Math.round(Math.random()*25+65);//将ASCII码转换成字符sb.append(String.valueOf((char)result));break;case 1://产⽣a-z的ASCII码result=Math.round(Math.random()*25+97);sb.append(String.valueOf((char)result));break;case 2://产⽣0-9的数字sb.append(String.valueOf(new Random().nextInt(10)));break;}}return sb.toString();}public static void main(String[] args) {System.out.println(CharacterUtils.getRandomString(12));}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

JAVA的Random类介绍

JAVA的Random类介绍Random类 (java.util)Random类中实现的随机算法是伪随机，也就是有规则的随机。

在进⾏随机时，随机算法的起源数字称为种⼦数(seed)，在种⼦数的基础上进⾏⼀定的变换，从⽽产⽣需要的随机数字。

相同种⼦数的Random对象，相同次数⽣成的随机数字是完全相同的。

也就是说，两个种⼦数相同的Random对象，第⼀次⽣成的随机数字完全相同，第⼆次⽣成的随机数字也完全相同。

这点在⽣成多个随机数字时需要特别注意。

下⾯介绍⼀下Random类的使⽤，以及如何⽣成指定区间的随机数组以及实现程序中要求的⼏率。

1、Random对象的⽣成Random类包含两个构造⽅法，下⾯依次进⾏介绍：a、public Random()该构造⽅法使⽤⼀个和当前系统时间对应的相对时间有关的数字作为种⼦数，然后使⽤这个种⼦数构造Random对象。

b、public Random(long seed)该构造⽅法可以通过制定⼀个种⼦数进⾏创建。

⽰例代码：Random r = new Random();Random r1 = new Random(10);再次强调：种⼦数只是随机算法的起源数字，和⽣成的随机数字的区间⽆关。

验证：相同种⼦数的Random对象，相同次数⽣成的随机数字是完全相同的。

import java.util.Random;public class test {public void random(){int i=0;int j=0;Random random=new Random(1);Random random1=new Random(1);i=random.nextInt();j=random1.nextInt();System.out.println(i+"-----"+j);}public static void main(String[] args) {test tt=new test();tt.random();}}结果：第⼀次：修改⼀下起源数字，让其等于10。

惊艳面试官-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年冯诺依曼提出来的。

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

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

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

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

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

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

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

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

伪随机数——精选推荐

伪随机数笔者最近在练习Mysql语句优化，奈何年少不懂，找不到百万级别的测试数据，只好⽤java随机⽣成数据凑合⽤⼀下，所以写下此篇博客，经测试⽣成500万条数据后台⽤了9秒，完全可以接受1. Randomrandom伪随机数类在 java.util 包下，是最常⽤的随机数⽣成器，其使⽤线性同余公式来⽣成随机数，所以才说是伪随机。

该类的实例是线程安全的，多线程并发使⽤可能会遇到争⽤问题，这时可⽤ ThreadLocalRandom 来解决这个问题，此外还有 SecureRandom 、SplittableRandom 随机⽣成器，这⾥就不扩展说明了2. 构造⽅法与常⽤⽅法类型名字解释Random()默认构造函数Random(long seed)有参构造，⽤种⼦创建伪随机⽣成器int nextInt返回⽣成器中⽣成表序列中的下⼀个伪随机数int nextInt(int n)返回均匀分布于区间 [0,n)的伪随机数double nextDouble返回下⼀个伪随机数 [0.0,1.0)3. 具体分析先看⽆参构造，直接上源码// ⽆参构造也是调⽤有参构造的，那么放出有参构造，再看⾥⾯具体内容public Random() {this(seedUniquifier() ^ System.nanoTime());}// 有参构造接收长整型种⼦参数public Random(long seed) {// 判断是否本类if (getClass() == Random.class)// 可以看出长整型种⼦是Atomic原⼦型的，即线程安全// initialScramble() 是seed与两个具体数值运算，这⾥不给出了this.seed = new AtomicLong(initialScramble(seed));else {// subclass might have overriden setSeed// 翻译：⼦类可能重写setSeed⽅法this.seed = new AtomicLong();setSeed(seed);}}// 再回⽆参构造内部// 其中 ^ System.nanoTime() 表⽰与系统纳秒异或运算，也就是说随机数依赖于时间this(seedUniquifier() ^ System.nanoTime());private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);private static long seedUniquifier() {// L'Ecuyer, "Tables of Linear Congruential Generators of// Different Sizes and Good Lattice Structure", 1999// 翻译：不同⼤⼩结构良好的线性同余⽣成元表，for (;;) {long current = seedUniquifier.get();long next = current * 181783497276652981L;// ⽤到了CAS轻量锁if (pareAndSet(current, next))return next;}}再看nextInt⽅法，有参的⽅法⽤逻辑运算把范围指定，这⾥就不介绍了public int nextInt() {return next(32);}protected int next(int bits) {long oldseed, nextseed;AtomicLong seed = this.seed;do {oldseed = seed.get();nextseed = (oldseed * multiplier + addend) & mask; // 都是具体的值位运算} while (!pareAndSet(oldseed, nextseed)); // 改变值return (int)(nextseed >>> (48 - bits)); // 可能这些位运算就是线性同余把}简单使⽤Random r1 = new Random();Random r2 = new Random();Random r3 = new Random();Random r4 = new Random(1000);Random r5 = new Random(1000);System.out.println(r1.nextInt());System.out.println(r2.nextInt());System.out.println(r3.nextInt(100));System.out.println(r4.nextInt());System.out.println(r5.nextInt());491030142202183584749-1244746321-1244746321从结果和源码可以看出：这⾥补充⼀下seed是final类型，线程更安全给定seed之后，伪随机数的序列是确定的⽽没有给seed因为依赖于变化的时间，所以每次的序列是不确定的常⽤new Random().nextInt(int n)来⽣成伪随机数4. Math.random我们最常⽤还是这个函数，静态调⽤⽅便简单// 底层还是⽤了Random类public static double random() {return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();}// 新建⼀个依赖时间的随机数⽣成器private static final class RandomNumberGeneratorHolder {static final Random randomNumberGenerator = new Random();}// 位运算加强随机public double nextDouble() {return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT;}从源码可以看出：这个类⽅便我们使⽤伪随机数，每次调⽤就新建⼀个Random类也知道区间为 [0.0,1.0)⽣成给定范围的伪随机数// 给定范围int min = 10;int max = 15;// ⽣成伪随机⼩数double num = Math.random();// 范围逻辑运算，想⼀下很简单的int rs = (int)(num * (max - min + 1) + min);System.out.println(rs); // 需要整数的位数5. 这⾥贴⼀下⽣成测试数据中密码的逻辑// 密码字符范围String range = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~!@#$%^&*()_+[];',.<>?:{}|"; // ⽣成100个伪随机密码for(int i = 0; i < 100; i++){// 字符串StringBuffer bf = new StringBuffer();// 密码长度8~20int len = (int)(Math.random() * (20 - 8 + 1) + 8);for(int j = 0; j < len; j++){int index = new Random().nextInt(range.length());bf.append(range.charAt(index));}System.out.println(bf.toString());}_ho1O@<s|4z$1sDIDRt_o{PRH_}z;A9;K74amjb2rO;*89#b!|4w|;z?~s+EmeTCdpJ9?W8,lNNl|o2#P9R@,hFT{+})BECM.Jf|&// 完全看不懂，还可以加上MD5加密。