JavaSE - 包装类与数字处理类

JavaSE - 包装类与数字处理类

本节学习目标：

• 了解基本类型的包装类；
• 熟悉并掌握包装类的使用方法；
• 了解数字的格式化方法；
• 了解Math类与常用数学运算方法；
• 了解并掌握随机数的使用与Random类；
• 了解大数字运算。

1. 包装类

众所周知，Java语言中万物皆对象，在Java中，对象是程序执行的基本单元，但是基本数据类型变量却不是一个对象，
为了能将基本数据类型视为对象进行处理，Java提供了基本数据类型（Primitive Type）的包装类（Wrapper Type）：

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

所有的包装类都位于java.lang包下，这意味着无需使用import关键字导入即可使用。

1.1 Integer 类

Integer类是基本数据类型int的包装类，包装类内部封装了一个int型成员变量value用来存储数据。

1. 构造方法

Integer类有两种构造方法：

• Integer(int value)：将提供的int类型参数包装为Integer对象。

Integer i = new Integer(7);
// 上面的等价于
Integer i = 7;

• Integer(String s)：使用parseInt()方法将数值型字符串转换为int类型参数，再包装为Integer对象。如果提供的字符串不是纯数值型，将抛出异常（NumberFormatException）。

Integer i = new Integer("872");

2. 常用方法

Integer类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Integer对象的字符串形式
static toString(int i)	String	返回int类型数值i的字符串形式
static toHexString(int i)	String	返回int类型数值i的十六进制字符串形式
static toOctalString(int i)	String	返回int类型数值i的八进制字符串形式
static toBinaryString(int i)	String	返回int类型数值i的二进制字符串形式
static parseInt(String s)	int	将数值型字符串s解析为int类型数值
static valueOf(int i)	Integer	将int类型数值i解析为Integer对象
static valueOf(String s)	Integer	将数值型字符串s解析为Integer对象
compareTo(Integer anotherInteger)	int	将该Integer对象的值与另一个Integer对象anotherInteger的值比较， 两值相等返回0，小于anotherInteger返回-1，大于anotherInteger返回1
static compare(int x, int y)	int	将int类型数值x，y相互比较，x与y相等返回0， x小于y返回-1，x大于y返回1
static sum(int a, int b)	int	返回int类型数值a和b相加的和
static max(int a, int b)	int	返回int类型数值a和b比较的较大值
static min(int a, int b)	int	返回int类型数值a和b比较的较小值

3. 常量

Integer类提供以下静态常量可供使用：

静态常量	类型	说明	值
MIN_VALUE	int	int类型数值可表示的最小数	0x80000000（-231）
MAX_VALUE	int	int类型数值可表示的最大数	0x7fffffff（231-1）
SIZE	int	int类型数值所占内存的位数	32（4字节，32位）
TYPE	Class	int类型对应的Class实例	int

1.2 Byte 类

Byte类是基本数据类型byte的包装类，包装类内部封装了一个byte类型成员变量value用来存储数据。

1. 构造方法

Byte类有两种构造方法：

• Byte(byte value)：将提供的byte类型参数包装为Byte对象。

Byte b = new Byte(6);
// 上面的等价于
Byte b = 6;

• Byte(String s)：使用parseByte()方法将数值型字符串转换为byte类型参数，再包装为Byte对象。

Byte b = new Byte("110");

2. 常用方法

Byte类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Byte对象的字符串形式
static toString(byte b)	String	返回byte类型数值b的字符串形式
static parseByte(String s)	byte	将数值型字符串s解析为byte类型数值
static valueOf(byte b)	Byte	将byte类型数值b解析为Byte对象
static valueOf(String s)	Byte	将数值型字符串s解析为Byte对象
compareTo(Byte anotherByte)	int	将该Byte对象的值与另一个Byte对象anotherByte的值比较，返回它们两个相减的差值。 两者相等差值为0，小于anotherByte差值为负数，大于anotherByte差值为正数
static compare(byte x, byte y)	int	将byte类型数值x、y相互比较，返回它们两个相减的差值。 两者相等差值为0，x小于y差值为负数，x大于y差值为正数

3. 常量

Byte类提供以下静态常量可供使用：

静态常量	类型	说明	值
MIN_VALUE	byte	byte类型数值可表示的最小数	-128（-27）
MAX_VALUE	byte	byte类型数值可表示的最大数	127（27-1）
SIZE	int	byte类型数值所占内存的位数	8（1字节，8位）
TYPE	Class	byte类型对应的Class实例	byte

1.3 Short 类

Short类是基本数据类型short的包装类，包装类内部封装了一个short类型成员变量value用来存储数据。

1. 构造方法

Short类有两种构造方法：

• Short(short value)：将提供的short类型参数包装为Short对象。

Short s = new Short(6);
// 上面的等价于
Short s = 6;

• Short(String s)：使用parseShort()方法将数值型字符串转换为short类型参数，再包装为Short对象。

Short s = new Short("785");

2. 常用方法

Short类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Short对象的字符串形式
static toString(short s)	String	返回short类型数值s的字符串形式
static parseShort(String s)	short	将数值型字符串s解析为short类型数值
static valueOf(short b)	Short	将short类型数值b解析为Short对象
static valueOf(String s)	Short	将数值型字符串s解析为Short对象
compareTo(Short anotherShort)	int	将该Short对象的值与另一个Short对象anotherShort的值比较，返回它们两个相减的差值。 两者相等差值为0，小于anotherShort差值为负数，大于anotherShort差值为正数
static compare(short x, short y)	int	将short类型数值x、y相互比较，返回它们两个相减的差值。 两者相等差值为0，x小于y差值为负数，x大于y差值为正数

3. 常量

Short类提供以下静态常量可供使用：

静态常量	类型	说明	值
MIN_VALUE	short	short类型数值可表示的最小数	-32768（-215）
MAX_VALUE	short	short类型数值可表示的最大数	32767（215-1）
SIZE	int	short类型数值所占内存的位数	16（2字节，16位）
TYPE	Class	short类型对应的Class实例	short

1.4 Long 类

Long类是基本数据类型long的包装类，包装类内部封装了一个long类型成员变量value用来存储数据。

1. 构造方法

Long类有两种构造方法：

• Long(long value)：将提供的long类型参数包装为Long对象。

Long l = new Long(6L);
// 上面的等价于
Long l = 6;

• Long(String s)：使用parseLong()方法将数值型字符串转换为long类型参数，再包装为Long对象。

Long s = new Long("78547552");

2. 常用方法

Long类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Long对象的字符串形式
static toString(long l)	String	返回long类型数值l的字符串形式
static toHexString(long l)	String	返回long类型数值l的十六进制字符串形式
static toOctalString(long l)	String	返回long类型数值l的八进制字符串形式
static toBinaryString(long l)	String	返回long类型数值l的二进制字符串形式
static parseLong(String s)	long	将数值型字符串s解析为long类型数值
static valueOf(long l)	Long	将long类型数值l解析为Long对象
static valueOf(String s)	Long	将数值型字符串s解析为Long对象
compareTo(Long anotherLong)	int	将该Long对象的值与另一个Long对象anotherLong的值比较， 两值相等返回0，小于anotherLong返回-1，大于anotherLong返回1
static compare(long x, long y)	int	将long类型数值x，y相互比较，x与y相等返回0， x小于y返回-1，x大于y返回1
static sum(long a, long b)	long	返回long类型数值a和b相加的和
static max(long a, long b)	long	返回long类型数值a和b比较的较大值
static min(long a, long b)	long	返回long类型数值a和b比较的较小值

3. 常量

Long类提供以下静态常量可供使用：

静态常量	类型	说明	值
MIN_VALUE	long	long类型数值可表示的最小数	0x8000000000000000L（-263）
MAX_VALUE	long	long类型数值可表示的最大数	0x7fffffffffffffffL（263-1）
SIZE	int	long类型数值所占内存的位数	64（8字节，64位）
TYPE	Class	long类型对应的Class实例	long

1.5 Float 类

Float类是基本数据类型float的包装类，包装类内部封装了一个float类型成员变量value用来存储数据。

1. 构造方法

Float类有三种构造方法：

• Float(float value)：将提供的float型参数包装为Float对象。

Float f = new Float(7.35F);
// 上面的等价于
Float f = 7.35F;

• Float(double value)：将提供的double型参数强转为float类型后包装为Float对象。

Float f = new Float(7.35);
// 上面的等价于
Float f = (float) 7.35;

• Float(String s)：使用parseFloat()方法将数值型字符串转换为float类型参数，再包装为Float对象。

Float f = new Float("7.35F");
Float f = new Float("7.35D")
// 上面的等价于
Float f = new Float("7.35")

2. 常用方法

Float类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Float对象的字符串形式
static toString(float f)	String	返回float类型数值f的字符串形式
static toHexString(float f)	String	返回float类型数值f的十六进制字符串形式
static parseFloat(String s)	float	将数值型字符串s解析为float类型数值
static valueOf(float f)	Float	将float类型数值f解析为Float对象
static valueOf(String s)	Float	将数值型字符串s解析为Float对象
compareTo(Float anotherFloat)	int	将该Float对象的值与另一个Float对象anotherFloat的值在数值上进行比较， 两值相等返回0，小于anotherFloat返回-1，大于anotherFloat返回1
static compare(float f1, float f2)	int	将float类型数值f1、f2在数值上相互比较， f1与f2相等返回0，f1小于f2返回-1，f1大于f2返回1
static isNaN(float v)	boolean	判断float类型数值v是否为非数字，是返回true，否返回false
isNaN()	boolean	判断该Float对象的值是否为非数字，是返回true，否返回false
static isInfinite(float v)	boolean	判断float类型数值v在数值上是否无限大，是返回true，否返回false
isInfinite()	boolean	判断该Float对象的值在数值上是否无限大，是返回true，否返回false
static isFinite(float v)	boolean	判断float类型数值v是否为有限浮点数，是返回true，否返回false
static sum(float a, float b)	float	返回float类型数值a和b相加的和
static max(float a, float b)	float	返回float类型数值a和b比较的较大值
static min(float a, float b)	float	返回float类型数值a和b比较的较小值

3. 常量

Float类提供以下静态常量可供使用：

静态常量	类型	说明	值
POSITIVE_INFINITY	float	float类型表示的正无穷大	Infinity（1.0F / 0.0F）
NEGATIVE_INFINITY	float	float类型表示的负无穷大	-Infinity（-1.0F / 0.0F）
NaN	float	float类型表示的非数字	NaN（0.0F / 0.0F）
MAX_VALUE	float	float类型能表示的最大精度（最大正数）	0x1.fffffeP+127f（3.4028235E38，3.4×1038）
MIN_VALUE	float	float类型能表示的最小精度（最小正数）	0x0.000002P-126f（1.4E-45，1.4×10-45）
SIZE	int	float类型数值所占内存的位数	32（4字节，32位）
TYPE	Class	float类型对应的Class实例	float

1.6 Double 类

Double类是基本数据类型double的包装类，包装类内部封装了一个double类型成员变量value用来存储数据。

1. 构造方法

Double类有两种构造方法：

• Double(double value)：将提供的double类型参数包装为Double对象。

Double d = new Double(8.457);
// 上面的等价于
Double d = 8.457;

• Double(String s)：使用parseDouble()方法将数值型字符串s转换为double类型参数，再包装为Double对象。

Double d = new Double("8.457");

2. 常用方法

Double类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Double对象的字符串形式
static toString(double d)	String	返回double类型数值f的字符串形式
static toHexString(double d)	String	返回double类型数值f的十六进制字符串形式
static parseDouble(String s)	double	将数值型字符串s解析为double类型数值
static valueOf(double d)	Double	将double类型数值d解析为Double对象
static valueOf(String s)	Double	将数值型字符串s解析为Double对象
compareTo(Double anotherDouble)	int	将该Double对象的值与另一个Double对象anotherDouble的值在数值上进行比较， 两值相等返回0，小于anotherDouble返回-1，大于anotherDouble返回1
static compare(double d1, double d2)	int	将double类型数值d1、d2在数值上相互比较， d1与d2相等返回0，d1小于d2返回-1，d1大于d2返回1
static isNaN(double v)	boolean	判断double类型数值v是否为非数字，是返回true，否返回false
isNaN()	boolean	判断该Double对象的值是否为非数字，是返回true，否返回false
static isInfinite(double v)	boolean	判断double类型数值v在数值上是否无限大，是返回true，否返回false
isInfinite()	boolean	判断该Double对象的值在数值上是否无限大，是返回true，否返回false
static isFinite(double v)	boolean	判断double类型数值v是否为有限浮点数，是返回true，否返回false
static sum(double a, double b)	double	返回double类型数值a和b相加的和
static max(double a, double b)	double	返回double类型数值a和b比较的较大值
static min(double a, double b)	double	返回double类型数值a和b比较的较小值

3. 常量

静态常量	类型	说明	值
POSITIVE_INFINITY	double	double类型表示的正无穷大	Infinity（1.0 / 0.0）
NEGATIVE_INFINITY	double	double类型表示的负无穷大	-Infinity（-1.0 / 0.0）
NaN	double	double类型表示的非数字	NaN（0.0 / 0.0）
MAX_VALUE	double	double类型能表示的最大精度（最大正数）	0x1.fffffffffffffP+1023（1.7976931348623157E308，1.8×10308）
MIN_VALUE	double	double类型能表示的最小精度（最小正数）	0x0.0000000000001P-1022（4.9E-324，4.9×10-324）
SIZE	int	double类型数值所占内存的位数	64（8字节，64位）
TYPE	Class	double类型对应的Class实例	double

1.7 Number 类

Number类是一个抽象类，它是BigDecimal（大数小数）、BigInteger（大数整数）、Integer，Byte，Short，Long，Float和Double等类的父类。

Number类中有四个抽象方法和两个方法，这些方法分别被继承Number类的子类所实现：

方法	返回值类型	功能	说明
abstract intValue()	int	以int类型返回当前数值	抽象方法，子类分别有此方法的实现
abstract longValue()	long	以long类型返回当前数值	抽象方法，子类分别有此方法的实现
abstract floatValue()	float	以float类型返回当前数值	抽象方法，子类分别有此方法的实现
abstract doublevalue()	double	以double类型返回当前数值	抽象方法，子类分别有此方法的实现
bytevalue()	byte	以byte类型返回当前数值	默认实现为(byte)intValue()，基本数值类型分别重写了该方法
shortValue()	short	以short类型返回当前数值	默认实现为(short)intValue()，基本数值类型分别重写了该方法

1.8 Boolean 类

Boolean类是基本数据类型boolean的包装类，包装类内部封装了一个boolean类型成员变量value用来存储数据。

1. 构造方法

Boolean类有两种构造方法：

• Boolean(boolean value)：将提供的boolean类型参数包装为Boolean对象。

Boolean b = new Boolean(true);
// 上面的等价于
Boolean b = true;

• Boolean(String s)：使用parseBoolean()方法将字符串s转换为boolean类型参数，再包装为Boolean对象。

Boolean b = new Boolean("true");

2. 常用方法

Boolean类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Boolean对象的字符串形式
static toString(boolean b)	String	返回boolean类型参数b的字符串形式
static parseBoolean(String s)	boolean	将布尔型字符串s解析为boolean类型 （"true"字符串（不区分大小写）都被解析为true，否则为false）
static valueOf(boolean b)	Boolean	将boolean类型参数b解析为Boolean对象
static valueOf(String s)	Boolean	将布尔型字符串s解析为Boolean对象
static logicalAnd(boolean a, boolean b)	boolean	返回boolean类型参数a对b的逻辑与运算结果（a && b）
static logicalOr(boolean a, boolean b)	boolean	返回boolean类型参数a对b的逻辑或运算结果（ a || b）
static logicalXor(boolean a, boolean b)	boolean	返回boolean类型参数a对b的逻辑异或运算结果（a ^ b）

3. 常量

Boolean类提供了以下静态常量可供使用：

静态常量	类型	说明	值
TRUE	Boolean	布尔值true对应的Boolean对象	new Boolean(true)
FALSE	Boolean	布尔值false对应的Boolean对象	new Boolean(false)
TYPE	Class(Boolean)	boolean类型对应的Class实例	boolean

1.9 Character 类

Character类是基本数据类型char的包装类，包装类内部封装了一个char类型成员变量value用来存储数据。

1. 构造方法

Character类只有一个构造方法：

• Character(char value)：将char类型参数包装为Character对象。

Character c = new Character('A');
// 上面的等价于
Character c = 'A';

2. 常用方法

Character类提供了很多常用的处理方法：

方法	返回值类型	功能
toString()	String	返回该Character对象的字符串形式
static toString(char c)	String	返回char类型字符c的字符串形式
charValue()	char	返回该Character对象的值
static isLowerCase(char ch)	boolean	判断字符ch是否为小写字母
static isUpperCase(char ch)	boolean	判断字符ch是否为大写字母
static isSpaceChar(char ch)	boolean	判断字符ch是否为空格
static toLowerCase(char ch)	char	将大写字母字符ch转换为小写字母
static toUpperCase(char ch)	char	将小写字母字符ch转换为大写字母

3. 常量

Character类提供了很多常量，包括了很多特殊字符的unicode值。在此仅列出Character类属性相关的常量：

静态常量	类型	说明	值
MIN_VALUE	char	char类型表示的最小值	'u0000'
MAX_VALUE	char	char类型表示的最大值	'uffff'
SIZE	int	char类型数值所占内存的位数	16（2字节，16位）
TYPE	Class	char类型对应的Class实例	char

1.10 自动装箱与拆箱

在JDK1.5版本新增了两个功能：自动装箱（Auto boxing）与自动拆箱（Auto Unboxing）。

• 自动装箱：将一个基本数据类型变量赋值给它对应的包装类引用时，系统自动将它包装为对应的包装类对象来进行相关操作，即基本数据类型当成引用数据类型使用。
• 自动拆箱：需要基本数据类型时，传入的是包装类的一个对象，则系统自动将包装类对象转换为对应的基本数据类型变量进行操作，即引用数据类型当成基本数据类型使用。

编写代码进行测试：

public class BoxingTest {
    public static void main(String[] args) {
        Integer i = 7; // 自动装箱
        int j = i;     // 自动拆箱
    }
}

使用JDK提供的反汇编工具javap.exe查看编译后的字节码文件，执行命令javap -c BoxingTest.class：

可以看到JVM执行main()方法时执行的指令：

• 第3（2）条指令：执行静态方法（invokestatic），对应第3（#2）行源码，执行了java.lang.Integer类的valueOf(int)静态方法。
• 第8（7）条指令：执行成员方法（invokevirtual），对应第4（#3）行源码，执行了java.lang.Integer类的intValue()成员方法。

所以JVM执行这两行语句时，自动替换成下列方法执行：

Integer i = Integer.valueOf(7);
int j = i.intValue();

从反编译得到的字节码内容可以看出，在进行装箱时自动调用的是Integer类的valueOf(int)方法，进行拆箱时自动调用的是Integer类的intValue()方法。

面试题：下面的语句输出结果为？

public class Test {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        Integer c = 200;
        Integer d = 200;
        System.out.println(a == b);
        System.out.println(c == d);
    }
}

// 运行结果
// true
// false

解析：Java自动装箱与自动拆箱（包装类） - CSDN/Loisy-M

2. 数字处理类

Java提供了多种数字处理类，如DecimalFormat类，Math类，Random类，BigInteger类与BigDecimal类等来处理数学问题，随机问题，商业货币问题，科学计数问题等实际问题。

2.1 数字格式化

Java对浮点型数据（float与double）提供默认格式化：

• 数据绝对值大于0.001并且小于10000000，将以常规小数形式表示；
• 数据绝对值小于0.001或者大于10000000，将以科学计数法表示。

double d1 = 9999999.0;
double d2 = 10000000.0;
System.out.println(d1);
System.out.println(d2);

// 运行结果
9999999.0
1.0E7

使用java.text包下的DecimalFormat类中的方法可以实现指定格式的格式化，如货币，商品价格等需要保留若干位小数，保留若干位有效数字。

DecimalFormat类是NumberFormat类的一个子类，用于格式化十进制数字。支持的格式化特殊字符：

特殊字符	说明
0	占位符0，如果该位不存在数字，使用数字0替代显示
#	占位符#，如果该位存在数字，则显示。
.	小数分隔符
-	负号
,	分组分隔符
E	分割科学计数法中的尾数和指数
%	放置在数字的前缀或后缀，将数字乘以100并显示为百分数
u2030	放置在数字的前缀或后缀，将数字乘以1000并显示为千分数
u00A4	放置在数字的前缀或后缀，作为货币记号
'	如果想要上述符号当做普通符号使用，使用单引号即可

演示使用DecimalFormat类进行数字格式化：

import java.text.DecimalFormat;
public class FormatTest {
    public static void main(String[] args) {
        DecimalFormat formatter = new DecimalFormat();
        formatter.applyPattern("###,###.##");
        // 以上两行代码可以使用构造方法简化
        // DecimalFormat formatter = new DecimalFormat("###,###.##");
        String str = formatter.format(472416.15);
        System.out.println(str);
    }
}

// 运行结果
// 472,416.15

2.2 Math 类与数学运算

Math类位于java.lang包下，提供了数学运算中常用的静态常量与静态方法。

1. 常量

静态常量	类型	说明	值
E	double	自然常数e	2.7182818284590452354
PI	double	圆周率π	3.14159265358979323846

2. 三角函数方法

三角函数方法	返回值类型	功能
static sin(double a)	double	返回一个弧度a的三角正弦值
static cos(double a)	double	返回一个弧度a的三角余弦值
static tan(double a)	double	返回一个弧度a的三角正切值
static asin(double a)	double	返回一个弧度a的三角反正弦值
static acos(double a)	double	返回一个弧度a的三角反余弦值
static atan(double a)	double	返回一个弧度a的三角反正切值
static toRadians(double a)	double	将角度a转换为弧度
static toDegrees(double a)	double	将弧度a转换为角度

3. 指数函数方法

指数函数方法	返回值类型	功能
static exp(double a)	double	返回自然常数e的a次方（即ea）
static log(double a)	double	返回以自然常数e为底a的对数（即logea，或lna）
static log10(double a)	double	返回以10为底a的对数（即log10a，或lga）
static sqrt(double a)	double	返回a的平方根（即√(a)，且a不能为负数，否则返回NaN）
static cbrt(double a)	double	返回a的立方根（即3√(a)）
static pow(double a, double b)	double	返回a的b次方（即ab）

4. 取整函数方法

取整函数方法	返回值类型	功能
static ceil(double a)	double	返回大于等于a的最小整数（即向上取整）
static floor(double a)	double	返回小于a的最大整数（即向下取整）
static rint(double a)	double	返回与a最接近的整数
static round(float a)	int	将a加上0.5后返回小于等于a的最大整数（即四舍五入，结果为float型）
static round(double a)	long	将a加上0.5后返回小于等于a的最大整数（即四舍五入，结果为long型）

5. 最值与绝对值函数方法

最值与绝对值函数方法	返回值类型	功能
static max(double a, double b)	double	返回double型参数a与b两者的最大值
static min(int a, int b)	int	返回int型参数a与b两者的最小值
static min(long a, long b)	long	返回long型参数a与b两者的最小值
static min(float a, float b)	float	返回float型参数a与b两者的最小值
static min(double a, double b)	double	返回double型参数a与b两者的最小值
static abs(int a)	int	返回int型参数a的绝对值
static abs(long a)	long	返回long型参数a的绝对值
static abs(float a)	float	返回float型参数a的绝对值
static abs(double a)	double	返回double型参数a的绝对值

2.3 随机数

随机数在数组的常用算法章节简单提到了，这里深入学习。

1. Math.random() 方法

Math类中的静态random()方法可用于产生随机数，默认生成大于等于0.0且小于1.0的double型随机数，即0 <= Math.random() < 1，[0.0, 1.0)区间内的随机数。

为了能够使用此方法产生任意范围的随机数，可以使用两种方法：

• (int) (Math.random() * n)：产生[0, n)之间的随机整数；
• m + (int) (Math.random() * (m - n))：产生[m, n)之间的随机整数。

编写代码进行测试：

import java.util.Arrays;
public class MathRandomTest {
    public static void main(String[] args) {
        int[] arr = randomGenerate(10, 50, 60);
        System.out.println(Arrays.toString(arr));
    }
    private static int[] randomGenerate(int length, int leftBound, int rightBound) {
        int[] arr = new int[length];
        for (int i = 0; i < length; i++) {
            arr[i] = leftBound + (int) (Math.random() * (rightBound - leftBound));
        }
        return arr;
    }
}

运行结果：

[55, 57, 57, 55, 54, 53, 59, 50, 51, 59]

2. Random 类

Random类位于java.util包下，是Java专门产生随机数与处理随机数的工具类。

可以通过实例化一个Random对象创建一个随机数生成器：

• Random()：默认构造方法，使用系统当前时间作为随机数种子产生随机数。
• Random(long seed)：使用指定的随机数种子产生随机数。

Random类提供了很多产生随机数的方法：

方法	返回值类型	功能
nextInt()	int	产生一个int类型范围内的随机整数
nextInt(int n)	int	产生一个[0, n)区间内的随机整数
nextLong()	long	产生一个long类型范围内的随机整数
nextBoolean()	boolean	产生一个随机布尔值
nextFloat()	float	产生一个[0, 1)区间内的随机float型浮点数
nextDouble()	double	产生一个[0, 1)区间内的随机double型浮点数
nextGaussian()	double	产生一个概率密度满足高斯分布的的double型浮点数

2.4 大数运算

Java提供了大数字的操作类，即BigInteger与BigDecimal，分别对整型大数与浮点型大数进行操作。两者都位于java.math包下。

1. BigInteger 类

BigInteger类可以处理任意精度的整数，可以表示任何大小的整数值。

常用的构造方法为BigInteger(String val)，即使用数值型字符串表示值：

BigInteger bi = new BigInteger("1");

BigInteger类支持基本的数学运算和位运算：

方法	返回值类型	功能
add(BigInteger val)	BigInteger	加法运算
subtract(BigInteger val)	BigInteger	减法运算
multiply(BigInteger val)	BigInteger	乘法运算
divide(BigInteger val)	BigInteger	除法运算
remainder(BigInteger val)	BigInteger	取余运算
divideAndRemainder(BigInteger val)	BigInteger[]	返回余数和商，返回的数组中第一个元素为商，第二个元素为余数
pow(int exponent)	BigInteger	返回当前数的exponent次方的值
negate()	BigInteger	返回相反数
shiftLeft(int n)	BigInteger	按位左移，若为负数则右移
shiftRight(int n)	BigInteger	按位右移，若为负数则左移
and(BigInteger val)	BigInteger	按位与运算
or(BigInteger val)	BigInteger	按位或运算
compareTo(BigInteger val)	int	比较运算，当前数与参数相等返回0，当前数大于参数返回1，当前数小于参数返回-1
equals(Object x)	boolean	继承Object类的equals()方法，比较当前数与参数的值，相等返回true，不相等返回false
min(BigInteger val)	BigInteger	返回较小值
max(BigInteger val)	BigInteger	返回较大值

2. BigDecimal 类

BigInteger类可以处理任意精度的浮点数，可以表示任何大小的浮点数值。

常用的构造方法：

• BigDecimal(double val)：将double类型数值转换为BigDecimal对象。
• BigDecimal(String val)：将数值型字符串转换为BigDecimal对象。

简单介绍BigDecimal类的四则运算：

方法	返回值类型	功能
add(BigDecimal augend)	BigDecimal	加法运算
subtract(BigDecimal subtrahend)	BigDecimal	减法运算
multiply(BigDecimal multiplicand)	BigDecimal	乘法运算
divide(BigDecimal divisor, int scale, int roundingMode)	BigDecimal	除法运算，第一个参数为除数，第二个参数为保留的小数位数，第三个参数为BigDecimal类定义的常量，代表处理模式

divide()方法的第三个参数为BigDecimal类定义的静态常量，代表处理模式：

roundingMode常量	类型	说明	值
ROUND_UP	int	商的最后一位如果大于0，则向前进位	0
ROUND_DOWN	int	商的最后一位省略	1
ROUND_CEILING	int	商的如果是正数则按照ROUND_UP模式处理，如果为负数则按照ROUND_DOWN模式处理	2
ROUND_FLOOR	int	与ROUND_CEILING模式相反	3
ROUND_HALF_UP	int	对商进行四舍五入操作，商的最后一位小于等于5则舍弃，大于5则进位	4
ROUND_HALF_DOWN	int	对商进行四舍五入操作，商的最后一位小于5则舍弃，大于等于5则进位	5
ROUND_HALF_EVEN	int	如果商的倒数第二位为奇数则按照ROUND_HALF_UP模式处理，如果为偶数则按照ROUND_HALF_DOWN模式处理	6