Java入门-1-数据类型 8种基本类型对照表类型比较 byte与Byte对比short与Short对比int与Integer对比long与Long对比整型总结float与Float对比double与Double对比浮点型总结char与Character对比字符型总结boolean与Boolean对比逻辑型总结

◆Java入门-1-数据类型

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

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

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

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

◆8种基本类型对照表

注： 1字节(byte)=8位(bit)，1B=8b。 注： 263=9223372036854774808

分类基本类型引用类型取值范围字节长度整型byteByte-128~1271字节整型shortShort-32768~327672字节整型intInteger-2147483648~21474836474字节整型longLong −263 ~ 263−1 8字节浮点型floatFloat 2−149 ~ (2−2−23)∗2127 4字节浮点型doubleDouble 2−1074 ~ 21024−1 8字节字符型charCharacter整个Unicode字符集2字节逻辑型booleanBooleantrue~ false1位

◆类型比较

◆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。

◆整型总结

Byte、Short、Integer、Long都对从-128到127的整数进行了缓存，刚好是byte的取值范围。不使用引用对象创建实例时，值在byte取值范围时相等，超出byte取值范围时不相等。使用引用对象创建实例时，值不相等。整型引用对象需要使用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。

◆逻辑型总结

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