首先了解下Java的四类八种基本数据类型:
基本类型 | 占用空间(Byte) | 表示范围 | 包装器类型 |
boolean | 1/8 | true|false | Boolean |
char | 2 | -128~127 | Character |
byte | 1 | -128~127 | Byte |
short | 2 | -2ˆ15~2ˆ15-1 | Short |
int | 4 | -2ˆ31~2ˆ31-1 | Integer |
long | 8 | -2ˆ63~2ˆ63-1 | Long |
float | 4 | -3.403E38~3.403E38 | Float |
double | 8 | -1.798E308~1.798E308 | Double |
自动装箱
所谓的自动装箱就是将基本的数据类型自动转换为包装类型,如int自动转换为Integer
如下清单1:
1
2
3
4
5
6
7
8
9
10
11
12
|
@Test
public
void
boxingTest() {
Integer i1 =
17
;
Integer i2 =
17
;
Integer i3 =
137
;
Integer i4 =
137
;
System.out.println(i1 == i2);
11
System.out.println(i3 == i4);
}
|
输出:
1
2
|
true
false
|
解释下清单1第11句输出true的原因:
当包装器类型进行“==”比较时,i3会调用Integer.valueOf自动装箱基本数据类型为包装器类型。
及 当Integer 和另一个Integer 进行比较的时候,会先调用Integer.valueof 这个方法将对应的包装器类型的基本数据类型转换为包装器类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public
static
Integer valueOf(
int
i) {
if
(i >= IntegerCache.low && i <= IntegerCache.high)
return
IntegerCache.cache[i + (-IntegerCache.low)];
return
new
Integer(i);
}
|
从源码中可以看出,Integer对象自动缓存int值范围在low~high(-128~127),所有对于17 是没有重新new一个对象,而是直接返回缓存中的Integer对象,如果超出这个范围则会自动装箱为包装类,及new 一个新的对象,所以两个137就new了两次Integer 对象,所以他们是不相等的。
- Integer、Short、Byte、Character、Long这几个包装类的valueOf方法的实现是类似的;
- Double、Float的valueOf方法的实现是类似的。
- Boolean的valueOf方法的实现是个三目运算,形如` return (b ? TRUE : FALSE); `
- 自动拆箱
自动拆箱就是将包装器类型转换为基本数据类型,如将Integer 转换为int ,Float 转换为float 等;
1
2
3
4
5
6
7
8
9
10
11
12
@Test
public
void
unboxingTest() {
Integer i1 =
17
;
int
i2 =
17
;
int
i3 =
137
;
Integer i4 =
137
;
System.out.println(i1 == i2);
10
System.out.println(i3 == i4);
}
输出:
1
2
true
true
当 包装器类型与基本类型进行“==”比较时 ,包装器类型会调用Integer.intValur() 进行自动拆箱为基本数据类型;
1
2
3
4
5
6
7
/**
* Returns the value of this {@code Integer} as an
* {@code int}.
*/
public
int
intValue() {
return
value;
}
如:
清单3内容如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public
void
unboxingTest() {
Integer i1 =
17
;
Integer i2 =
17
;
Integer i3 =
137
;
Integer i4 =
137
;
// ==
System.out.println(i1 == i2);
System.out.println(i3 == i4);
// equals
System.out.println(i1.equals(i2));
15
System.out.println(i3.equals(i4));
}
输出:
1
2
3
4
true
false
true
true
当包装器类型与包装器类型进行“equals()”比较时, 首先是判断是否为同一类型,如果是同一类型,在进行拆箱转换为基本数据类型进行比较,相等这返回true,否则返回false;
如: Integer 中的equals()代码:
自动拆箱就是将包装器类型转换为基本数据类型,如将Integer 转换为int ,Float 转换为float 等;
1
2
3
4
5
6
7
8
9
10
11
12
|
@Test
public
void
unboxingTest() {
Integer i1 =
17
;
int
i2 =
17
;
int
i3 =
137
;
Integer i4 =
137
;
System.out.println(i1 == i2);
10
System.out.println(i3 == i4);
}
|
输出:
1
2
|
true
true
|
1
2
3
4
5
6
7
|
/**
* Returns the value of this {@code Integer} as an
* {@code int}.
*/
public
int
intValue() {
return
value;
}
|
如:
清单3内容如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
@Test
public
void
unboxingTest() {
Integer i1 =
17
;
Integer i2 =
17
;
Integer i3 =
137
;
Integer i4 =
137
;
// ==
System.out.println(i1 == i2);
System.out.println(i3 == i4);
// equals
System.out.println(i1.equals(i2));
15
System.out.println(i3.equals(i4));
}
|
输出:
1
2
3
4
|
true
false
true
true
|
如: Integer 中的equals()代码:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/**
* Compares this object to the specified object. The result is
* {@code true} if and only if the argument is not
* {@code null} and is an {@code Integer} object that
* contains the same {@code int} value as this object.
*
* @param obj the object to compare with.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
*/
public
boolean
equals(Object obj) {
if
(obj
instanceof
Integer) {
return
value == ((Integer)obj).intValue();
}
return
false
;
}
装箱拆箱综合清单:
输出:
这里面需要注意的是:当 “==”运算符的两个操作数都是包装器类型的引用,则是比较指向的是否是同一个对象,而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)另外,对于包装器类型,equals方法并不会进行类型转换。
|
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/**
* Compares this object to the specified object. The result is
* {@code true} if and only if the argument is not
* {@code null} and is an {@code Integer} object that
* contains the same {@code int} value as this object.
*
* @param obj the object to compare with.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
*/
public
boolean
equals(Object obj) {
if
(obj
instanceof
Integer) {
return
value == ((Integer)obj).intValue();
}
return
false
;
}
|