1、Java八种基本数据类型的大小、默认值及对应封装类
基本类型 | 大小(字节) | 默认值 | 取值范围 | 封装类 |
---|---|---|---|---|
byte | 1 | (byte)0 | -128~127 | Byte |
short | 2 | (short)0 | -32768~32767 | Short |
int | 4 | 0 | -231 ~ 2(31-1) | Integer |
long | 8 | 0L | -263 ~ 2(63-1) | Long |
float | 4 | 0.0f | 1.4E-45~3.4028235E38 | Float |
double | 8 | 0.0d | 4.9E-324~1.7976931348623157E308 | Double |
boolean | - | false | true或false | Boolean |
char | 2 | \u0000(null) | 0~65535 | Character |
2、基础类型与包装类型的区别
-
包装类型可以为null,基础类型不可以。
例如:int默认值是0,而Integer默认值是null,所以Integer能区分出0和null的情况。一旦java看到null,就知道这个引用还没有指向某个对象,再任何引用使用前,必须为其指定一个对象,否则会报NullPointer。
包装类型的这一特性使其广泛应用于POJO中(POJO专指只有setter/getter/toString的简单类,例如DO/DTO/BO/VO 等),而基本类型不行。因为数据库的查询结果可能是null,如果使用基本类型的话,因为要自动拆箱(将包装类型转为基本类型,比如说把Integer 对象转换成int值),就会抛出 NullPointerException 的异常。
具体示例如下代码,将为null的Interger类型a,赋值给int类型b,编译报 NullPointerException 。
public class Main {
public static void main(String[] args) {
Integer a = null;
int b = a;
System.out.println(b);
}
}
执行结果:
-
包装类型是对象,基本类型不是。
在Java中可以理解为一切皆对象,但是基本类型除外,因为基本数据类型是Java语言的一部分,它们是原始的、简单的数据类型,直接存储在内存中的栈中,不需要进行对象的创建和销毁,所以基本类型不是对象。
-
内存中存储方式及位置的不同
基本数据类型直接存储在内存中的栈中,在声明时系统会自动给它分配空间,而包装类型声明时只是分配了引用空间,需要通过引用指向实例,必须通过实例化开辟数据空间之后才可以赋值,具体的实例保存在堆中。
因此基本数据类型在内存分配和访问上更加高效,可以提高程序的执行效率。而包装类型的效率相对就明显更低。
示例如下:Long与long做+=操作耗时比较,两者完全不在一个数量级,当然这是针对数据量较大的情况,正常情况下时间差异还是没有这么大的。
public class Main {
public static void main(String[] args) {
//包装类型
long t1 = System.currentTimeMillis();
Long sum1 = 0L;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
sum1 += i;
}
long t2 = System.currentTimeMillis();
System.out.println(t2-t1);
//基本类型
long t3 = System.currentTimeMillis();
long sum2 = 0L;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
sum2 += i;
}
long t4 = System.currentTimeMillis();
System.out.println(t4-t3);
}
}
执行结果:
-
包装类型可以用于泛型,基本类型不可以
泛型的使用只能是对象,所以基本数据类型不可以用于泛型。最常见的例如集合中使用从而限定集合中数据元素的类型。
示例如下:语法报错,List泛型,参数类型不能为基本类型。
public class Main {
public static void main(String[] args) {
List<int> l1 = new ArrayList<>();//Syntax error, insert "Dimensions" to complete ReferenceType
List<Integer> l2 = new ArrayList<>();
}
}
3、自动装箱与拆箱
装箱就是自动将基本数据类型转换为包装类型;如int —>Integer的转换,实际就是调用Integer的valueOf(int)方法,将int转换为Integer。
拆箱就是自动将包装类型转换为基本数据类型;如Integer—>int的转换,实际就是调用Integer的intValue()方法,将Integer转换为int。
装箱与拆箱是Java SE5中引入的概念,在Java SE5之前,如果要创建一个数值为1的Integer对象:
Integer i = new Integer(1);
而在Java SE5之后,只需:
Integer i = 1;//自动装箱实现
4、Integer缓存池
Java SE5在引入装箱与拆箱概念的同时,还引入了一个叫IntegerCache的Integer缓存池(常量池)的特性,有助于Integer使用时节省内存、提高性能。
先看一段经典案例代码
public class IntegerCacheExample {
public static void main(String[] args) {
Integer a = 127;
Integer b = 127;
System.out.printf("a==b: %s.\n", a == b);
Integer c = 128;
Integer d = 128;
System.out.printf("c==d: %s.\n", c == d);
}
}
输出结果:
是什么问题导致的这种情况呢?是在自动装箱过程中调用的valueOf(int)方法,使用了Integer缓存池的特性导致的。
看一下valueOf的具体实现:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
看到int在一定取值范围内,没有直接实例化一个Integer对象,而是使用了IntegerCache中的常量池cache[]。
继续看IntegerCache的源码:
/**
* Cache to support the object identity semantics of autoboxing for values between
* -128 and 127 (inclusive) as required by JLS.
*
* The cache is initialized on first usage. The size of the cache
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
* During VM initialization, java.lang.Integer.IntegerCache.high property
* may be set and saved in the private system properties in the
* sun.misc.VM class.
*/
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
在源码中可以看到,默认在-128到127之间的int,转换成Integer时,使用的是常量池的中对象。
所以在示例代码中的a和b实际上都是常量池中的同一个Integer对象,==判断的两侧对象地址相等,返回ture;而c和d因为超出了常量池默认取值范围,所以是分别示例化了一个新的Integer对象,==判断的对象地址不相等,返回false。
回到IntegerCache源码,在源码注释中提到了常量池生成的默认范围是-128~127,但是可以在启动之前配置JVM参数AutoBoxCacheMax进行常量池范围修改。