"JDK1.5"的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each 循环，自动装包/拆包，枚举，可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
自动装箱/拆箱(Autoboxing/unboxing)
自动装箱：基本类型自动转换为包装类
自动拆包：包装类自动转换为基本类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package com.linjunlong.fun.jdk15;
import java.util.ArrayList;
/**
* 功能：自动装箱/拆箱
* 编译器自动进行基本类型和对应的包装类型进行转换
* byte <--> Byte
* short <--> Short
* int <--> Integer
* long <--> Long
* float <--> Float
* double <--> Double
* char <--> Character
* boolean <--> Boolean
*
* @author linjunlong.com
*/
public class AutoBoxingOrUnBoxing {
/**
* 这里我们以Integer为实例
*/
public void jdk14() {
//在jdk1.4中,初始话一个值类型对应的包装类，你需要这么写
Integer integer = new Integer(1);
int i = integer.intValue();
//如果你需要在数组中添加一个数值类型的话，你还需要把他转成基础类型
new ArrayList().add(new Integer(i));
}
public void jdk15() {
//在jdk1.5中你可以这么写; int --> Integer
Integer integer = 1;
// Integer --> int
int i = integer;
//这里你可以直接添加数值类型
new ArrayList().add(i);
}
public static void main(String[] args) {
/*
* 这里有一些有趣的特性，享元模式，
* 经过装箱和解箱的对象只要大小在-128到127之间（byte类型的范围之间）
* 都会在jvm内存的对象缓存池里形成记录，下次有装箱和解箱行为的对象，
* 都会直接指向这个缓存次里的对象
*/
Integer num1 = 20;
int num2 = new Integer(20);
System.out.println( num1 == num2); //@answer1
Integer int1 = new Integer(20);
Integer int2 = new Integer(20);
System.out.println( int1 == int2); //@answer2
System.out.println(num1 == int1); //@answer3
System.out.println(num1 == int1*1);//@answer4
//->answer1:true num1和num2都经过了装箱和解箱，都指向缓存池里的对象20
//->answer2:false int1和int2 没经过装箱和解箱，2个是不同的对象，比较他们的引用地址肯定也不一样
//->ansewr3:false 一个在的引用地址指向缓存池，一个是指向对象[20]的引用地址2个也不相等
//->answer4:true 后面int1经过了解箱然后*1运算，然后又装箱成Integer类型，所以他的引用地址也是缓存池里的地址
}
}
静态导入(StaticImports)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.linjunlong.fun.jdk15;
import static java.lang.Integer.*; //导入了Integer的所有静态方法和静态属性
import static java.lang.Math.max; //导入了Math的max方法
/**
* 功能：静态导入
* 你可以导入一些静态方法和属性来当作类本身的方法和属性一样调用
*
* @author linjunlong.com
*/
public class StaticImports {
/**
* 这里我们以Integer的对象和方法为例
*/
public void jdk14() {
//在jdk1.4中你基本上只能这么写
Math.max(Integer.MAX_VALUE, Integer.MIN_VALUE);
Integer.parseInt("12");
}
public void jdk15() {
//在jdk1.5中你只要导入了相应的对象和方法你就可以直接写了
max(MAX_VALUE, MIN_VALUE);
parseInt("12");
}
}
For-Each循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.linjunlong.fun.jdk15;
/**
* 功能：ForEach循环
*
* @author linjunlong.com
*/
public class ForEach {
/**
* 例如在jdk1.4中，我们需要遍历一个数组，或集合，用for循环的话，我们基本只能这么写
*/
public static void jdk14(String[] strs) {
for(int i = 0,max = strs==null?0:strs.length
; i < max ; i ++) {
System.out.print(strs[i]);
}
}
public static void jdk15(String[] strs) {
//jdk1.5中我们可以
for(String s : strs) {
System.out.print(s);
}
}
public static void main(String[] args) {
String[] strs = {"a","b","c"};
ForEach.jdk14(strs);//abc
ForEach.jdk15(strs);//abc
}
}
可变长参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.linjunlong.fun.jdk15;
/**
* 功能：可变长参数
* 1、方法的参数是可以变长的
* 2、可变长参数一定要是方法的最后一个参数
*
* @author linjunlong.com
*/
public class VariableArguments {
/**
* 例如在jdk14中，如果需要传一堆字符串
* 这么写
*/
public static void jdk14(String[] strs) {
for(int i = 0,max = strs==null?0:strs.length
; i < max ; i ++) {
System.out.print(strs[i]);
}
}
/**
* 在jdk1.5中，我们可以这么写,注意String后面的3个点...
* @param strs
*/
public static void jdk15(String... strs) {
for(int i = 0,max = strs==null?0:strs.length
; i < max ; i ++) {
System.out.print(strs[i]);
}
}
public static void main(String[] args) {
String[] strs = {"a","b","c"};
VariableArguments.jdk14(strs);//abc
VariableArguments.jdk15(strs);//abc
//jdk15还可以
VariableArguments.jdk15("a","b","c");//abc
}
}
枚举
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.linjunlong.fun.jdk15;
/**
* 功能：枚举
* 枚举类型，jdk1.5加入了一个新的关键字enmu，我们可以这样来定义一个枚举类型。
*
* @author linjunlong.com
*/
public class Enums {
//这里用了静态内部类，只是为了方便写例子
public static enum Colors {
Red,
White,
Blue
}
public static void main(String[] args) {
//我们可以这样使用枚举
Enums.Colors myColors = Enums.Colors.Red;
System.out.println(myColors);
for(Enums.Colors c : Enums.Colors.values()) {
System.out.println(c);
}
}
}
泛型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.linjunlong.fun.jdk15;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* 功能：泛型
* C++通过模板技术可以指定集合的元素类型，
* 而Java在1.5之前一直没有相对应的功能。
* 一个集合可以放任何类型的对象，
* 相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。
* 猛虎引入了泛型，它允许指定集合里元素的类型，
* 这样你可以得到强类型在编译时刻进行类型检查的好处。
*
* @author linjunlong.com
*/
public class Generic {
public static void jdk14(){
//相当于15中的List<Object> list = new ArrayList<Object>();
List list = new ArrayList();
list.add("1");//我们现在在list中添加了一个字符串类型
String s = (String)list.get(0);//需要强转
list.add(new Date());//我们还可以添加一个Date类型
}
public static void jdk15(){
List<String> list = new ArrayList<String>();
list.add("1");
String s = list.get(0);//不需要强转
//list.add(new Date());//编译不通过
}
}
