概述
8种基本数据类型
long double int float byte char short boolean(栈)
字符 char
数值 整形: long int byte short 浮点型：double float
布尔 boolean
包装类在jdk中处理方式
Long Double Integer Float ByteCharacter Short Boolean(堆)
Integer 32位 -2147483648 ~ 2147483647
JDK源码
/*
* IntegerCache内部类
* 其中cache[]数组用于存放从-128到127一共256个整数
*/
private static class IntegerCache {
static final int high;
static final Integer cache[];
static {
final int low = -128;
// high value may be configured by property
int h = 127;
if (integerCacheHighPropValue != null) {
// Use Long.decode here to avoid invoking methods that
// require Integer's autoboxing cache to be initialized
int i = Long.decode(integerCacheHighPropValue).intValue();
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - -low);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
//进行缓存
return IntegerCache.cache[i + 128];
else
//新的对象
return new Integer(i);
}
当if为true时会获取缓存的值else实例化一个新的Integer对象
例1
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1 == i2);
处理过程
1> Integer.valueOf(127)
2> 当值大于等于 -128 <= 127 时会调用IntegerCache.cache[i + 128]
例2
Integer i1 = 128;
Integer i2 = 128;
System.out.println(i1 == i2);
处理过程
1> Integer.valueOf(128)
2> new Integer(128)
结果 ：例1为true
因为当值在-128 到127之间时那么Integer.valueOf
会从IntegerCache.cache缓存中获取，那么获得的就是该数组下
同一个引用对象，判断堆中的地址是否一样
例2 false
因为不在-128 到127之间，虚拟机会实例化两个不同Integer对象
如果想比较堆中i1,i2对象的内容是否一致时，使用equals来进行判断
总结: 当Integer取值范围在-128 ~ 127 之间时那么每次都会从IntegerCache.cache数组缓存中获得，不会每次都去实例化一个Integer对象，也就是说不会开辟一个新的内存空间，这样在性能方面也是一个很大的优化.
例3
Integer i1 = 128;
System.out.println(i1 == 128);
处理过程
1> Integer.valueOf(128) (i1)
2> new Integer(128)
3> i1.intValue()
结果: 例3 为true
(i1 == 128) 因为128是int类型 这个时候Integer对象会进行拆箱操作，然后在做比较，那么它们比较的，就不是堆中的地址，而是判断数值是否是一样。
Long和Integer处理类似 64位 -9223372036854775808 ~ 9223372036854775807
JDK源码
public static Long valueOf(long l) {
final int offset = 128;
if (l >= -128 && l <= 127) { // will cache
return LongCache.cache[(int)l + offset];
}
return new Long(l);
}
/*
* LongCache内部类
* 其中cache[]数组用于存放从-128到127一共256个整数
*/
private static class LongCache {
private LongCache(){}
static final Long cache[] = new Long[-(-128) + 127 + 1];
static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Long(i - 128);
}
}
longValue() 拆箱
Float 32位 -3.40292347E+38 ~ 3.40292347E+38 （E表示10的N（38）次方）
例1
Float f1 = 12.5F;
Float f2 = 12.5F;
System.out.println(f1 == f2);
处理过程
1> Float.valueOf(12.5)
2> new Float(12.5)
例2
Float f1 = 12.5F;
float f2= 12.5F;
System.out.println(f1 == f2);
处理过程
1> Float.valueOf(12.5)
2> new Float(12.5)
3> i1.intValue()
例3
Float f1 = 12.5F;
Float f2 = 12.5F;
System.out.println(f1.equals(f2));
处理过程
1> Float.valueOf(12.5)
2> new Float(12.5)
结果
例1 false
因为比较是堆中地址，Float 类型每次都会进行实例化，所以两个在堆中地址是不一样的
例2 true
因为 f2 是基本数据类型，所以f1首先会进行拆箱操作然后在进行比较，比较的是数值
例3 true
因为equals比较时f1,f2堆中内容，是否一样
Double 64位 -1.79769313486231570E+38 ~ 1.79769313486231570E+38 （E表示10的N（38）次方）
处理逻辑同Float类似
Short 16位 -32768 ~ 32767
处理逻辑同Long类似
Byte 8位 -128 ~ 127
处理逻辑同Long类似
Character 16位 /u0000 ~ /uffff
整型和char之间可以互相转换
Boolean true / false
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
基本数据类型：存放在栈中
对象： 引用存放在栈，实际对象时存放在堆中
以上如有不对的地方请留言，让我们一起共同学习！
最后
以上就是怡然身影为你收集整理的JDK - 8种基本类型，和包装类的全部内容，希望文章能够帮你解决JDK - 8种基本类型，和包装类所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复