Java学习 - 基本数据类型

基本数据类型

Java中有8种数据类型

名称	包装类	位数	占用字节	默认值	是否有默认缓存？	取值范围
byte	Byte	8	1	0	是	[-2^7, 2^7 - 1]
short	Short	16	2	0	是	[-2^15, 2^15 - 1]
int	Integer	32	4	0	是	[-2^31, 2^31 - 1]
long	Long	64	8	0L	是	[-2^ 63, 2^63 - 1]
float	Float	32	4	0f	否	1.4E-45 ~ 3.4028235E38
double	Double	64	8	0d	否	4.9E-324 ~ 1.7976931348623157E308
char	Character	4	1	‘u0000’	是	0 ~ 65535（2^16 - 1）
boolean	Boolean	1	未明确定义	false	是	true、false

Java中，局部变量会被存入Java虚拟机栈中的局部变量表中，未被static修饰的基本数据则被存入Java虚拟机的堆中。而对于包装类，其本质是一个对象，而显而易见，基本上所有对象都被存在堆中。

为什么说是几乎所有对象实例都存在于堆中呢？ 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存 ^[1]

基础数据包装类的默认缓存

Java为大部分基础数据的包装类都添加了默认缓存，对于整型系列，都有[-128, 127]的缓存。对于Character则是[0,127]，而对于Boolean则是(True, False)。

默认缓存的意义在于将一些经常使用的对象优先进行缓存，以便在实际操作时减少由于频繁创建对象带来的性能损耗。

缓存的实现，从底层代码来看是一目了然的。这里给一个Integer的例子

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

 private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

可以看到，...Cache是一个静态类，内部信息在类加载的时候便会被加载到内存中去（放进常量池）。...Cache这个静态类中维护了一个类型为...的数组，并在类加载时便初始化。valueOf()方法通常在装箱的时候调用，因此可以知道，装箱时并不是直接创建一个存储了基本类型的对象，而是先对基本类型进行一个范围判断知乎决定是否创建一个新的对象还是从缓存中获取对象。其他的包装类缓存也是大同小异，不过可以从中看出来，缓存的上限是可以通过JVM参数自定义的：-XX:AutoBoxCacheMax。

对于浮点数系列则没有设置缓存，个人觉得有如下几个原因：

1. 浮点是连续的。相较于整型，浮点很难在实际操作中对某一些数进行预缓存，并且经常使用它们。既然无法确保这一点，便无法提升性能。
2. 浮点本身便有精度问题。

装箱与拆箱

Integer a = 10; // 装箱
int b = a; // 拆箱

装箱： 调用包装类的valueOf()方法 （Integer a = Integer.valueOf(10);），因此在装箱时会判断对应值是否在缓存范围内，来决定是否直接返回缓存内容。

拆箱： 调用xxxValue()方法 (int b = a.intValue();)。

浮点数精度问题

其实很好理解，计算机来理解一个数，总是会有一个用于存储数据的字节量，而这个字节量一定是有限的，所以只能够存储一定位数的数据。作为浮点数（小数），我们都知道，我们无法确保其一定会是有限位数的小数，比如说无限循环小数，无理数等等。这些书无法用限定的字节量来精确表达，只能够到让它们到了一定小数点后位数之后将其截断，这也就是造成了浮点数的精度问题的其中之一。

我个人认为这么回答也没有问题，但是浮点数精度问题也是由于用于表示浮点数的二进制标准带来的问题。对于float来说，字节位数为32，细节分下来：第一位为符号位，2-9是指数位，10-32是尾数位。(double则是1为符号位，2-12是指数位，13-64是尾数位)。理论上而言，足够长的位数能够将浮点数的精度误差近似为0，但是终究会有表示能力的问题，这会让一些十进制的小数在表示二进制时是无限循环小数。

如何解决精度问题

考虑浮点数本身： 可以使用BigDecimal类来解决精度问题

考虑浮点数之间的大小关系问题 ： 可以为浮点数之间设一个误差空间来消除精度带来的问题。

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a == b); // false
System.out.println(Math.abs(a  - b) < 0.00001f); // true

引用

1. 基础常用面试题总结(上) ↩