1. java数据类型

Java数据类型主要包括两种：基本类型 和 封装类型

1. 基本类型

1.1 分类
Java的基本数据类型总共有8种，包括三大类：数值型，字符型，布尔型，

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

1.2 大小和范围
计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从00000000 - 11111111，换算成十进制是0 - 255，换算成十六进制是00 - ff。

类型	占用存储空间	大小/范围	默认值
byte	1字节	-27 ~ 27-1 （-128 - 127）	（byte）0
short	2字节	-215 ~ 215-1 （-32768 - 32767）	（short）0
int	4字节	-231 ~ 231-1 （-2147483648 - 2147483647）	0
long	8字节	-263 ~ 263-1	0L
float	4字节	-2128 ~ +2128 （-3.40E+38 ~ +3.40E+38）	0.0f
double	8字节	-21024 ~ +21024（-1.79E+308 ~ +1.79E+308）	0.0d
char	2字节	0 ~ 65535	\u0000（空，''）
boolean	1字节	true, false	false

1.3 浮点型精度
float和double的浮点数在计算机上的存储都遵循IEEE规范，在内存中是按科学计数法来存储的。float是单精度浮点数，占4个字节(byte)，即32位(bit,比特)；double是双精度浮点数，占8个字节(byte)，即64位(bit,比特)。

1. 单精度数据存储格式，1位符号，8位指数位，23位小数位；

   
   
   单精度数据存储格式.png

2. 双精度数据存储格式，1位符号，11位指数位，52位小数位；

   
   
   双精度数据存储格式.png
3. float和double的范围是由指数的位数来决定的，精度是由小数的位数来决定的。

• float：指数位为2^8=128，所以取值范围为 -2¹²⁸ ~ +2¹²⁸；小数位为2^23 = 8388608，共7位，意味着最多能有7位有效数字，但绝对能保证的为6位，也即float的精度为6~7位有效数字；
• double：指数位为2^11=1024，所以取值范围为 -2¹⁰²⁴ ~ +2¹⁰²⁴；小数位为2^52 = 4503599627370496，一共16位，同理，double的精度为15~16位。

1.4 java基本类型转换
Java是强类型的编程语言，其数据类型在定义时就已经确定了，因此不能随意转换成其他的数据类型，但是Java允许将一种类型赋值给另一种类型。

1. 在Java中，boolean类型与其他7种类型的数据都不能进行转换，但对于其他7种数据类型，它们之间都可以进行转换，只是可能会存在精度损失或其他一些变化。转换分为自动转换和强制转换：

• 自动类型转换（隐式）：无需任何操作
• 强制类型转换（显式）：需使用转换操作符

2. 自动类型转换需要满足如下两个条件：

• 转换前的数据类型与转换后的数据类型兼容；
• 转换后的数据类型的表示范围比转换前的类型大。

3. 6种数值类型作如下排序：

double > float > long > int > short > byte

那么从小转换到大，那么可以直接转换，而从大到小，或char或其他6种数据类型转换，则必须使用强制转换，且可能会发生精度损失。

2. 封装类型

2.1 8种基本类型和封装类型的对应

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

封装类型与基本类型相比，有如下区别：

• 1.从参数传递上来说，基本类型只能按值传递，而每个封装类都是按引用传递的；
• 2.从存储的位置上来说，基本类型是存储在栈中的，而所有的对象都是在堆上创建和存储的，所以基本类型的存取速度要快于在堆中的封装类型的实例对象；JDK5.0开始可以自动封包了 ，也就是基本数据可以自动封装成封装类,基本数据类型的好处就是速度快（不涉及到对象的构造和回收），封装类的目的主要是更好的处理数据之间的转换，方法很多，用起来也方便。
• 3.基本类型的优势是：数据存储相对简单，运算效率比较高；
• 4.封装类型的优势是：类型转换的api更好用了，比如Integer.parseInt(*)等的，每个封装类型都提供了parseXXX方法和toString方法。而且在集合当中，也只能使用封装类型。封装类型满足了Java中一切皆对象的原则。

2.2 封装类的自动装箱和拆箱

1. 自动装箱和拆箱测试
   写个简单测试类，包含以下main方法

   public static void main(String[] args) {
       Integer n = 50; // 自动装箱
       int n1 = n; // 自动拆箱
       System.out.println(n1);
   }
   

   在cmd中用命令编译和反编译
   编译：javac Test3.java
   反编译：javap -c Test3.class
   结果如下：
   
   反编译结果.png
   
   可以看出，自动装箱使用了Integer.valueOf()方法，而拆箱过程执行了n.intValue()

2.3 封装类的缓存机制

1. 缓存机制
   以Integer类为例，上面说道Integer自动装箱使用了Integer.valueOf()方法，我们查看一下此方法的源码：
   
   valueOf方法源码.png
   
   方法中IntegerCache设计到封装类的缓存，默认情况下，IntegerCache.low=-128，IntegerCache.high=127。即在执行Integer.valueOf(num)方法时，会先判断num的大小，如果小于-128或者大于127，就创建一个Integer对象，否则就从IntegerCache中来获取。
   查看IntegerCache源码，可以看到取值范围的大小，IntegerCache源码如下：
   
   IntegerCache源码.png
   
   可以看出IntegerCache是一个静态内部类，它包含low、high和数组cache。第一次使用Integer的时候创建值在-128到java.lang.Integer.IntegerCache.high范围内的所有的Integer对象将其放入到cache数组中。其中java.lang.Integer.IntegerCache.high默认是127，可以在jvm启动时配置：
   • 若配置的值小于127，则取127，配置的值不管用
   • 若配置的值在127 ~ 2³¹-1(int型最大值)之间，java.lang.Integer.IntegerCache.high取配置的值
   • 若配置大于2³¹-1，则取2³¹-1，配置的值也不管用

这是Integer缓存数据的机制。这也是为了减轻封装类型相比于基本类型的性能消耗。

• 类似Integer有缓存机制的类：Integer、Short、Byte、Character、Long
• 浮点类型无缓存机制，因浮点类型如Float和Double却在任意区间都有无数个值
• Boolean内部已经提前创建好两个对象，因为它只有两种情况

Boolean类内部.png

类型	默认缓存范围
Integer	[-128,127]
Short	[-128,127]
Long	[-128,127)
Character	[0,127]

---

2. 缓存机制相关小例子

public class Main {
  public static void main(String[] args) {

      Integer i1 = 100;
      Integer i2 = 100;
      Integer i3 = 200;
      Integer i4 = 200;

      System.out.println(i1 == i2);  //true
      System.out.println(i3 == i4);  //false
  }
}

执行结果大家可能出乎意料，原因是什么呢，结合Integer缓存机制的说明，可以明白这个过程如下：

• i1和i2会进行自动装箱，执行了valueOf方法，它们的值落在[-128,128)，所以它们取到的IntegerCache.cache中的是同一个对象，所以它们是相等的；
• i3和i4也会进行自动装箱，执行valueOf方法时，它们的值都大于128，所以会执行new Integer(200)，也即它们分别创建了两个不同的对象，所以它们肯定不相等

需要注意的几点：

• 当一个基本数据类型与封装类型进行==、+、-、*、/运算时，会将封装类进行拆箱，对基本数据类型进行运算；
• 拆箱完成运算之后，如果返回的结果需要是封装类型，则需要进行自动装箱，返回封装对象；
• equals(Object o)方法每个封装类中都略有不同，但它必须满足两个条件才为true： 类型相同和内容相同

Integer num1 = 100;  
int num2 = 100;  
Long num3 = 200l;  
System.out.println(num1 + num2);  // 200
System.out.println(num3 == (num1 + num2));  // true
System.out.println(num3.equals(num1 + num2));  // false，因类型不同