526互联

JAVA中数值类型的类型和类以及使用的选择

发布时间 2023-07-21 15:14:50作者: 白露~

数值类型的分类

在JAVA中，数值类型可以分为两大类：基本数据类型和包装类。

基本数据类型共有八种，分别是：

  • 整型：byte、short、int、long
  • 浮点型：float、double
  • 字符型：char
  • 布尔型：boolean

包装类是为了让基本数据类型可以作为对象使用而提供的一种类，它们分别是：

  • Integer：对应int类型
  • Long：对应long类型
  • Byte：对应byte类型
  • Short：对应short类型
  • Double：对应double类型
  • Float：对应float类型
  • Character：对应char类型
  • Boolean：对应boolean类型

除了这些包装类之外，JAVA还提供了两个用于处理大数和高精度计算的类，它们是：

  • BigInteger：可以表示任意精度的整数
  • BigDecimal：可以表示任意精度的浮点数

数值类型的选择

在使用数值类型时，我们需要根据不同的场景和需求来选择合适的类型，以下是一些常见的选择原则：

  • 如果需要表示整数，优先使用int类型，除非数值超过了int的范围，才考虑使用long或者BigInteger。
  • 如果需要表示小数，优先使用double类型，除非需要精确计算（如货币），才考虑使用float或者BigDecimal。
  • 如果需要表示字符，使用char类型或者String类。
  • 如果需要表示布尔值，使用boolean类型或者Boolean类。
  • 如果需要将基本数据类型作为对象使用（如作为泛型参数、集合元素等），使用对应的包装类。
  • 如果需要进行大数或者高精度的运算，使用BigInteger或者BigDecimal类，并注意它们的运算方法和规则。

数值类型的转换

在JAVA中，数值类型之间可以进行转换，转换分为两种：

  • 自动转换：当目标类型的取值范围大于或等于源类型时，可以自动进行转换，无需显式操作。例如：
int a = 10;
long b = a; // int自动转换为long
double c = b; // long自动转换为double
  • 强制转换：当目标类型的取值范围小于源类型时，必须进行强制转换，否则会编译错误。强制转换需要在源类型前加上目标类型作为前缀。例如：
double d = 3.14;
int e = (int) d; // double强制转换为int，小数部分会被舍弃
byte f = (byte) e; // int强制转换为byte，可能会造成数据溢出或精度损失

在进行数值类型的转换时，要注意以下几点：

  • 避免不必要的转换，尽量保持数据的一致性和准确性。
  • 避免强制转换可能造成的数据溢出或精度损失，尽量使用适当的范围和精度来表示数据。
  • 在进行包装类和基本数据类型之间的转换时，可以使用自动装箱和拆箱机制，也可以使用包装类提供的方法。例如：
// 自动装箱和拆箱
Integer g = 100; // int自动装箱为Integer
int h = g; // Integer自动拆箱为int

// 使用包装类的方法
Integer i = Integer.valueOf(100); // int转换为Integer
int j = i.intValue(); // Integer转换为int

数值类型的运算

在JAVA中，数值类型可以进行各种运算，包括：

  • 算术运算：使用+、-、*、/、%等符号进行加、减、乘、除、取余等操作。例如：
int k = 10 + 5; // 加法
int l = 10 - 5; // 减法
int m = 10 * 5; // 乘法
int n = 10 / 5; // 除法
int o = 10 % 5; // 取余
  • 位运算：使用&、|、^、~、<<、>>等符号进行与、或、异或、非、左移、右移等操作。例如：
int p = 10 & 5; // 按位与
int q = 10 | 5; // 按位或
int r = 10 ^ 5; // 按位异或
int s = ~10; // 按位非
int t = 10 << 2; // 左移2位
int u = 10 >> 2; // 右移2位
  • 逻辑运算：使用&&、||、!等符号进行与、或、非等操作。例如：
boolean v = true && false; // 逻辑与
boolean w = true || false; // 逻辑或
boolean x = !true; // 逻辑非
  • 关系运算：使用>、<、>=、<=、==、!=等符号进行大于、小于、大于等于、小于等于、等于、不等于等操作。例如：
boolean y = 10 > 5; // 大于
boolean z = 10 < 5; // 小于
boolean aa = 10 >= 5; // 大于等于
boolean bb = 10 <= 5; // 小于等于
boolean cc = 10 == 5; // 等于
boolean dd = 10 != 5; // 不等于

在进行数值类型的运算时，要注意以下几点：

  • 遵循运算的优先级和结合性，必要时使用括号来改变运算顺序。
  • 避免出现除数为0的情况，否则会抛出异常。
  • 避免出现整数溢出的情况，可以使用BigInteger类来处理大整数的运算。
  • 避免出现浮点数精度丢失的情况，可以使用BigDecimal类来处理高精度的运算。
  • 在进行包装类的运算时，要注意自动拆箱可能造成的空指针异常，以及自动装箱可能造成的性能损耗。
  • 在进行BigInteger和BigDecimal的运算时，要使用它们提供的方法，而不是直接使用运算符。例如：
BigInteger bi1 = new BigInteger("100");
BigInteger bi2 = new BigInteger("50");
BigInteger bi3 = bi1.add(bi2); // 使用add方法进行加法运算，而不是bi1 + bi2

BigDecimal bd1 = new BigDecimal("3.14");
BigDecimal bd2 = new BigDecimal("2.71");
BigDecimal bd3 = bd1.multiply(bd2); // 使用multiply方法进行乘法运算，而不是bd1 * bd2

数值类型的常用方法

在JAVA中，数值类型提供了一些常用的方法，用来实现一些常见的功能，如转换、比较、格式化等。以下是一些常用方法的介绍：

  • xxxValue()：将Number对象转换为xxx数据类型的值并返回。例如：
Integer ee = new Integer(100);
int ff = ee.intValue(); // 将Integer对象转换为int值并返回

Double gg = new Double(3.14);
double hh = gg.doubleValue(); // 将Double对象转换为double值并返回

  • compareTo()：将Number对象与参数比较，返回一个int值，表示大小关系。如果Number对象大于参数，返回正数；如果Number对象小于参数，返回负数；如果Number对象等于参数，返回0。例如：
Integer ii = new Integer(100);
Integer jj = new Integer(50);
int kk = ii.compareTo(jj); // 将ii与jj比较，返回正数

Double ll = new Double(3.14);
Double mm = new Double(2.71);
int nn = ll.compareTo(mm); // 将ll与mm比较，返回正数
  • equals()：判断Number对象是否与参数相等，返回一个boolean值。如果参数是一个Number对象，并且数值相等，返回true；否则返回false。例如：
Integer oo = new Integer(100);
Integer pp = new Integer(100);
boolean qq = oo.equals(pp); // 判断oo是否与pp相等，返回true

Double rr = new Double(3.14);
Double ss = new Double(2.71);
boolean tt = rr.equals(ss); // 判断rr是否与ss相等，返回false
  • valueOf()：返回一个Number对象指定的内置数据类型。可以接受一个基本数据类型或者一个字符串作为参数。例如：
Integer uu = Integer.valueOf(100); // 返回一个Integer对象，表示int值100
Integer vv = Integer.valueOf("100"); // 返回一个Integer对象，表示字符串"100"

Double ww = Double.valueOf(3.14); // 返回一个Double对象，表示double值3.14
Double xx = Double.valueOf("3.14"); // 返回一个Double对象，表示字符串"3.14"
  • toString()：以字符串形式返回值。可以接受一个基本数据类型或者一个Number对象作为参数。例如：
String yy = Integer.toString(100); // 返回一个字符串，表示int值100
String zz = Integer.toString(new Integer(100)); // 返回一个字符串，表示Integer对象的值

String aaa = Double.toString(3.14); // 返回一个字符串，表示double值3.14
String bbb = Double.toString(new Double(3.14)); // 返回一个字符串，表示Double对象的值
  • parseInt()：将字符串解析为int类型。可以接受一个字符串或者一个带有基数的字符串作为参数。例如：
int ccc = Integer.parseInt("100"); // 将字符串"100"解析为int类型
int ddd = Integer.parseInt("100", 10); // 将字符串"100"按照十进制解析为int类型
  • abs()：返回参数的绝对值。可以接受任何数值类型作为参数。例如：
int eee = Math.abs(-10); // 返回10
double fff = Math.abs(-3.14); // 返回3.14
  • ceil()：返回大于等于 ( >= )给定参数的的最小整数，类型为双精度浮点型。可以接受任何数值类型作为参数。例如：
double ggg = Math.ceil(1.4); // 返回2.0
double hhh = Math.ceil(-1.4); // 返回-1.0
  • floor()：返回小于等于（<=）给定参数的最大整数 。可以接受任何数值类型作为参数。例如：
double iii = Math.floor(1.6); // 返回1.0
double jjj = Math.floor(-1.6); // 返回-2.0
  • rint()：返回与参数最接近的整数。返回类型为double。可以接受任何数值类型作为参数。例如：
double kkk = Math.rint(1.4); // 返回1.0
double lll = Math.rint(-1.4); // 返回-1.0
  • round()：它表示 四舍五入 ，算法为 Math.floor(x+0.5) ，即将原来的数字加上 0.5 后再向下取整，所以，Math.round (11.5) 的结果为12，Math.round (-11.5) 的结果为-11。可以接受任何数值类型作为参数。例如：
int mmm = Math.round(1.4f); // 返回1
int nnn = Math.round(-1.4f); // 返回-1
long ooo = Math.round(1.6); // 返回2
long ppp = Math.round(-1.6); // 返回-2
  • min()：返回两个参数中的最小值。可以接受任何数值类型作为参数。例如：
int qqq = Math.min(10, 5); // 返回5
double rrr = Math.min(3.14, 2.71); // 返回2.71
  • max()：返回两个参数中的最大值。可以接受任何数值类型作为参数。例如：
int sss = Math.max(10, 5); // 返回10
double ttt = Math.max(3.14, 2.71); // 返回3.14
  • exp()：返回自然数底数e的参数次方。可以接受任何数值类型作为参数。例如：
double uuu = Math.exp(1); // 返回e的1次方，即e
double vvv = Math.exp(2); // 返回e的2次方，即e^2
  • log()：返回参数的自然数底数的对数值。可以接受任何数值类型作为参数。例如：
double www = Math.log(Math.E); // 返回1，因为ln(e) = 1
double xxx = Math.log(Math.E * Math.E); // 返回2，因为ln(e^2) = 2
  • pow()：返回第一个参数的第二个参数次方。可以接受任何数值类型作为参数。例如：
double yyy = Math.pow(2, 3); // 返回8，因为2^3 = 8
double zzz = Math.pow(3, 2); // 返回9，因为3^2 = 9
  • sqrt()：求参数的算术平方根。可以接受任何数值类型作为参数。例如：
double aaaa = Math.sqrt(4); // 返回2，因为sqrt(4) = 2
double bbbb = Math.sqrt(9); // 返回3，因为sqrt(9) = 3
  • sin()：求指定double类型参数的正弦值。可以接受任何数值类型作为参数。例如：
double cccc = Math.sin(Math.PI / 6); // 返回0.5，因为sin(pi/6) = 0.5
double dddd = Math.sin(Math.PI / 4); // 返回0.707，因为sin(pi/4) = sqrt(2)/2 ≈ 0.707
  • cos()：求指定double类型参数的余弦值。可以接受任何数值类型作为参数。例如：
double eeee = Math.cos(Math.PI / 3); // 返回0.5，因为cos(pi/3) = 0.5
double ffff = Math.cos(Math.PI / 6); // 返回0.866，因为cos(pi/6) = sqrt(3)/2 ≈ 0.866
  • tan()：求指定double类型参数的正切值。可以接受任何数值类型作为参数。例如：
double gggg = Math.tan(Math.PI / 4); // 返回1，因为tan(pi/4) = 1
double hhhh = Math.tan(Math.PI / 6); // 返回0.577，因为tan(pi/6) = sqrt(3)/3 ≈ 0.577
  • asin()：求指定double类型参数的反正弦值。可以接受任何数值类型作为参数。例如：
double iiii = Math.asin(0.5); // 返回pi/6，因为asin(0.5) = pi/6
double jjjj = Math.asin(0.707); // 返回pi/4，因为asin(sqrt(2)/2) ≈ pi/4
  • acos()：求指定double类型参数的反余弦值。可以接受任何数值类型作为参数。例如：
double kkk

k = Math.acos(0.5); // 返回pi/3，因为acos(0.5) = pi/3 double llll = Math.acos(0.866); // 返回pi/6，因为acos(sqrt(3)/2) ≈ pi/6


- **atan()**：求指定double类型参数的反正切值。可以接受任何数值类型作为参数。例如：

```java
double mmmm = Math.atan(1); // 返回pi/4，因为atan(1) = pi/4
double nnnn = Math.atan(0.577); // 返回pi/6，因为atan(sqrt(3)/3) ≈ pi/6
  • atan2()：将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。可以接受任何数值类型作为参数。例如：
double oooo = Math.atan2(1, 1); // 返回pi/4，因为(1, 1)对应的极坐标角度为pi/4
double pppp = Math.atan2(-1, -1); // 返回-3pi/4，因为(-1, -1)对应的极坐标角度为-3pi/4
  • toDegrees()：将参数转化为角度。可以接受任何数值类型作为参数。例如：
double qqqq = Math.toDegrees(Math.PI / 2); // 返回90，因为pi/2弧度对应90度
double rrrr = Math.toDegrees(Math.PI / 4); // 返回45，因为pi/4弧度对应45度
  • toRadians()：将角度转换为弧度。可以接受任何数值类型作为参数。例如：
double ssss = Math.toRadians(90); // 返回pi/2，因为90度对应pi/2弧度
double tttt = Math.toRadians(45); // 返回pi/4，因为45度对应pi/4弧度
  • random()：返回一个随机数。返回类型为double。无需参数。例如：
double uuuu = Math.random(); // 返回一个[0, 1)之间的随机数
double vvvv = Math.random() * 10; // 返回一个[0, 10)之间的随机数