JDK1.5/1.6新特性总结
一、JDK1.5新特性
1、泛型(Generic)
可以在编译的时候检测出类型错误，编译后和没有使用泛型的效果是相同的，但是使用泛型可以让你在编译时就发现错误，例如：
例1-1代码
1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.Iterator;
4.
5. public class GenericTest {
6. public static void main(String[] args) {
7. Collection c = new ArrayList();
8. c.add(new Integer(1));
9. c.add("123");
10. for(Iterator i=c.iterator();i.hasNext();){
11. String s = (String) i.next();
12. System.out.println(s);
13. }
14. }
15. }
16.
17. 运行结果：
18. Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
19. at GenericTest.main(GenericTest.java:12)
例1-1代码
1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.Iterator;
4.
5. public class GenericTest {
6. public static void main(String[] args) {
7. Collection c = new ArrayList();
8. c.add(new Integer(1));
9. c.add("123");
10. for(Iterator i=c.iterator();i.hasNext();){
11. String s = (String) i.next();
12. System.out.println(s);
13. }
14. }
15. }
16.
17. 运行结果：
18. Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
19. at GenericTest.main(GenericTest.java:12)
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Integer(1));
c.add("123");
for(Iterator i=c.iterator();i.hasNext();){
String s = (String) i.next();
System.out.println(s);
}
}
}
运行结果：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at GenericTest.main(GenericTest.java:12)
Collection应该只存放String对象，但是我们“不小心”添加了一个Integer类型的对象，编译正常进行，程序在运行时才发现错误。
下面是使用了泛型后的程序
例1-2代码 复制代码
1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.Iterator;
4.
5. public class GenericTest {
6. public static void main(String[] args) {
7. Collection<String> c = new ArrayList<String>();
8. c.add(new Integer(1));
9. c.add("123");
10. for(Iterator<String> i=c.iterator();i.hasNext();){
11. String s = i.next();
12. System.out.println(s);
13. }
14. }
15. }
16.
17. 运行结果
18. D:\test>javac GenericTest.java
19. GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer)
20. c.add(new Integer(1));
21. ^
22. 1 错误
23.
24. D:\test>
例1-2代码
1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.Iterator;
4.
5. public class GenericTest {
6. public static void main(String[] args) {
7. Collection<String> c = new ArrayList<String>();
8. c.add(new Integer(1));
9. c.add("123");
10. for(Iterator<String> i=c.iterator();i.hasNext();){
11. String s = i.next();
12. System.out.println(s);
13. }
14. }
15. }
16.
17. 运行结果
18. D:\test>javac GenericTest.java
19. GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer)
20. c.add(new Integer(1));
21. ^
22. 1 错误
23.
24. D:\test>
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add(new Integer(1));
c.add("123");
for(Iterator<String> i=c.iterator();i.hasNext();){
String s = i.next();
System.out.println(s);
}
}
}
运行结果
D:\test>javac GenericTest.java
GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer)
c.add(new Integer(1));
^
1 错误
D:\test>
使用了泛型之后在编译时就发现了错误，可以增强程序的健壮性，而其i.next();也不用使用强制类型转换了。
2、增强for循环(For-Each)
For-Each的内部是用Iterator实现的，但是使用起来更简单，例如使用For-Each实现1-2如下
例2-1 代码 复制代码
1. import java.util.ArrayList;
2. import java.util.Collection;
3.
4. public class GenericTest {
5. public static void main(String[] args) {
6. Collection<String> c = new ArrayList<String>();
7. c.add("aa");
8. c.add("bb");
9. for(String s:c){
10. System.out.println(s);
11. }
12. }
13. }
14. 运行结果：
15. aa
16. bb
例2-1 代码
1. import java.util.ArrayList;
2. import java.util.Collection;
3.
4. public class GenericTest {
5. public static void main(String[] args) {
6. Collection<String> c = new ArrayList<String>();
7. c.add("aa");
8. c.add("bb");
9. for(String s:c){
10. System.out.println(s);
11. }
12. }
13. }
14. 运行结果：
15. aa
16. bb
import java.util.ArrayList;
import java.util.Collection;
public class GenericTest {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("aa");
c.add("bb");
for(String s:c){
System.out.println(s);
}
}
}
运行结果：
aa
bb
比Integer方便多了吧？可以使程序员更加注重逻辑，而不是代码本身。
3、自动装箱拆箱(Autoboxing/unboxing)
例3-1代码 复制代码
1. Integer i = new Integer(2);
2. //i自动拆箱为int类型
3. System.out.println(i==2);
4. //3自动装箱为Integer类型
5. System.out.println(i.equals(3));
例3-1代码
1. Integer i = new Integer(2);
2. //i自动拆箱为int类型
3. System.out.println(i==2);
4. //3自动装箱为Integer类型
5. System.out.println(i.equals(3));
Integer i = new Integer(2);
//i自动拆箱为int类型
System.out.println(i==2);
//3自动装箱为Integer类型
System.out.println(i.equals(3));
4、静态导入(static import)
例4-1代码 复制代码
1. //静态导入Math的random方法
2. import static java.lang.Math.random;
3.
4. public class StaticImportTest {
5. public static void main(String[] args){
6. //类中生成随机数数可以直接使用静态引入的random方法了，而不用Math.random()这样调用了
7. System.out.println(random());
8. }
9. }
例4-1代码
1. //静态导入Math的random方法
2. import static java.lang.Math.random;
3.
4. public class StaticImportTest {
5. public static void main(String[] args){
6. //类中生成随机数数可以直接使用静态引入的random方法了，而不用Math.random()这样调用了
7. System.out.println(random());
8. }
9. }
//静态导入Math的random方法
import static java.lang.Math.random;
public class StaticImportTest {
public static void main(String[] args){
//类中生成随机数数可以直接使用静态引入的random方法了，而不用Math.random()这样调用了
System.out.println(random());
}
}
5、格式化打印(formatted print)
C语言中printf()风格的格式化输出。
这里只举一个thinking in java的一个例子：
例5-1代码 复制代码
1. public class SimpleFormat {
2. public static void main(String[] args) {
3. int x = 5;
4. double y = 5.332542;
5. //The old way
6. System.out.println("Row 1: ["+x+" "+y+"]");
7. //The new way
8. System.out.format("Row 1: [%d %f]\n", x,y);
9. //or
10. System.out.printf("Row 1: [%d %f]\n", x, y);
11. }
12. }
13.
14. 运行结果：
15. Row 1: [5 5.332542]
16. Row 1: [5 5.332542]
17. Row 1: [5 5.332542]
例5-1代码
1. public class SimpleFormat {
2. public static void main(String[] args) {
3. int x = 5;
4. double y = 5.332542;
5. //The old way
6. System.out.println("Row 1: ["+x+" "+y+"]");
7. //The new way
8. System.out.format("Row 1: [%d %f]\n", x,y);
9. //or
10. System.out.printf("Row 1: [%d %f]\n", x, y);
11. }
12. }
13.
14. 运行结果：
15. Row 1: [5 5.332542]
16. Row 1: [5 5.332542]
17. Row 1: [5 5.332542]
public class SimpleFormat {
public static void main(String[] args) {
int x = 5;
double y = 5.332542;
//The old way
System.out.println("Row 1: ["+x+" "+y+"]");
//The new way
System.out.format("Row 1: [%d %f]\n", x,y);
//or
System.out.printf("Row 1: [%d %f]\n", x, y);
}
}
运行结果：
Row 1: [5 5.332542]
Row 1: [5 5.332542]
Row 1: [5 5.332542]
可以看到，format和printf是等价的，他们只需要一个简单的格式化字符串，加上一串参数即可，每个参数对应一个格式修饰符
6、枚举(Enum)
当每一类型可取值范围是有限的时候，可以使用枚举，例如每个学生登记只能用ABCD表示，如果直接用E的话，那么编译不会出错，但是却不符合输入要求，而使用枚举增加程序的易读性和健壮性？
Java代码 复制代码
1. public class GradeTest {
2. public static void main(String[] args) {
3. Student stu = new Student();
4. stu.setName("wasw100");
5. stu.setGrade(Grade.A);
6. //输出学生信息
7. System.out.println(stu);
8. }
9. }
10.
11. /**
12. * 枚举：Grader 学生考试等级
13. * @author wasw100
14. */
15. enum Grade{
16. A,B,C,D
17. }
18.
19. class Student {
20. private String name;
21. private Grade grade;
22.
23. //重写toString()方法
24. public String toString(){
25. return "name:+"+name+"\ngrader:"+grade;
26. }
27.
28. public String getName() {
29. return name;
30. }
31.
32. public void setName(String name) {
33. this.name = name;
34. }
35.
36. public Grade getGrade() {
37. return grade;
38. }
39.
40. public void setGrade(Grade grade) {
41. this.grade = grade;
42. }
43.
44. }
Java代码
1. public class GradeTest {
2. public static void main(String[] args) {
3. Student stu = new Student();
4. stu.setName("wasw100");
5. stu.setGrade(Grade.A);
6. //输出学生信息
7. System.out.println(stu);
8. }
9. }
10.
11. /**
12. * 枚举：Grader 学生考试等级
13. * @author wasw100
14. */
15. enum Grade{
16. A,B,C,D
17. }
18.
19. class Student {
20. private String name;
21. private Grade grade;
22.
23. //重写toString()方法
24. public String toString(){
25. return "name:+"+name+"\ngrader:"+grade;
26. }
27.
28. public String getName() {
29. return name;
30. }
31.
32. public void setName(String name) {
33. this.name = name;
34. }
35.
36. public Grade getGrade() {
37. return grade;
38. }
39.
40. public void setGrade(Grade grade) {
41. this.grade = grade;
42. }
43.
44. }
public class GradeTest {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("wasw100");
stu.setGrade(Grade.A);
//输出学生信息
System.out.println(stu);
}
}
/**
* 枚举：Grader 学生考试等级
* @author wasw100
*/
enum Grade{
A,B,C,D
}
class Student {
private String name;
private Grade grade;
//重写toString()方法
public String toString(){
return "name:+"+name+"\ngrader:"+grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
}
7、可变长参数(varargs)
方法的参数是不固定的我们一般会使用重载或者使用数组参数。重载需要些更多写更多的方法，数组需要在使用时先声明。
可能参数是一个不错的解决方案。
下面是网上一个 唐僧 给 悟空 将佛经的例子
Java代码 复制代码
1. public class VarargsTest {
2. public void speak(String name, Object... arguments) {
3. System.out.print(name+": ");
4. for (Object object : arguments) {
5. System.out.print(object);
6. }
7. System.out.println();
8. }
9.
10. public static void main(String[] args) {
11. VarargsTest vt = new VarargsTest();
12. vt.speak("悟空", "人和妖精都是妈生的,");
13. vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");
14. }
15. }
16.
17. 运行结果：
18. 悟空: 人和妖精都是妈生的,
19. 悟空: 不同的人是人他妈生的,妖是妖他妈生的,
Java代码
1. public class VarargsTest {
2. public void speak(String name, Object... arguments) {
3. System.out.print(name+": ");
4. for (Object object : arguments) {
5. System.out.print(object);
6. }
7. System.out.println();
8. }
9.
10. public static void main(String[] args) {
11. VarargsTest vt = new VarargsTest();
12. vt.speak("悟空", "人和妖精都是妈生的,");
13. vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");
14. }
15. }
16.
17. 运行结果：
18. 悟空: 人和妖精都是妈生的,
19. 悟空: 不同的人是人他妈生的,妖是妖他妈生的,
public class VarargsTest {
public void speak(String name, Object... arguments) {
System.out.print(name+": ");
for (Object object : arguments) {
System.out.print(object);
}
System.out.println();
}
public static void main(String[] args) {
VarargsTest vt = new VarargsTest();
vt.speak("悟空", "人和妖精都是妈生的,");
vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");
}
}
运行结果：
悟空: 人和妖精都是妈生的,
悟空: 不同的人是人他妈生的,妖是妖他妈生的,
可变长参数只能作为最后一个参数。
JDK1.6的九大新特性
一：Desktop类和SystemTray类
在JDK1.6中，AWT新增加了两个类：Desktop和SystemTray。
前者可以用来打开系统默认浏览器浏览指定的URL，打开系统默认邮件客户端给指定的邮箱发邮件，用默认应用程序打开或编辑文件(比如，用记事本打开以txt为后缀名的文件)，用系统默认的打印机打印文档；后者可以用来在系统托盘区创建一个托盘程序。
二：使用JAXB2来实现对象与XML之间的映射
JAXB是Java Architecture for XML Binding的缩写，可以将一个Java对象转变成为XML格式，反之亦然。
我们把对象与关系数据库之间的映射称为ORM，其实也可以把对象与XML之间的映射称为OXM(Object XML Mapping)。原来JAXB是Java EE的一部分，在JDK1.6中，SUN将其放到了Java SE中，这也是SUN的一贯做法。JDK1.6中自带的这个JAXB版本是2.0，比起1.0(JSR 31)来，JAXB2(JSR 222)用JDK5的新特性Annotation来标识要作绑定的类和属性等，这就极大简化了开发的工作量。
实际上，在Java EE 5.0中，EJB和Web Services也通过Annotation来简化开发工作。另外，JAXB2在底层是用StAX(JSR 173)来处理XML文档。除了JAXB之外，我们还可以通过XMLBeans和Castor等来实现同样的功能。
三：理解StAX
StAX(JSR 173)是JDK1.6.0中除了DOM和SAX之外的又一种处理XML文档的API。
StAX 的来历：在JAXP1.3(JSR 206)有两种处理XML文档的方法：DOM(Document Object Model)和SAX(Simple API for XML)。
由于JDK1.6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR 224)都会用到StAX所以Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版本)。JDK1.6里面JAXP的版本就是1.4。
StAX是The Streaming API for XML的缩写，一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于事件迭代器(Iterator)的API让程序员去控制xml文档解析过程，程序遍历这个事件迭代器去处理每一个解析事件，解析事件可以看做是程序拉出来的，也就是程序促使解析器产生一个解析事件然后处理该事件，之后又促使解析器产生下一个解析事件，如此循环直到碰到文档结束符；
SAX也是基于事件处理xml文档，但却是用推模式解析，解析器解析完整个xml文档后，才产生解析事件，然后推给程序去处理这些事件；DOM采用的方式是将整个xml文档映射到一颗内存树，这样就可以很容易地得到父节点和子结点以及兄弟节点的数据，但如果文档很大，将会严重影响性能。
四：使用Compiler API
现在我 们可以用JDK1.6 的Compiler API(JSR 199)去动态编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码，有点动态语言的特征。
这个特性对于某些需要用到动态编译的应用程序相当有用，比如JSP Web Server，当我们手动修改JSP后，是不希望需要重启Web Server才可以看到效果的，这时候我们就可以用Compiler API来实现动态编译JSP文件，当然，现在的JSP Web Server也是支持JSP热部署的，现在的JSP Web Server通过在运行期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码，这种方式需要我们产生另一个进程去做编译工作，不够优雅而且容易使代码依赖与特定的操作系统；Compiler API通过一套易用的标准的API提供了更加丰富的方式去做动态编译，而且是跨平台的。
五：轻量级Http Server API
JDK1.6 提供了一个简单的Http Server API，据此我们可以构建自己的嵌入式Http Server，它支持Http和Https协议，提供了HTTP1.1的部分实现，没有被实现的那部分可以通过扩展已有的Http Server API来实现，程序员必须自己实现HttpHandler接口，HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求，在这里，我们把一个Http请求和它的响应称为一个交换，包装成HttpExchange类，HttpServer负责将HttpExchange传给HttpHandler实现类的回调方法。
六：插入式注解处理API(Pluggable Annotation Processing API)
插入式注解处理API(JSR 269)提供一套标准API来处理Annotations(JSR 175)
实际上JSR 269不仅仅用来处理Annotation，我觉得更强大的功能是它建立了Java 语言本身的一个模型，它把method，package，constructor，type，variable， enum，annotation等Java语言元素映射为Types和Elements(两者有什么区别?)，从而将Java语言的语义映射成为对象，我们可以在javax.lang.model包下面可以看到这些类。 所以我们可以利用JSR 269提供的API来构建一个功能丰富的元编程(metaprogramming)环境。
JSR 269用Annotation Processor在编译期间而不是运行期间处理Annotation，Annotation Processor相当于编译器的一个插件，所以称为插入式注解处理.如果Annotation Processor处理Annotation时(执行process方法)产生了新的Java代码，编译器会再调用一次Annotation Processor，如果第二次处理还有新代码产生，就会接着调用Annotation Processor，直到没有新代码产生为止.每执行一次process()方法被称为一个"round"，这样整个Annotation processing过程可以看作是一个round的序列。
JSR 269主要被设计成为针对Tools或者容器的API. 举个例子，我们想建立一套基于Annotation的单元测试框架(如TestNG)，在测试类里面用Annotation来标识测试期间需要执行的测试方法。
七：用Console开发控制台程序
JDK1.6中提供了java.io.Console 类专用来访问基于字符的控制台设备。你的程序如果要与Windows下的cmd或者Linux下的Terminal交互，就可以用Console类代劳。但我们不总是能得到可用的Console，一个JVM是否有可用的Console依赖于底层平台和JVM如何被调用。如果JVM是在交互式命令行(比如Windows的cmd)中启动的，并且输入输出没有重定向到另外的地方，那么就可以得到一个可用的Console实例。
八：对脚本语言的支持
如： ruby，groovy，javascript。
九：Common Annotations
Common annotations原本是Java EE 5.0(JSR 244)规范的一部分，现在SUN把它的一部分放到了Java SE 6.0中。
随着Annotation元数据功能(JSR 175)加入到Java SE 5.0里面，很多Java 技术(比如EJB，Web Services)都会用Annotation部分代替XML文件来配置运行参数（或者说是支持声明式编程，如EJB的声明式事务），如果这些技术为通用目的都单独定义了自己的Annotations，显然有点重复建设，所以，为其他相关的Java技术定义一套公共的Annotation是有价值的，可以避免重复建设的同时，也保证Java SE和Java EE 各种技术的一致性。
下面列举出Common Annotations 1.0里面的10个Annotations Common Annotations Annotation Retention Target Description Generated Source ANNOTATION_TYPE，CONSTRUCTOR，FIELD，LOCAL_VARIABLE，METHOD，PACKAGE，PARAMETER，TYPE 用于标注生成的源代码Resource Runtime TYPE，METHOD，FIELD用于标注所依赖的资源，容器据此注入外部资源依赖，有基于字段的注入和基于setter方法的注入两种方式 Resources Runtime TYPE同时标注多个外部依赖，容器会把所有这些外部依赖注入PostConstruct Runtime METHOD标注当容器注入所有依赖之后运行的方法，用来进行依赖注入后的初始化工作，只有一个方法可以标注为PostConstruct PreDestroy Runtime METHOD当对象实例将要被从容器当中删掉之前，要执行的回调方法要标注为PreDestroy RunAs Runtime TYPE用于标注用什么安全角色来执行被标注类的方法，这个安全角色必须和Container的Security角色一致的。RolesAllowed Runtime TYPE，METHOD用于标注允许执行被标注类或方法的安全角色，这个安全角色必须和Container的Security角色一致的 PermitAll Runtime TYPE，METHOD允许所有角色执行被标注的类或方法DenyAll Runtime TYPE，METHOD不允许任何角色执行被标注的类或方法，表明该类或方法不能在Java EE容器里面运行DeclareRoles Runtime TYPE用来定义可以被应用程序检验的安全角色，通常用isUserInRole来检验安全角色。
注意：
1.RolesAllowed，PermitAll，DenyAll不能同时应用到一个类或方法上
2.标注在方法上的RolesAllowed，PermitAll，DenyAll会覆盖标注在类上的RolesAllowed，PermitAll，DenyAll
3.RunAs，RolesAllowed，PermitAll，DenyAll和DeclareRoles还没有加到Java SE 6.0上来
4. 处理以上Annotations的工作是由Java EE容器来做，Java SE 6.0只是包含了上面表格的前五种Annotations的定义类，并没有包含处理这些Annotations的引擎，这个工作可以由Pluggable Annotation Processing API(JSR 269)来做
