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<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 (-27) |
MAX_VALUE | byte | byte 类型数值可表示的最大数 | 127 (27-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 (-215) |
MAX_VALUE | short | short 类型数值可表示的最大数 | 32767 (215-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 (-263) |
MAX_VALUE | long | long 类型数值可表示的最大数 | 0x7fffffffffffffffL (263-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×1038) |
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×10308) |
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
:
可以看到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 |