数字的处理

╰半夏微凉° 2022-12-26 11:09 33阅读 0赞

### 一、分类 ###

<table> 
 <tbody> 
 <tr> 
 <td> 简单类型 </td> 
 <td> boolean </td> 
 <td> byte </td> 
 <td> char </td> 
 <td> short </td> 
 <td> Int </td> 
 <td> long </td> 
 <td> float </td> 
 <td> double </td> 
 </tr> 
 <tr> 
 <td> 封装器类 </td> 
 <td> Boolean </td> 
 <td> Byte </td> 
 <td> Character </td> 
 <td> Short </td> 
 <td> Integer </td> 
 <td> Long </td> 
 <td> Float </td> 
 <td> Double </td> 
 </tr> 
 <tr> 
 <td> 二进制位数 </td> 
 <td> 1 </td> 
 <td> 8 </td> 
 <td> 16 </td> 
 <td> 16 </td> 
 <td> 32 </td> 
 <td> 64 </td> 
 <td> 32 </td> 
 <td> 64 </td> 
 </tr> 
 </tbody> 
</table>

Java基本类型共有八种，基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不随着机器硬件环境或者操作系统的改变而改变。

*  byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。
 *  short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。
 *  int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
 *  long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
 *  float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
 *  double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。
 *  boolean：只有true和false两个取值。
 *  char：16位，存储Unicode码，用单引号赋值。

### 二、数据类型间的转换 ###

2.1 **自动类型转换**

低级变量可以直接转换为高级变量，例如:

byte b;
    int i=b;
    long l=b;
    float f=b;
    double d=b;

2.2 **强制类型转换**

将高级变量转换为低级变量时，你可以使用强制类型转换。即你必须采用下面这种语句格式：

int i=99;
    byte b=(byte)i;
    char c=(char)i;
    float f=(float)i;double d = (double)f;

2.3 包装类型转换

在我们讨论其它变量类型之间的相互转换时，可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double。从字面上我们就可以看出它们分别对应于 boolean、char、int、long、float和double。  在进行简单数据类型之间的转换（自动转换或强制转换）时，我们总是可以利用包装类进行中间过渡。例如：  
当希望把float型转换为double型时：

float f1=100.00f;  
      Float F1=new float(f1);  
      Double d1=F1.doubleValue();
      //F1.doubleValue()为Float类的返回double值型的方法

### 三、部分原理和坑点 ###

3.1 拆箱和装箱

3.1.1 原理

在Java 5之前，两种方式赋值

*  Integer value = new Integer(10);
 *  Integer value = Integer.valueOf(10);

在Java 5之后，可以直接将整型赋给Integer对象，由编译器来完成从int型到Integer类型的转换，这就叫自动装箱。类似于这种：

Integer value = 10;

静态方法valueOf(基本类型)：将给定的基本类型转换成对应的包装类型；实例方法xxxValue()：将具体的包装类型对象转换成基本类型；下面我们以int和Integer为例，说明Java中自动装箱与自动拆箱的实现机制。代码：

public class TestNumber {
        public static void main(String[] args) {
            Integer inte = 10;
            int i = inte;
        }
    }

反编译后类似于：

public class TestNumber {
        public static void main(String[] paramArrayOfString) {
            Integer localInteger = Integer.valueOf(10);
            int i = localInteger.intValue();
        }
    }

也就是说在将Java源文件编译为class文件的过程中，javac编译器在自动装箱的时候，调用了Integer.valueOf()方法，在自动拆箱时，又调用了intValue()方法。

3.1.2 坑点

public class TestNumber {
 public static void main(String[] paramArrayOfString) {
 ArrayList<Integer> a;//a中装有要操作的数据，都是数字
 for(int i = 0; i<a.size(); i++){
 //....遍历
 for(int j=i;j<a.size();j++){
 if(a.get(i)==a.get(j)){
 a.remove(j);
 }
 }
 }
 }
 }

int为基本类型，Integer类型为基本包装类型。因而可以将Integer当做一个对象来理解，所以在上面的代码示例中，用==来比较2个对象的引用无疑就是在搞笑了，地址都不一样，怎么可能返回true。但是这里存在着一些坑，就是Integer有时候用==比较是可以得到true的（值相同），原因如下：在-128至127之间的赋值，Integer对象是在IntegerCache.cache产生，会复用已有对象，这个区间内的Integer值可以直接使用==进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象。所以推荐都使用equals比较。其他包装类型：

（1）Integer默认复用了\[-128,127\]这些对象；

（2）Byte复用了全部256个对象\[-128,127\]；

（3）Short服用了\[-128,127\]这些对象；

（4）Long服用了\[-128,127\];

（5）Character复用了\[0,127\];

（6）Double和Float是连续不可数的，所以没法复用对象，也就不存在自动装箱复用陷阱。

3.2 浮点数精度

浮点数分为单精度浮点数和双精度浮点数，float是单精度浮点数。double是双精度浮点数。两者主要区别如下：

*  在内存中占用的字节数不同：单精度浮点数在内存中占4个字节。双精度浮点数在内存中占8个字节。
 *  有效数字的位数不同：

**单精度浮点数有效数字是8位（整数部分+小数部分），**第9位数字将会四舍五入**。**

**双精度浮点数有效数字是16位（正数部分+小数部分），**第17位数字将会四舍五入。

* 数值取值范围：
 
 <table> 
 <tbody> 
 <tr> 
 <th> 格式 </th> 
 <th> 最小负数 ~ 最大正数（二进制） </th> 
 <th> 最小负数 ~ 最大正数（十进制） </th> 
 </tr> 
 <tr> 
 <td> 单精度浮点数 </td> 
 <td> -2+128 ~ 2+128 </td> 
 <td> -3.402...10+38 ~ 3.402...10+38 </td> 
 </tr> 
 <tr> 
 <td> 双精度浮点数 </td> 
 <td> -2+1024 ~ 2+1024 </td> 
 <td> -1.797...10+308 ~ 1.797...10+308 </td> 
 </tr> 
 </tbody> 
 </table>

4）在程序中处理速度不同：一般来说，CPU处理单精度浮点数的速度比处理双精度浮点数要快很多。

3\*0.1==0.3将会返回什么fasle，为什么？

12.0f-11.9f=0.10000038，"减不尽"为什么？

3.2.1 原理

现在我们就详细剖析一下浮点型运算为什么会造成精度丢失？

首先我们要搞清楚下面两个问题：

(1) 十进制整数如何转化为二进制数

算法很简单。举个例子，11表示成二进制数：

11/2=5 余   1

5/2=2   余   1

2/2=1   余   0

1/2=0   余   1

0结束         11二进制表示为(从下往上):1011

这里提一点：只要遇到除以后的结果为0了就结束了，大家想一想，所有的整数除以2是不是一定能够最终得到0。换句话说，所有的整数转变为二进制数的算法会不会无限循环下去呢？绝对不会，整数永远可以用二进制精确表示 ，但小数就不一定了。

(2) 十进制小数如何转化为二进制数

算法是乘以2直到没有了小数为止。举个例子，0.9表示成二进制数

0.9\*2=1.8   取整数部分 1

0.8(1.8的小数部分)\*2=1.6    取整数部分 1

0.6\*2=1.2   取整数部分 1

0.2\*2=0.4   取整数部分 0

0.4\*2=0.8   取整数部分 0

0.8\*2=1.6 取整数部分 1

0.6\*2=1.2   取整数部分 0

.........      0.9二进制表示为(从上往下): 1100100100100......

注意：上面的计算过程循环了，也就是说\*2永远不可能消灭小数部分，这样算法将无限下去。很显然，小数的二进制表示有时是不可能精确的 。其实道理很简单，十进制系统中能不能准确表示出1/3呢？同样二进制系统也无法准确表示1/10。这也就解释了为什么浮点型减法出现了"减不尽"的精度丢失问题。0.1的二进制表示为0.0 0011 0011 0011… （0011 无限循环)，再转换为十进制就是0.1000000000000000055511151231257827021181583404541015625。**对于计算机而言，0.1无法精确表达，这是浮点数计算造成精度损失的根源。**

3.2.2 坑点

3.2.2.1 加法坑

double d1 = 0.1;
    d1 += 0.1;
    d1 += 0.1;
    d1 += 0.1;
    d1 += 0.1;
    d1 += 0.1;
    d1 += 0.1;
    d1 += 0.1;
    d1 += 0.1; // 连着加了8次
    System.out.println(d1);  
    0.8999999999999999

3.2.2.2 减法坑

double d1 = 1.0;
    double d2 = 0.1;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2;
    d1 -= d2; // 连着减了9次0.1
    System.out.println(d1);  
    0.10000000000000014

3.2.2.3 乘法坑

double d1 = 123213.0;
    d1 *= 0.35;
    System.out.println(d1);
    43124.549999999996

3.2.2.4 除法坑

double result = 11.4/12;
    System.out.println(result);  
    0.9500000000000001

**如果需要对资金进行加减乘除四则运算，千万不能使用double类型的**

3.2.2.5 大数转为字符串坑

double bigValue = 12345678.9;
    System.out.println(bigValue);  
    1.23456789E7
    如果你想要显示大的浮点数，请使用DecimalFormat自己来格式化。

3.2.2.6 除0坑

result = 1.0/0.0;
    System.out.println(result);
    result = 0.0/0.0;
    System.out.println(result);  
    Infinity NaN
    注意并不会抛出异常

3.2.2.7 浮点数舍入的坑

double num1 = 3.35;
    float num2 = 3.35f;
    System.out.println(String.format("%.1f", num1));//四舍五入
    System.out.println(String.format("%.1f", num2));
    3.350000000000000088817841970012523233890533447265625
    3.349999904632568359375
    String.format采用四舍五入的方式进行舍入，取1位小数，double的3.350四舍五入为3.4，而float的3.349四舍五入为3.3。

3.2.2.8 比较是否相等的坑

System.out.println(1.1 == 1.1? "true": "false");
    System.out.println(1.1 == 1.100000000000001? "true": "false");
    System.out.println(1.1 == 1.10000000000000009? "true": "false");  
    true false true

在进行资金相关的运算时，千万不能使用Double类型，否则一个不小心就让你好看。 那么不使用double，使用哪个类型合适呢？Java提供了一个叫BigDecimal的对象，专门用来做计算使用，但是BigDecimal也不是那么容易驾驭的，使用不当，还是会被爆出翔。

3.3 Bigdecimal

3.3.1 原理

BigDecimal的原理很简单，就是将小数扩大N倍，转成整数后再进行计算，同时结合指数，得出没有精度损失的结果。

package java.math;
    
    public class BigDecimal {
        //值的绝对long型表示
        private final transient long intCompact;
        //值的小数点后的位数
        private final int scale;
    
        private final BigInteger intVal;
        //值的有效位数，不包含正负符号
        private transient int precision;
        private transient String stringCache;
    
        //加、减、乘、除、绝对值
        public BigDecimal add(BigDecimal augend) {}
        public BigDecimal subtract(BigDecimal subtrahend) {}
        public BigDecimal multiply(BigDecimal multiplicand) {}
        public BigDecimal divide(BigDecimal divisor) {}
        public BigDecimal abs() {}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb3llcWl1_size_16_color_FFFFFF_t_70][]

BigDecimal能更精确表示带小数点的数值，因为采用了long intCompact和int scale来表示数值，而不是浮点型的科学计数法。

3.3.2 坑点

3.3.2.1 实例化对象

BigDecimal num = new BigDecimal(0.3);
    System.out.println(num);
    0.299999999999999988897769753748434595763683319091796875
    
    //正确方式
    BigDecimal num = new BigDecimal("0.3");
    System.out.println(num);
    0.3

3.3.2.2 除法

BigDecimal d = BigDecimal.ONE;  
    d.divide(new BigDecimal("3"));
    Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
    
    //换种方式
    BigDecimal d = BigDecimal.ONE;  
    d.divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
    System.out.println(d);
    1
    //咦，为何不是0.33，数没变呢？ 原因是：BigDecimal是不可变的，每次运算后返回新的对象，再改：
    BigDecimal d = BigDecimal.ONE;  
    d = d.divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
    System.out.println(d);

3.3.2.3 比较相等的坑

num = new BigDecimal("1");
    num1 = new BigDecimal("1.0");
    System.out.println(num.equals(num1)); // 竟然不相等呀
    System.out.println(num.compareTo(num1)); // 0   
    false 0

BigDecimal的equals方法的注释中说明了原因，equals比较的是BigDecimal的value和scale，1.0的scale是1，1的scale是0，所以结果一定是false：

/**
     * Compares this {@code BigDecimal} with the specified
     * {@code Object} for equality.  Unlike {@link
     * #compareTo(BigDecimal) compareTo}, this method considers two
     * {@code BigDecimal} objects equal only if they are equal in
     * value and scale (thus 2.0 is not equal to 2.00 when compared by
     * this method).
     *
     * @param  x {@code Object} to which this {@code BigDecimal} is
     *         to be compared.
     * @return {@code true} if and only if the specified {@code Object} is a
     *         {@code BigDecimal} whose value and scale are equal to this
     *         {@code BigDecimal}'s.
     * @see    #compareTo(java.math.BigDecimal)
     * @see    #hashCode
     */
    @Override
    public boolean equals(Object x)

BigDecimal的equals和hashCode方法会同时考虑value和scale，如果结合HashSet或HashMap使用的话就可能会出现麻烦。比如，我们把值为1.0的BigDecimal加入HashSet，然后判断其是否存在值为1的BigDecimal，得到的结果是false：

Set hashSet1 = new HashSet<>();
 hashSet1.add(new BigDecimal("1.0"));
 System.out.println(hashSet1.contains(new BigDecimal("1")));//返回false

解决这个问题的办法有两个：

* 第一个方法是，使用TreeSet替换HashSet。TreeSet不使用hashCode方法，也不使用equals比较元素，而是使用compareTo方法，所以不会有问题。
 * Set treeSet = new TreeSet<>();
 treeSet.add(new BigDecimal("1.0"));
 System.out.println(treeSet.contains(new BigDecimal("1")));//返回true
 
  
 * 第二个方法是，把BigDecimal存入HashSet或HashMap前，先使用stripTrailingZeros方法去掉尾部的零，比较的时候也去掉尾部的0，确保value相同的BigDecimal，scale也是一致的：
 
 Set hashSet2 = new HashSet<>();
 hashSet2.add(new BigDecimal("1.0").stripTrailingZeros());
 System.out.println(hashSet2.contains(new BigDecimal("1.000").stripTrailingZeros()));//返回true

1.  实例化时使用字符串
2.  一定要使用操作后返回值（BigDecimal是不可变的）
3.  进行运算前先设置保留几位小数
4.  除法运算要在计算时设置保留位数
5.  确定要使用哪种进位（四舍五入，还是银行家舍入法）
6.  比较两个Decimal是否相等，使用compareTo，不要使用equals

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb3llcWl1_size_16_color_FFFFFF_t_70]: /images/20221120/7db10ab1d9de4544aa529532302608aa.png