Java知识体系之基本类型

Java知识体系

基本数据类型

boolean的占用大小？

boolean的占用大小是多少，有如下说法

• 1bit: boolean编译后的是使用1和0储存，理论上只需1bit即可储存
• 1byte: 计算机处理数据的最小单位是1byte,用一字节的最低位存储，其他的用0填补。如果值是true则储存二进制为0000 0001，false则是0000 0000
• 4byte or 1btye: java虚拟机没有对boolean类型的专用字节码指令，表达式所操作的boolean在编译之后是使用int数据类型来代替的，而boolean数组则会被编译成byte数组

正确答案：

• 单个boolean 类型变量在编译的时候是使用的int 类型，所以是4个byte
• boolean 类型的数组时，在编译的时候是作为byte数组来编译的，所以boolean 数组里面的每一个元素占1个byte

char类型变量能不能储存一个中文的汉字?

中文unicode编码方式每个字符占用两个字节，char是16位类型，中文储存需要两个字节，因此可以储存中文字符。

浮点数float和双精度浮点数double表示法

浮点数的二进制表示法由三部分组成

• 符号位
• 指数位
• 尾数位

float、double二进制结构：

• 符号位部分用来储存数字符号，区分正负数，0 正 1 负
• 指数位储存指数，指数也有正负，指数确定大小范围
  指数是有符号的，但有符号整数比无符号整数计算麻烦，因此实际储存是将指数转为无符号整数，8bit的范围为0~255，真实的指数需要减去偏移量127。范围在（-126 ~ 128）
• 尾数位存储小数部分，确定浮点数精度，小数能表示的数越大，精度越大，数值越准确
  
  • float的尾数位是23，2^23=8388608 ，8388608是个7位数的十进制，如果加上忽略的整数位，最多可表示8位的十进制。但是绝对能保证有效是7位左右的十进制数；
  • double尾数位是52，2^52=4503599627370496，16位的数字，加上整数位2^53也是个16位数字，因此绝对能保证有效位精确是15位的十进制数

15.625的存储示例：

• 15.625 换成二进制 1111.101
• 将1111.101 右移三位，剩小数点前1位： 1.111101 * 2^3
• 底数位：因为小数点前必是1，因此只需记录小数点后的位数即可，此时底数是 1111 01 ,低位补零：111 1010 0000 0000 0000 0000
• 指数位：指数为3，加上127（反转时则减去127）得130，指数位二进制为1000 0010
• 符号位：正数 0

15.625 在内存的二进制形式表示为

基本类型的自动转换

• 整数类型的自动提升
  
  • byte -> (short/char) -> int -> long (自动提升链)
  • short 和 char 都是16位，但是不能隐式转换，因为取值范围不一样
• 字符型数据向整型数据的自动转换
  
  • char是无符号类型，表示范围在（0~2^16-1），可隐式转为int或long类型
• 整型、字符型数据都可向浮点型的自动转换
  
  • 因为浮点型能保存的有效数字是限制的，需要考虑转换后的有效位问题
• 布尔类型boolean不存在隐式转换为其他类型

short s1 = 1; s1 = s1 + 1;有错吗? short s1 = 1; s1 += 1;有错吗？

• s1 = s1+1 中的1默认类型是int，表达式中低范围类型s1会默认转为int来相加，得到int型的结果，最后int型的结果不能隐式转为short，编译报错
• s1 += 1; 存在隐含的强制转化 s1 += 1 -> s1 = (short) (s1+ 1); 编译不会报错

不同的基本类型强制转换，可能会产生什么问题

• 浮点型转整型，精度丢失、数据溢出
• 取值范围大的整型转取值范围小的整型，数据溢出，高位丢失

float f = 3.4; 是否正确？

在java里，不加后缀修饰的浮点数默认是double类型。double类型不能隐式类型转成float,编译会报错

表达式3*0.1 == 0.3 将会返回什么？true还是false？

浮点型存在精度问题，3*0.1得到的double数据尾数位 和 0.3 尾数位是不一样的 ，false

switch语句能否作用在 byte 类型变量上，能否作用在long类型变量上，能否作用在 String 类型变量上？

• switch(expr) expr 需要是int类型
  
  • byte,char,short 会自动提升为int，因此可以作用在switch关键字
  • long,float,double不能自动转为int，编译会报错
• String 也不能自动转为int，在1.7之前也是不能用在switch。但是1.7之后JDK支持String,通过String.hashCode返回一个int类型，并在case里再次使用String.equals比较

//语法糖反编译
switch(s.hashCode()){
    default;
        break;
    case 3556498:
        if(s.equals("test")){
            .....
        }
        break;
}

包装类

Java 是较为纯粹的面向对象设计语言，而其中存在八个原始类型，不归于类的范畴。为了践行 无物不可引用，万类皆是对象，Java 为原始类型提供了对应的引用类型（基本类型又可以称为原始类型），称其为原始类型的包装类。

需要注意：

• Byte、Short、Integer、Long、Float、Double 同属于 Number 数值类，Character、Boolean 不是
• 相较于基本类型，包装类作为引用类型，可以存在 NULL 值。
• 所有的包装类，都是 final 不可变类，这点与 String 是一致的，任何的修改都是新对象的创建

拆箱、装箱

拆、装箱，是原始类型与引用类型之间的相互转换

• 装箱：基本类型转为其包装类 valueOf()
• 拆箱：包装类转为其基本类型 intValue()

目前，Java 已经支持了自动装箱、自动拆箱，无须再调用特定的方法进行手动拆、装箱。

// 手动装箱
Integer integer1 = Integer.valueOf(12);
// 手动拆箱
int int1 = integer1.intValue();
// 自动装箱
Integer integer2 = 12;
// 自动拆箱
int int2 = integer2;

缓存池

上面说过，包装类都是不可变类，若需要修改其中的内容，必须开辟新的内存空间，这会造成不必要的浪费，也是各种缓存机制存在的必然。

包装类中，存在缓存池的设置，避免对象的重复创建，以 Integer 为例。

在 Integer 类中，存在一个私有静态内部类 private static class IntegerCache {}。
简单的理解，Integer 类的装箱操作，会调用 valueOf()，并开辟一块新的堆内存。
若装箱后的 Integer 对象存在于 Integer 的缓存池中，则不会创建新对象，而是直接引用自缓存池 IntegerCache

无论是手动装箱，还是自动装箱，都会调用valueOf()，只是隐藏了这部分。

Integer a1 = 120;
Integer a2 = 1200;
Integer b1 = 120;
Integer b2 = 1200;
// 对于引用类型 == 对比的是内存地址
System.out.println(a1 == b1);// true
System.out.println(a2 == b2);// false

当调用 valueOf() 时，会先判断当前创建的对象是否存在于缓存池中

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在 Integer 中，缓存池是 -128~127，一个 byte 的取值范围。也可以手动的扩充缓存池的大小，但并不推荐这样做

当然，若是直接使用 new Integer()，可以创建一个新的 Integer 对象。关键字 new，为强制创建，无视缓存池机制

Integer a1 = 120;
Integer b1 = 120;
Integer c1 = new Integer(120);
// 对于引用类型 == 对比的是内存地址
System.out.println(a1 == b1);// true
System.out.println(a1 == c1);// false
// equals()方法已经被重写，比较的是对象的值，所以返回true
System.out.println(a1.equals(c1));// true

值得注意的是，并非所有的包装类都存在缓存池，浮点型的 Float、Double 与 Boolean 不存在缓存池的概念。Byte、Short、Integer、Long、Character 存在缓存池，默认范围都是 -128~127

BigDecimal

BigDecimal 可以实现对浮点数的运算，不会造成精度丢失。
通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 BigDecimal 来做的。

为什么浮点数float或double运算的时候会有精度丢失的风险呢？

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。

BigDecimal 的用处

浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals 来判断。

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false

从输出结果就可以看出发生精度丢失的问题。想要解决这个问题也很简单，直接使用 BigDecimal 来定义浮点数的值，再进行浮点数的运算操作即可。

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);
System.out.println(x); /* 0.1 */
System.out.println(y); /* 0.1 */
System.out.println(Objects.equals(x, y)); /* true */

注意：我们在使用 BigDecimal 时，为了防止精度丢失，推荐使用它的BigDecimal(String val)构造方法或者 BigDecimal.valueOf(double val) 静态方法来创建对象。

BigDecimal 工具类

import java.math.BigDecimal;
import java.math.RoundingMode;
/**
 * 简化BigDecimal计算的小工具类
 */
public class BigDecimalUtil {
    /**
     * 默认除法运算精度
     */
    private static final int DEF_DIV_SCALE = 10;
    private BigDecimalUtil() {
    }
    /**
     * 提供精确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.add(b2).doubleValue();
    }
    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.subtract(b2).doubleValue();
    }
    /**
     * 提供精确的乘法运算。
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.multiply(b2).doubleValue();
    }
    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入。
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2) {
        return divide(v1, v2, DEF_DIV_SCALE);
    }
    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
    }
    /**
     * 提供精确的小数位四舍五入处理。
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = BigDecimal.valueOf(v);
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
    }
    /**
     * 提供精确的类型转换(Float)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static float convertToFloat(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.floatValue();
    }
    /**
     * 提供精确的类型转换(Int)不进行四舍五入
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static int convertsToInt(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.intValue();
    }
    /**
     * 提供精确的类型转换(Long)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static long convertsToLong(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.longValue();
    }
    /**
     * 返回两个数中大的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中大的一个值
     */
    public static double returnMax(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.max(b2).doubleValue();
    }
    /**
     * 返回两个数中小的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中小的一个值
     */
    public static double returnMin(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.min(b2).doubleValue();
    }
    /**
     * 精确对比两个数字
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1
     */
    public static int compareTo(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.compareTo(b2);
    }
}

参考

https://segmentfault.com/a/1190000023264152
https://blog.csdn.net/m0_57711043/article/details/117331007
https://javaguide.cn/java/basis/bigdecimal.html