该项目源码地址：https://github.com/ggb2312/JavaNotes/tree/master/java-basic

1. 基本数据类型

Java中定义了四类八种基本数据类型：

布尔型: boolean
字符型: char
整数型: byte, short, int, long
浮点数型: float, double

八种基本数据类型占用内存的字节数、取值范围：

八种基本数据类型常识

其中float的取值范围1.4E-45=1.4*10^-45，即1.4乘以10的负45次方。
此处的E并非自然对数，E是exponent的缩写，意为指数。这里特指E右边的数是以10为底的指数。这是科学计数法的写法。

自动类型转换：

Java会自动完成低级类型向高级类型的转换。低级类型指取值范围较小的数据类型，高级类型指取值范围较大的数据类型。如long相对于float是低级类型，但相对于float是高级类型。

数据类型从高到低

ps：注意4字节的float类型比8字节的long类型表示的数要大！

强制类型转换：
将数据类型相对较高的数据或变量赋值给数据类型相对较低的变量，需要强制类型转换。

2. 包装数据类型

包装数据类型：
八种基本数据类型对应了八种包装数据类型

基本数据类型	boolean	char	byte	short	int	long	float	double
包装数据类型	Boolean	Character	Byte	Short	Integer	Long	Float	Double

使用包装数据类型有什么好处？
因为包装数据类型作为对象的存在都会有一个默认值null，可以比基本数据类型多表示一种情况。

实例

打一个简单比方：给学生期末考试成绩填分数。
我们封装一个学生类Student，使用基本数据类型int代表学生成绩

public class Student {
    private String name;//学生姓名
    private int score; //学生成绩

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
}

现在我们来给学生们填成绩表，小明考试很认真考了95分

Student xiaoming = new Student("小明", 95);

小红考试睡着了考了0分

Student xiaohong = new Student("小红", 0);

小刚考试没来...？缺考怎么表示呢，还是说算0分？

Student xiaogang = new Student("小刚", 0);//考试缺考

通常情况下，考试0分和缺考是两个完全不同概念。拿四级考试来说，考试0分的话，明年再考没什么大不了的，但是缺考的话，就要禁考一年了。

所以如果我们还是将小刚的成绩算为0分的话，就会产生二义性！但是如果我们使用包装数据类型Integer来表示学生成绩的话就可以解决这个二义性的问题。

重新封装学生类Student，使用基本数据类型Integer代表学生成绩

public class Student {
    private String name;
    private Integer score;

    public Student(String name, Integer score) {
        this.name = name;
        this.score = score;
    }
}

小刚考试没来，我们就可以使用null来表示缺考。

Student xiaogang = new Student("小刚", null);//考试缺考

其次，包装数据类型内部提供了缓存、数据类型转换、数据类型的各种操作。
所以通常不会使用基本数据类型，而使用包装数据类型。当然，这个也是要视情况而定，如果纯粹的基本数据类型就可与满足业务需求，也可以不使用包装数据类型！

3. 深入理解包装数据类型

3.1 自动装箱和拆箱原理

简介
自动装箱是Java编译器在基本数据类和对应的包装数据类型之间做的一个转化。比如：把int转为Integer，double转为Double，等等。反之就是自动拆箱，比如，把Integer转为int等。

实例

// jdk5之前非自动装箱
Integer inter = new Integer(555);  
// jdk5之后自动装箱
Integer it = 555;
//自动拆箱
int i = it;

编译器是如何实现自动装箱和拆箱的呢？
自动装箱和拆箱只是一个语法糖而已。
将java代码编译成class文件，即编译成字节码文件，再反编译class文件，语法糖就会露出本质。

下面是使用javap -c AutoBox.class文件的结果

javap -c AutoBox.class

使用jad反编译工具可以直接看到去掉语法糖后java文件的本质。

jad反编译

从反编得到的内容来看，自动装箱时调用的是Integer.valueOf()，自动拆箱时调用的是Integer的intValue()。同理其他包装类也类似。

一句话：即装箱的过程是调用包装数据类型的valueOf()实现的，拆箱的过程是调用包装数据类型的xxxValue()实现的（xxx代表基本数据类型）。

关于valueOf()的缓存请继续往下看

3.2 整数缓存原理

简介
在Java 5中，引入了一个新功能来保存内存并提高Integer类型对象处理的性能。整数对象在内部缓存，并通过相同的引用对象重用。

这适用于介于-127到+127（最大整数值）范围内的整数值。
此整数缓存仅适用于自动装箱。使用构造函数构建整数对象时，它们不会被缓存。

实例
以一道面试题为切入，下面三个输出会打印什么呢？

/**
 * 修改IntegerCache
 * -Djava.lang.Integer.IntegerCache.high=129
 * -XX:AutoBoxCacheMax=129
 * @author lastwhisper
 */
public class IntegerDemo {

    public static void main(String[] args) {
        Integer a1 = 127;//Integer.valueOf(127);
        Integer a2 = 127;
        System.out.println(a1 == a2);

        Integer a3 = 129;//Integer.valueOf(129);
        Integer a4 = 129;
        System.out.println(a3 == a4);

        Integer a5 = new Integer(127);
        Integer a6 = new Integer(127);
        System.out.println(a5 == a6);
    }
}

输出

true
false
false

在3.1中解释了Integer a1 =xxx是自动装箱，自动装箱的本质是调用valueOf()，在valueOf()中使用了缓存，而new Integer(xxx)是新创建对象。

让我们看一下JDK中的valueOf()方法源码。在构造新的Integer实例之前，会判断是否满足条件，如果满足则根据i计算偏移量查找IntegerCache.cache，反之则构造Integer实例。这种思想或者模式也叫享元设计模式。

public static Integer valueOf(int i) {
       // -128<i<127返回cache中的值
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache类

IntegerCache是类的私有静态内部Integer类。

private static class IntegerCache {
        // 缓存的最小值边界
        static final int low = -128;
        // 缓存的最大值边界，在static代码块中初始值
        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");
            // 配置的最大值不为null，将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];
            // 循环数组的长度，从-128开始赋值
            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() {}
    }

Javadoc注释明确指出此类用于缓存并支持-128到127之间的值的自动装箱。可以使用VM参数修改127的高值-XX:AutoBoxCacheMax=size。所以缓存发生在for循环中。它只是从低到高运行，并在名为cache的Integer数组中创建尽可能多的Integer实例和存储。就如此容易。这个缓存是在第一次使用Integer类时进行的。此后，使用这些缓存的实例而不是创建新实例（在自动装箱期间）。

实际上，当在Java 5中首次引入此功能时，范围固定为-127到+127。后来在Java 6中，范围的高端被映射到java.lang.Integer.IntegerCache.high，并且VM参数允许我们设置高数字。根据我们的应用用例，它可以灵活地调整性能。在程序中首次使用Integer必须花费额外的时间来缓存实例。

XXXCache

类	是否有Cache	最小值	最大值
Boolean	无	--	--
Byte	ByteCache	-128	127(固定)
Short	ShortCache	-128	127(固定)
Character	CharacterCache	0	127(固定)
Integer	IntegerCache	-128	java.lang.Integer.IntegerCache.high
Long	LongCache	-128	127(固定)
Float	无	--	--
Double	无	--	--

java.lang.Integer.IntegerCache.high可以通过设置-Djava.lang.Integer.IntegerCache.high=xxx和-XX:AutoBoxCacheMax=xxx来修改。

参考

https://javapapers.com/java/java-integer-cache/

https://www.jb51.net/article/129640.htm

Java基础之基本数据类型与包装数据类型