基本数据类型和包装类

Java中的数据类型包括（基本数据类型和引用类型）

基本数据类型（原生类、内置类型）8种
基本数据类型都是有符号的，而且它们的取值范围都是已经固定的。

1. byte
2. short
3. int
4. long
5. float
6. double
7. char
8. boolean

---

分类：
整数类型：（byte，short，int，long）
浮点类型：（float、double）
逻辑类型：（boolean）
字符类型：（char）

各种基本类型的详细信息如下图：

---

为什么需要装箱和拆箱

Java支持的数据类型包括两种：一种是基本数据类型，包含byte，char,short, boolean ,int , long, float,double;另一种是引用类型：如String等，其实是对象的引用，JVM中虚拟栈中存的是对象的地址，创建的对象实质在堆中，通过地址来找到堆中的对象的过程，即为引用类型。自动装箱就是Java编译器在基本数据类型和对应的对象包装类型间的转化，即int转化为Integer,自动拆箱是Integer调用其方法将其转化为int的过程。基本数据类型，不具备面向对象的特性，而且不具有缓存的特性。

---

不同的数据的类型转换

• 隐式转换：从低精度向高精度进行转换。优先级：byte < short < char < int < long < float < double；
  
  1.char隐式转换时会转换为与其对应的ASCLL码；
  2.byte、char、short在参与运算的时候会自动转换为int型。但是使用“+=”不会产生类型转换。
  3.基本类型不能和布尔型相互转换

eg:.short s1=1;s1=s1+1;有什么错？short s1=1;s1+=1;有什么错？

对于s1 = s1 +1；由于执行s1 + 1 时会自动提升表达式的类型，这里得到的结果为int型（当short，byte，char 这些比int字节数小的变量类型来说，当它们和int进行运算时，运算结果会自动转换为int类型），最后当将int数据赋值给short类型的s1时，编译器会报告需要强制类型转换的错误。

而对于s1+=1；由于+=是Java语言规定的运算符，Java编译器会对它进行特殊的处理，因此可以正确编译

示例代码2：

package dong.test;

public class Test {
	public static void main(String[] args){
		byte a1=2,a2=4,a3,a4;
		
		//数值型变量在默认情况下为Int型，
		//byte和short型在计算时会自动转换为int型计算，
		//结果也是int 型。所以a1+a2的结果是int 型的。
		
		a3 = a1+a2;//编译出错
		
		a4 = (byte) (a1 + a2);//编译通过
	}
}

• 强制类型转换：可能会损失精度

---

引用类型

1. 数组（数组是一种对象）
2. 类
3. 接口

---

1.Java为每一种基本数据类型都提供了一个对应的包装类

1.1装箱：基本数据类型装换为包装类
1.2拆箱：包装类转换为基本数据类型

引申：不可变类：是指当创建了类的实例后，就不允许修改他的值了，有点类似于常量，只允许程序读取但是不可以修改。

• 基本类型的包装类都是不可变类
• String也是不可变类。

eg:

int n = 10;
Integer i = n;//装箱
int n2 = i;//拆箱

---

实例代码1：

package dong.test;

public class Test {
	public  void add(Byte b){
		b = b++;
	}
	
	public void test(){
		Byte a = 127;
		Byte b = 127;
		add(++a);
		System.out.println("a="+a);
		add(b);
		System.out.println("b="+b);
	}
	
	public static void main(String[] args){
		Test t = new Test();
		t.test();
	}
}

运行结果：

a=-128
b=127

1.方法public void add(Byte b){}看似引用传递，但是在add（）函数内实现++操作，会自动拆箱为byte值传递类型，所以add（）函数不能实现自增功能。
2.Byte类型的数值范围是-128~127，在test函数中执行add（++a），a先自增1，此时a会越界，a的值变为-128.

---

Integer对象的创建和比较

demo1

JDK1.8 Integer类中valueOf（）的源码
valueOf():基本数据类型装箱为包装类是通过该方法实现的，这段代码作用是：如果是-128到127之间的int类型转换为Integer对象，则直接从cache[]数组里获取。
cache是IntegerCache内部类的一个静态数组，存放的是-128到127之间的Integer对象。当通过valueOf()方法获取包装类对象时，如果int参数在【-128,127】之间，则直接从缓存里面取，否则通过new 实例生成Integer对象。

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

public class test{
    public static void main(String[] args) {
        Integer a1 = 59;//直接赋值数字，java会自动装箱，自动调用Integer.valueOf(59).
        int a2 = 59;
        Integer a3 = Integer.valueOf(59);//Integer.valueOf(int i)会返回一个Integer对象，当i在-128~127之间时，会返回缓存中已创建的Integer对象。
        Integer a4 = new Integer(59);//显示装箱：返回一个新的对象

        System.out.println("a1 和 a2  "+(a1==a2));//true int与Integer在进行比较的时候，Integer会自动进行拆箱，转换为int与int进行比较，比较的是具体的值
        System.out.println("a1 和 a3  "+(a1==a3));//true
        System.out.println("a3 和 a4  "+(a4==a3));//false

        Integer a5 = 128;
        Integer a6 = Integer.valueOf(128);
        System.out.println("a5 和 a6  "+(a5==a6));//false 不在i在-128~127之间时
    }

}

demo2
Integer中equals方法

  public boolean equals(Object obj) {
        if (obj instanceof Integer) {//先判断是否为Integer实例
            return value == ((Integer)obj).intValue();//比较值
        }
        return false;
    }

public static void main(String[] args) {
        //valueOf()装箱
        //intValue（）拆箱
        Boolean result1 = Integer.valueOf(2).intValue() == 2;//先装箱后拆箱，比较的数值 true
        Boolean result2 = new Integer(2).equals(new Integer(2));//先比较是否都为Integer类型，后比较值 true
        System.out.println(result1);
        System.out.println(result2);
    }

总结：.Integer与Integer比较的时候，整数范围在-128到127之间时，不需要创建新的Integer对象，而是从缓存（IntegerCache）中获取已经创建好的Integer对象。当大于或小于这个范围的时候，就会直接调用new Integer来创建Integer对象。所以Integer a = 128 与 Integer b = Integer.valueOf(128) 都创建了新的Integer对象，用“==”比较会返回false 。