Java入门-1-数据类型

◆Java入门-1-数据类型

在Java的世界里，数据类型分为基本类型(值类型)和包装类型(引用类型)，值类型不是对象，不能调用Object对象提供的方法，如toString()、hashCode()等。

C#、Python、Go等也有类似值类型和引用类型的概念

JAVA的引用类型有两类：Class和Interface。网上有些把数组(Array)也算一类，个人认为数组(Array)是Class的一个具体形式，应该归属于Class；当然数组是一个比较特殊的对象，其class带有“[“这种特殊符号，单独算一类也说得通，我们今天的重点并不是数组这个类型，就不在细究。

通俗比喻：值类型就是现金，要用直接用；引用类型是存折，要用还得先去银行取现。—-(摘自网上)

◆8种基本类型对照表

注： 1字节(byte)=8位(bit)，1B=8b。
注： $2^{63}=9223372036854774808$

分类	基本类型	引用类型	取值范围	字节长度
整型	byte	Byte	-128~127	1字节
整型	short	Short	-32768~32767	2字节
整型	int	Integer	-2147483648~2147483647	4字节
整型	long	Long	$-2^{63}$~$2^{63}-1$	8字节
浮点型	float	Float	$2^{-149}$~$(2-2^{-23})*2^{127}$	4字节
浮点型	double	Double	$2^{-1074}$~${2^{1024}}-1$	8字节
字符型	char	Character	整个Unicode字符集	2字节
逻辑型	boolean	Boolean	true~ false	1位

◆类型比较

◆byte与Byte对比

byte初始值为0，Byte初始值为null；

byte b1 = 127;
Byte b2 = 127;
Byte b3 = new Byte("127");
System.out.println(b1 == b2);//b2自动拆箱为byte，所以为true;
System.out.println(b1 == b3);//同上
Byte b5 = 127;//被编译成-> Byte b5 = Byte.valueOf(127);
Byte b6 = 127;
System.out.println(b5 == b6);//byte值范围内Byte.valueOf会进行引用缓存，所以为true。
Byte b7 = new Byte("127");
System.out.println(b6 == b7);//不同引用，所以为false。
Byte b8 = new Byte("127");
Byte b9 = new Byte("127");
System.out.println(b8 == b9);//不同引用，所以为false。

◆short与Short对比

short初始值为0，Short初始值为null；

short s1 = 128;
Short s2 = 128;
Short s3 = new Short("128");
System.out.println(s1 == s2);//s2自动拆箱为short，所以为true;
System.out.println(s1 == s3);//同上
Short s5 = 127;//被编译成-> Short s5 = Short.valueOf(127);
Short s6 = 127;
System.out.println(s5 == s6);//byte值范围内Short.valueOf会进行引用缓存，所以为true。
Short s7 = new Short("127");
System.out.println(s6 == s7);//不同引用，所以为false。
Short s8 = 128;
Short s9 = 128;
System.out.println(s8 == s9);//128超出byte值范围，所以为false。
Short s10 = new Short("128");
Short s11 = new Short("128");
System.out.println(s10 == s11);//不同引用，所以为false。

◆int与Integer对比

int初始值为0，Integer初始值为null；

int i1 = 128;
Integer i2 = 128;
Integer i3 = new Integer(128);
System.out.println(i1 == i2);//i2自动拆箱为int，所以为true;
System.out.println(i1 == i3);//同上
Integer i5 = 127;//被编译成-> Integer i5 = Integer.valueOf(127);
Integer i6 = 127;
System.out.println(i5 == i6);//byte值范围内Integer.valueOf会进行引用缓存，所以为true。
Integer i7 = new Integer(127);
System.out.println(i6 == i7);//不同引用，所以为false。
Integer i8 = 128;
Integer i9 = 128;
System.out.println(i8 == i9);//128超出byte值范围，所以为false。
Integer i10 = new Integer(128);
Integer i11 = new Integer(128);
System.out.println(i10 == i11);//不同引用，所以为false。

◆long与Long对比

long初始值为0l，Long初始值为null；

long l1 = 128;
Long l2 = 128l;
Long l3 = new Long(128);
System.out.println(l1 == l2);//l2自动拆箱为long，所以为true;
System.out.println(l1 == l3);//同上
Long l5 = 127l;//被编译成-> Long l5 = Long.valueOf(127);
Long l6 = 127l;
System.out.println(l5 == l6);//byte值范围内Long.valueOf会进行引用缓存，所以为true。
Long l7 = new Long(127);
System.out.println(l6 == l7);//不同引用，所以为false。
Long l8 = 128l;
Long l9 = 128l;
System.out.println(l8 == l9);//128超出byte值范围，所以为false。
Long l10 = new Long(128);
Long l11 = new Long(128);
System.out.println(l10 == l11);//不同引用，所以为false。

◆整型总结

1. Byte、Short、Integer、Long都对从-128到127的整数进行了缓存，刚好是byte的取值范围。
2. 不使用引用对象创建实例时，值在byte取值范围时相等，超出byte取值范围时不相等。
3. 使用引用对象创建实例时，值不相等。
4. 整型引用对象需要使用equals()进行比较，或者使用xxxValue()把引用对象转成值对象。如byteValue()、shortValue()、intValue()、longValue()。

◆float与Float对比

float f1 = 128000F;
Float f2 = 128000F;
Float f3 = new Float(128000);
System.out.println(f1 == f2);// f2自动拆箱为float，所以为true;
System.out.println(f1 == f3);// 同上
Float f5 = 127F;// 被编译成-> Float f5 = Float.valueOf(127);
Float f6 = 127F;
System.out.println(f5 == f6);// Float没有缓存，所以为false。
Float f7 = new Float(127);
System.out.println(f6 == f7);// 不同引用，所以为false。
Float f8 = 128F;
Float f9 = 128F;
System.out.println(f8 == f9);// 不同引用，所以为false。
Float f10 = new Float(128);
Float f11 = new Float(128);
System.out.println(f10 == f11);// 不同引用，所以为false。

◆double与Double对比

double d1 = 128000d;
Double d2 = 128000d;
Double d3 = new Double(128000);
System.out.println(d1 == d2);// d2自动拆箱为double，所以为true;
System.out.println(d1 == d3);// 同上
Double d5 = 127d;// 被编译成-> Double d5 = Double.valueOf(127);
Double d6 = 127d;
System.out.println(d5 == d6);// Double没有缓存，所以为false。
Double d7 = new Double(127);
System.out.println(d6 == d7);// 不同引用，所以为false。
Double d8 = 128d;
Double d9 = 128d;
System.out.println(d8 == d9);// 不同引用，所以为false。
Double d10 = new Double(128);
Double d11 = new Double(128);
System.out.println(d10 == d11);// 不同引用，所以为false。

◆浮点型总结

浮点型和整型不同，没有内置缓存机制，所以除了有值类型存在，否则是无法”==”比较。

◆char与Character对比

char c1 = 128;
Character c2 = 128;
Character c3 = new Character((char)128);
System.out.println(c1 == c2);//c2自动拆箱为char，所以为true;
System.out.println(c1 == c3);//同上
Character c5 = 127;//被编译成-> Character c5 = Character.valueOf(127);
Character c6 = 127;
System.out.println(c5 == c6);//byte值范围内Character.valueOf会进行引用缓存，所以为true。
Character c7 = new Character((char)127);
System.out.println(c6 == c7);//不同引用，所以为false。
Character c8 = 128;
Character c9 = 128;
System.out.println(c8 == c9);//128超出byte值范围，所以为false。
Character c10 = new Character((char)128);
Character c11 = new Character((char)128);
System.out.println(c10 == c11);//不同引用，所以为false。

◆字符型总结

字符型和整型类似，内部创建了一个缓存，不过只有128个长度，从0开始的Character对象。

◆boolean与Boolean对比

boolean初始值为false，Boolean初始值为null；

boolean b1 = true;
Boolean b2 = true;
Boolean b3 = new Boolean(true);
System.out.println(b1 == b2);//b2自动拆箱为boolean，所以为true;
System.out.println(b1 == b3);//同上
Boolean b5 = true;//被编译成-> Boolean b5 = Boolean.valueOf(true);
Boolean b6 = true;
System.out.println(b5 == b6);//直接赋值进行比较为true。
Boolean b7 = new Boolean(true);
System.out.println(b6 == b7);//不同引用，所以为false。
Boolean b8 = new Boolean(true);
Boolean b9 = new Boolean(true);
System.out.println(b8 == b9);//不同引用，所以为false。

◆逻辑型总结

逻辑型和浮点型型的规则类似，没有内置缓存机制，所以除了有值类型存在，否则是无法”==”比较
=============================悬崖================================
如有理解不到位欢迎大家指正，欢迎讨论！！！