35Java 中的 Math 类Random 随机数UUID格式化字符串或数字字符串和数字的相互转换高精度计算BigDecimal计算机中的浮点数都是近似值
Posted JavaLearnerZGQ
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了35Java 中的 Math 类Random 随机数UUID格式化字符串或数字字符串和数字的相互转换高精度计算BigDecimal计算机中的浮点数都是近似值相关的知识，希望对你有一定的参考价值。
文章目录
一、Math 类
(1) 简介
✏️ java.lang.Math 类提供了常见的数学计算功能
✏️ Math 类被 final 修饰（不能被继承）
✏️ Math 类不能被实例化
🍀 Math 类中都是 static 成员
🍀 Math 类不能被实例化，里面的非静态成员就毫无意义
(2) 属性
// 自然对数函数的底数（常量）
public static final double E = 2.7182818284590452354;
// π（圆周率）
public static final double PI = 3.14159265358979323846;
刘徽开创了探索圆周率的精确方法。
祖冲之在刘徽开创的探索圆周率的精确方法的基础上，首次将圆周率精算到小数点后第七位，即在3.1415926和3.1415927之间。
(3) 方法
① ceil 和 floor
public class TestDemo
public static void main(String[] args)
// 求绝对值: 666
// 正数的绝对值是其本身, 负数的绝对值是其相反数
System.out.println("求绝对值: " + Math.abs(-666));
// 求两个数的最大值: 777
System.out.println("求两个数的最大值: " + Math.max(666, 777));
// 求两个数的最小值: 2.36
System.out.println("求两个数的最小值: " + Math.min(3.14, 2.36));
🍀 max 方法可以求 int、long、float、double 等类型的两个数的最大值
🍀 体现了 Java 中的方法的重载特性
🍀 重载：① 方法名相同，参数类型或数量不同；② 重载与返回值类型、参数名称无关
🍀 Math 类中有很多重载的方法
public class TestDemo
public static void main(String[] args)
double n1 = 3.14159;
double n2 = -3.04159;
// 向下取整: 3.0
System.out.println("向下取整: " + Math.floor(n1));
// 向上取整: 4.0
System.out.println("向上取整: " + Math.ceil(n1));
// 向下取整: -4.0
System.out.println("向下取整: " + Math.floor(n2));
// 向上取整: -3.0
System.out.println("向上取整: " + Math.ceil(n2));
🍀 floor（地板）：向下取整（最接近操作数的整数，并且要比操作数小）
🍀 ceil（天花板）：向上取整（最接近操作数的整数，并且要比操作数大）
public class TestDemo
public static void main(String[] args)
double n1 = 3.44159;
double n2 = -3.54159;
// 四舍五入: 3
System.out.println("四舍五入: " + Math.round(n1));
// 四舍五入: -4
System.out.println("四舍五入: " + Math.round(n2));
② Knowledge is power
🍀 弗朗西斯培根： 出生于英国伦敦，其父亲是伊丽莎白女王的掌玺大臣。
🍀 Knowledge is power. 来自于弗朗西斯培根
🍀 他在《培根随笔》中的文章 📗《论读书》写得非常非常好（下面看其片段）
🍀 英文版的读起来还是比较费劲，博主选择了个人觉得翻译得通俗易懂的（咬文嚼字的不要）
🌱 读书可以作为消遣，可以作为装饰，也可以增长才干。
🌱 孤独寂寞时，阅读可以消遣；高谈阔论时，知识可供装饰；处世行事时，知识意味着才干。
🌱 懂得事务因果的人是幸运的。有实际经验的人虽能够处理个别性的事务，但若要纵观整体，运筹全局，却唯有学识方能办到。读书太慢的人驰惰，为装潢而读书是欺人，完全按照书本做事就是呆子。
🌱💐 求知可以改进人性，而经验可以改进知识本身。人的天性犹如野生的花草，求知学习好比修剪移栽。学问虽能指引方向，但往往流于浅乏，必须依靠经验才能扎下根基。
🌱 狡诈者轻鄙学问，愚鲁者羡慕学问，聪明者则运用学问。 知识本身并没有告诉人怎么运用它，运用的智慧在于书本之外。这是技艺，不体验就学不到。
🌱 读书是为了认识事物原理。为挑剔辩驳去读书是无聊的，但也不可过于迷信书本。求知不是为了吹嘘炫耀，而是为了寻找真理，启迪智慧。
🌱 书籍好比食物。有些只须浅尝，有些可以吞咽，只有少数需要仔细咀嚼，慢慢品味。所以，有的书只须读其中一部分，有的书只须知其梗概，而对于少数好书，则应当通读、细读、反复读。
🌱 有的书可以请人代读，然后看 TA 的笔记摘要即可。但这只应限于不太重要的议论和质量粗劣的书。否则一本书就将像已被蒸馏过的水，变得淡而无味了。
✏️ 书归正传，Knowledge is power. 中的 power 是力量或权力的意思，但在数学上也表示幂、次方
public class TestDemo
public static void main(String[] args)
// 2的3次方: 8.0
System.out.println("2的3次方: " + Math.pow(2, 3));
🍀 Math 类的 pow 方法用于求数的次方值，pow 就来自于
power
③ sqrt
✏️ sqrt 是 Square Root 的简写，意思是：平方根
public class TestDemo
public static void main(String[] args)
// 计算平方根: 8.0
System.out.println("计算平方根: " + Math.sqrt(64));
④ sin、cos、角度转弧度
public class TestDemo
public static void main(String[] args)
double degree = 90; // 角度制
// 角度转换为弧度
double radian = Math.toRadians(degree);
// 计算 sin、cos、tan 等三角函数的时候, 需要把角度转换为弧度
// sin: 1.0
System.out.println("sin: " + Math.sin(radian));
// cos: 6.123233995736766E-17
System.out.println("cos: " + Math.cos(radian));
// tan: 1.633123935319537E16
System.out.println("tan: " + Math.tan(radian));
(4) Math.random() 和 Random 类
✏️ Math.random()可以生成[0.0, 1.0)范围的随机数【包括0，不包括1.0】
✏️ java.util.Random可以更方便地生成各种随机数（boolean 类型、int 类型、double 类型、long 类型 …） 👍
public class TestDemo
public static void main(String[] args)
Random random = new Random();
boolean randBool = random.nextBoolean();
int randInt = random.nextInt();
long randLong = random.nextLong();
float randFloat = random.nextFloat();
// randBool = false
System.out.println("randBool = " + randBool);
// randInt = 1742425555
System.out.println("randInt = " + randInt);
// randLong = -83656586469544965
System.out.println("randLong = " + randLong);
// randFloat = 0.106951594
System.out.println("randFloat = " + randFloat);
🍀 这几个方法生成的随机数是无法指定范围的
🍀 可通过下面的练习学习如何生成指定范围的随机数
① 生成 [0, 99] 范围的整数
public class Randoms
/**
* (1) Math.random() 生成的是 [0.0, 1.0] 范围的随机数
* (2) 乘以 100 之后就是 [0.0, 100.0) 的浮点数
* (3) 强转为 int 类型后就是 [0, 99] 的整数
*/
private static int createRandNum0To99()
return (int) (Math.random() * 100);
private static int createRandNum0To99_()
// 生成 [0, 100) 的随机整数
// [0, 100) 其实就是 [0, 99]
return new Random().nextInt(100);
🍀
new Random().nextInt(n)生成[0, n)范围的随机整数
② 生成 [10, 99] 范围的整数
public class Randoms
/**
* (1) (int) (Math.random() * 90): 生成的是 [0, 89] 的随机整数
* (2) 加上 10 后生成的就是 [10, 99] 的随机整数
*/
private static int createRandNum10To99()
return (int) (Math.random() * 90) + 10;
private static int createRandNum10To99_()
Random random = new Random();
return 10 + random.nextInt(90);
③ 生成四位大写字母随机字符串
public class RandStrFour
public static void main(String[] args)
char aLetter = 'A';
for (int i = 0; i < 4; i++)
Random random = new Random();
char i1 = (char) random.nextInt(25);
System.out.print((char) (aLetter + i1));
二、UUID
✏️ UUID（Universally Unique Identifier）：通用唯一标识符
✏️ UUID 的作用：让分布式系统中的所有元素都能有唯一的标识符，而不需要通过中央控制端来做标识符的指定
✏️ 可以使用java.util.UUID类的 randomUUID 方法生成一个32位的16进制数的随机字符串，可用该字符串作为 UUID
public class UUIDTest
public static void main(String[] args)
// 87fe7457-abb9-4de7-bb9b-9fe34fda11dd
// 绝对是随机且唯一的
System.out.println(UUID.randomUUID());
三、格式化字符串或数字
(1) 格式化字符串
🍀 这东西蛮好用的
✏️ 可用 System.out.printf 或 System.out.format 输出格式化的字符串
public class TestDemo
public static void main(String[] args)
String sentence = "%s, %s和%s去%s结婚了, 当时他们都才%d岁";
// 2022年08月09日, 莫松和陆昊去美国白宫结婚了, 当时他们都才20岁
System.out.printf(sentence, "2022年08月09日", "莫松", "陆昊", "美国白宫", 20);
System.out.println();
// 2022年08月08日, 杨嘉立和叶霆去美国大使馆结婚了, 当时他们都才12岁
System.out.format(sentence, "2022年08月08日", "杨嘉立", "叶霆", "美国大使馆", 12);
✏️ 也可以使用String类的 format 方法创建格式化的字符串
public class TestDemo
public static void main(String[] args)
String s = String.format("%s, 英国女王的%s, %d年成为英国皇室的第一大臣", "庆医", "干儿子", 2022);
// 庆医, 英国女王的干儿子, 2022年成为英国皇室的第一大臣
System.out.println(s);
🍀 这里面使用到了可变参数
| 占位符号 | 作用 |
|---|---|
| %d | 十进制整数 |
| %f | 浮点数 |
| %s | 字符串 |
| %n | 换行 |
(2) 格式化数字（DecimalFormat）
🍀 使用 java.text.DecimalFormat 可以更好地控制前0、后0、前缀、后缀、分组分隔符、十进制分隔符等。
public class TestDemo
public static void main(String[] args)
double doubleVal1 = 520360.123;
double doubleVal2 = 123.78;
double doubleVal3 = 12345.78;
// 520,360.123
System.out.println(customFormat("###,###.###", doubleVal1));
// 520360.12
System.out.println(customFormat("###.##", doubleVal1));
// 000123.780
System.out.println(customFormat("000000.000", doubleVal2));
// $12,345.78
System.out.println(customFormat("$###,###.###", doubleVal3));
/**
* 把 double 类型的值转换为指定的字符串格式
*
* @param pattern 转换格式
* @param value 待转换的数
* @return 转换后的字符串
*/
private static String customFormat(String pattern, double value)
DecimalFormat df = new DecimalFormat(pattern);
return df.format(value);
(3) 字符串转数字
🍀 包装类型的valueOf方法可以传入基本类型或字符串, 然后将其转换为包装类型
🍀 包装类型的parsexxx方法可以把一个字符串转化为对应数字的基本类型
✏️ 必须保证待转换的字符串是可以被转换为相应数字的，否则会抛数字转换异常（NumberFormatException）
public class TestDemo
public static void main(String[] args)
String intStr = "520";
String doubleStr = "66.88";
Integer i1 = Integer.valueOf(intStr);
Double d1 = Double.valueOf(doubleStr);
// 520
System.out.println(i1);
// 66.88
System.out.println(d1);
int i2 = Integer.parseInt(intStr);
double d2 = Double.parseDouble(doubleStr);
// 520
System.out.println(i2);
// 66.88
System.out.println(d2);
(4) 数字转字符串
🍀 字符串的valueOf方法可把数字、对象或 char 数字转换为字符串
🍀 包装类的toString 方法可把其包装的基本类型转换为字符串
public class TestDemo
public static void main(String[] args)
int i = 1;
double d = 66.666;
boolean b = true;
String iStr0 = i + "";
String dStr0 = d + "";
String bStr0 = b + "";
// 1
System.out.println(iStr0);
// 66.666
System.out.println(dStr0);
// true
System.out.println(bStr0);
String iStr = String.valueOf(i);
String dStr = String.valueOf(d);
String bStr = String.valueOf(b);
String iString = Integer.toString(i);
String dString = Double.toString(d);
String bString = Boolean.toString(b);
// true
System.out.println(iStr.equals(iString));
// true
System.out.println(dStr.equals(dString));
// true
System.out.println(bStr.equals(bString));
🍀 基本类型转换为字符串可通过拼接一个空串来简单实现
四、高精度计算
(1) 计算机中浮点数都是近似值
💐 float 和 double 存储的只是小数的近视值，并非精确值，因此不适合用来做高精度计算
💐 小数转换为二进制可能是无穷的（如：0.7）
💐 计算机保留的仅仅是 0.7 的二进制数的一部分（所以浮点数在计算机中肯定是近似值）
public class TestDemo
public static void main(String[] args)
double d1 = 0.7;
double d2 = 0.7;
// 0.48999999999999994
System.out.println(d1 * d2);
(2) BigDecimal
💐 java.math.BigDecimal 类可专门用来做高精度计算
💐 通过数字字符串创建 BigDecimal 对象
💐 通过 BigDecimal 内的方法计算加、减、乘和除
public class TestDemo
public static void main(String[] args)
double d1 = 0.7;
Math.random()是生成随机选取大于等于0且小于1的伪随机数，也就是说，从0（包含0）往上且不包括1（去除1）的所有范围。
Random类包含有参数和无参数的构造方法，其中无参数的构造方法每次都是使用当前系统时间作为种子，而有参数的构造方法是使用一个固定值（参数）作为种子。每次使用时先创建一个Random对象，称为随机数生成器，然后调用Random.next**()方法获取数值。
Math.random()方法生成随机数
生成一个[0，1)之间的随机数，举例参考代码如下：
package com.yoodb.study.other.random;
public class DemoTest01
public static void main(String[]args)
System.out.println("通过Math.random产生的随机数列[关注微信公众号“Java精选”]：");
for (int j = 0; j < 8; j++)
System.out.print(Math.random() + ",");
运行结果如下：
通过Math.random产生的随机数列[关注微信公众号“Java精选”]：
0.5956019878671859,0.24739500123720504,0.09675226363769507,0.11460305663401749,0.7565292415953803,0.13633278295115547,0.7136188381381711,0.9789645131075377,
生成一个8位的随机整数，参考代码如下：
package com.yoodb.study.other.random;
public class DemoTest02
public static void main(String[]args)
int rand = (int)(Math.random()*100000000);
System.out.println("生成一个8位的随机整数为：" + rand);
运行结果如下：
生成一个8位的随机整数为：11891302
Random类生成随机数
有参数构造方法：随机数生成器即Random对象，种子的值100。生成[0-n)的数值，也就是包括0，但是不包括n且全都是整数，代码如下：
package com.yoodb.study.other.random;
import java.util.Random;
public class DemoTest03
public static void main(String[]args)
for(int i = 0; i < 2; i++)
System.out.println("执行第" + (i+1) + "次");
Random random = new Random(100);
for(int j = 0; j < 3; j++)
System.out.println("生成[0-50)的整数值为：" + random.nextInt(50));
运行结果如下：
执行第1次
生成[0-50)的整数值为：15
生成[0-50)的整数值为：0
生成[0-50)的整数值为：24
执行第2次
生成[0-50)的整数值为：15
生成[0-50)的整数值为：0
生成[0-50)的整数值为：24
注：当使用有参数的构造创建随机数生成器然后生成随机数序列时，产生的随机数是经过传递的参数计算得到的，具有相同参数的Random对象生成的随机数序列相同。
无参数构造方法：随机数生成器即Random对象，不传递种子。生成[0-n)的数值，也就是包括0，但是不包括n且全都是整数，代码如下：
package com.yoodb.study.other.random;
import java.util.Random;
public class DemoTest03
public static void main(String[]args)
for(int i = 0; i < 2; i++)
System.out.println("执行第" + (i+1) + "次");
Random random = new Random();
for(int j = 0; j < 3; j++)
System.out.println("生成[0-50)的整数值为：" + random.nextInt(50));
运行结果如下：
执行第1次
生成[0-50)的整数值为：44
生成[0-50)的整数值为：45
生成[0-50)的整数值为：38
执行第2次
生成[0-50)的整数值为：40
生成[0-50)的整数值为：34
生成[0-50)的整数值为：14
注：通过无参构造创建Random对象，其本质是也是种子，只不过种子不是具体的数值，而是系统当前的时间，也因此创建的随机数是不相同的。
Random类源码分析
关于Random类，其构造方法源码如下：
/**
* Creates a new random number generator. This constructor sets
* the seed of the random number generator to a value very likely
* to be distinct from any other invocation of this constructor.
*/
public Random()
this(seedUniquifier() ^ System.nanoTime());
译：创建新的随机数生成器。此构造方法设置随机数生成器的种子是一个值与此构造方法的任何其他调用不同。
点击this，跳转到对应的有参构造中，显然由代码可以看出种子的生成和当前时间有关系，因此这样生成的种子是唯一的。
public Random(long seed)
if (getClass() == Random.class)
this.seed = new AtomicLong(initialScramble(seed));
else
// subclass might have overriden setSeed
this.seed = new AtomicLong();
setSeed(seed);
Math.random()和Random类两者关系
查看Math类源码，具体如下：
...
private static final class RandomNumberGeneratorHolder
static final Random randomNumberGenerator = new Random();
...
public static double random()
return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
...
从Math类的源码分析可以看出Math.random()方法内部调用的方法就是Random类中的nextDouble()方法，此时可以看出Math.random()返回的是double类型值。通过比较可以得出结论：1、随机数是种子经过计算生成的。2、Random类中不含参的构造方法每次都是使用当前时间作为种子，随机性强；而含有参数的构造方法是以参数为种子产生的伪随机数，更有可预见性。3、具有相同种子值的Random对象生成的随机数相同；种子值不同，产生的随机数不再一致。4、Math.random()方法中内部调用的方法是Random类中的nextDouble()方法。
以上是关于35Java 中的 Math 类Random 随机数UUID格式化字符串或数字字符串和数字的相互转换高精度计算BigDecimal计算机中的浮点数都是近似值的主要内容，如果未能解决你的问题，请参考以下文章