JavaSE - 包装类与数字处理类

最新推荐文章于 2023-01-06 19:13:52 发布

「已注销」

最新推荐文章于 2023-01-06 19:13:52 发布

阅读量211

点赞数

分类专栏：我的Java基础学习之路文章标签： java javase

本文链接：https://blog.csdn.net/qq_29718835/article/details/121188881

版权

我的Java基础学习之路专栏收录该内容

25 篇文章 0 订阅

订阅专栏

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`（-2³¹）
`MAX_VALUE`	`int`	`int`类型数值可表示的最大数	`0x7fffffff`（2³¹-1）
`SIZE`	`int`	`int`类型数值所占内存的位数	`32`（4字节，32位）
`TYPE`	`Class<Integer>`	`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`（-2⁷）
`MAX_VALUE`	`byte`	`byte`类型数值可表示的最大数	`127`（2⁷-1）
`SIZE`	`int`	`byte`类型数值所占内存的位数	`8`（1字节，8位）
`TYPE`	`Class<Byte>`	`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`（-2¹⁵）
`MAX_VALUE`	`short`	`short`类型数值可表示的最大数	`32767`（2¹⁵-1）
`SIZE`	`int`	`short`类型数值所占内存的位数	`16`（2字节，16位）
`TYPE`	`Class<Short>`	`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`（-2⁶³）
`MAX_VALUE`	`long`	`long`类型数值可表示的最大数	`0x7fffffffffffffffL`（2⁶³-1）
`SIZE`	`int`	`long`类型数值所占内存的位数	`64`（8字节，64位）
`TYPE`	`Class<Long>`	`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×10³⁸）
`MIN_VALUE`	`float`	`float`类型能表示的最小精度（最小正数）	`0x0.000002P-126f`（`1.4E-45`，1.4×10^-45）
`SIZE`	`int`	`float`类型数值所占内存的位数	`32`（4字节，32位）
`TYPE`	`Class<Float>`	`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×10³⁰⁸）
`MIN_VALUE`	`double`	`double`类型能表示的最小精度（最小正数）	`0x0.0000000000001P-1022`（`4.9E-324`，4.9×10^-324）
`SIZE`	`int`	`double`类型数值所占内存的位数	`64`（8字节，64位）
`TYPE`	`Class<Double>`	`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<Character>`	`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：

javap反编译工具查看字节码文件

可以看到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`次方（即e^a）
`static log(double a)`	`double`	返回以自然常数e为底`a`的对数（即log_ea，或lna）
`static log10(double a)`	`double`	返回以10为底`a`的对数（即log₁₀a，或lga）
`static sqrt(double a)`	`double`	返回`a`的平方根（即√(a)，且a不能为负数，否则返回`NaN`）
`static cbrt(double a)`	`double`	返回`a`的立方根（即³√(a)）
`static pow(double a, double b)`	`double`	返回a的b次方（即a^b）

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`

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE - 包装类与数字处理类

JavaSE - 包装类与数字处理类本节学习目标：了解基本类型的包装类；熟悉并掌握包装类的使用方法；了解数字的格式化方法；了解Math类与常用数学运算方法；了解并掌握随机数的使用与Random类；了解大数字运算。1. 包装类众所周知，Java语言中万物皆对象，在Java中，对象是程序执行的基本单元，但是基本数据类型变量却不是一个对象，为了能将基本数据类型视为对象进行处理，Java提供了基本数据类型（Primitive Type）的包装类（Wrapper Type）：基本数据
复制链接

扫一扫