Java 1.5,1.6,1.7,1.8新特性

java1.5新特性

1、自动装箱和拆箱功能

（1）自动装箱和拆箱是由编译器帮助完成从基本数据类型和基本数据类型的包装类之间的转换。 

①基本数据类型：int，long，double，float，boolean，char，byte，short 

②基本数据类型包装类：Integet，Long，Double，Float，Boolean，Character，Byte，Short

（2）自动装箱和拆箱的过程，例如：

//这里编译器是这样编译的Integer i = new Integer(137); 

Integer i = 137; 

//这里的话是i.intValue();变成了int再和1相加 

int x = i +1;

（3）享元模式由小的具体共同属性的对象变成一个对象，例如：Integer 就从-128到127是同一个对象,也就是一个字节 

Integer i1 = 127; 

Integer i2 = 127; 

Integer i3 = 128; 

Integer i4 = 128; 

System.out.println(i1==i2);//此处是相等的 

System.out.println(i4==i3);//此处不相等

2、可变参数

当调用函数的时候不确定要使用多少个参数的时候使用可变参数，可变参数必须放在最后面写入。例如： 

getSome(1,2,3,11,1);

//可变参数..这里接收了5个参数，一个是a的，剩下四个在args这个数组里面

public static void getSome(int a ,Object...args)
{
//以数组的形式存储，方便使用
for(int x=0 ; x<args.length; x++)
System.out.println(args[x]);
}

1
2
3
4
5
6
1
2
3
4
5
6

3、for-each，增强for循环，注：这种for循环只能进行遍历 
for( type 变量名 ：集合变量名 ) {…}

//对int数组进行遍历
int[] arr1 ={1,2,3,4};
for(Integer i : arr1)
System.out.println(i);

1
2
3
4
1
2
3
4

4、枚举，即只能为若干固定中的一个，否则编译器就会报错，枚举可以让编译器在编译时就可以控制源程序中填写非法的值，其关键字为enum

public enum MyEnum{
RED,GREEN,YELLOW
}

1
2
3
1
2
3

5、静态导入 

优点：使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。 

缺点：过度使用会降低代码的可读性

//导入的是Arrays这个类中所有的静态方法
import static java.util.Arrays.*
//当类名重名时，需要指定具体的包名
//当方法重名时，需要指定具体所属的对象或者类

1
2
3
4
1
2
3
4

6、泛型

（1）泛型的出现：集合的存放的数据类型不固定，往集合存放数据的时候就会出现安全隐患。在最初定义集合到时候就想规定这个集合存储一样数据类型，这样就可以解决此类的安全问题。1.5以后出现了泛型，用于解决集合框架的安全问题，让运行时候的ClassCastException异常问题在编译时期就能检测出来，避免了强转的麻烦。 

（2）泛型的格式：通过<>来定义要操作的引用数据类型。例如：

List<String> list = new ArrayList<String>();//声明这个集合只能存储String的数据类型

1
1

（3）泛型的形式：有泛型类，泛型方法，泛型接口。例如

//这里调用的时候指定了Integer，后面的show就不能传递其他类型的数据了

new genericClass<Integer>().show(1);

//这里print方法是接收任何的参数的
new genericClass().print(2);

//这里look方法也是接收任何参数，只是调用不用new对象
genericClass.look(3);

//定义一个泛型类
class genericClass<E>
{
//泛型的方法,必须和指定的类的数据引用是一样的
public void show(E e)
{
System.out.println(e+"这随着类的类型改变而改变");
}

public <T> void print(T t)
{
System.out.println(t+"可以接收任何类型的引用数据类型");
}

public static <W> void look(W w)
{
System.out.println(w+"这个是一个静态的方法，也可以定义泛型接收任何引用数据类型");
}
}

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
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

（4）泛型通配符、向上和向下限定

当定义两种泛型集合，则迭代的时候也要定义两种泛型，这时也可以用通配符？表示。在不知道具体的泛型类型的时候也可以用通配符表示<?>。泛型还可以接收该类的子类或父类。向下限定<？ extends E>即接收该类或子类。向上限定<？ super E>即接收该类或父类。

（5）泛型与原始数据类型兼容性，不支持继承关系。例如：

//和老的版本兼容
List list = new ArrayList<String>();
List<String> list = new ArrayList();

//不支持继续,变量声明能装任何类型但是实际只能装String
List<Object> list = new ArrayList<String>();
//这里就是，只能持有String的引用但是装进来的确实object
List<String> list = new ArrayList<Object>();

例如：定义一个Map对象（采用泛型），加入若干个对象，然后遍历并打印出各元素的key和value
//map对泛型的应用,定义泛型,并添加元素
HashMap<String, Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 10);
map.put("lisi", 12);
map.put("wangwu", 12);

//将map转为set再迭代
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
//增强for遍历集合
for(Entry<String, Integer> entry : entrySet)
{
System.out.println(entry.getKey()+"..."+entry.getValue());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7、线程并发库

线程并发库是Java1.5提出的关于多线程处理的高级功能，所在包：Java.util.concurrent 

包括 

①线程互斥 

工具类描述：Lock，RedWriteLock 

②线程通信 

描述：Condition 

③线程池 

ExecutorService 

④同步队列 

ArrayBlockingQueue 

⑤同步集合 

ConcurrentHashMap，CopyOnWriteArrayList 

⑥线程同步工具 

Semaphore 

Lock代替了Synchrinozed的使用，一个Lock可以设置多个Condition监视器，可以实现灵活的线程间通信。

8、注解 

（1）注解相当于一种标记，加了注解就等于打上了某种标记。以后可以用反射来了解类上面的各种元素上有无任何标记。标记可以加在包，类，字段，方法，和方法的参数，以及局部变量上。 

（2）注解的生命周期：Java源文件（SOURCE）–class文件（CLASS）—内存中的字节码（RUNTIME）

//@Override//重写的注解，生命周期是源文件,编译完就没用了
@Deprecated //过时的注解，生命周期是RUNTIME
@SuppressWarnings("")//废除警告的注解,生命周期是源文件,编译完就没用了
public static void show()
{
System.out.println("I love java");
}

1
2
3
4
5
6
7
1
2
3
4
5
6
7

（3）注解类

//默认生命周期在是Retentionpolicy.class,改变保留这个注解到Runtime生命周期
@Retention(RetentionPolicy.RUNTIME)
//这是元注解指定这注解在什么地方, method 表示可以注解在方法上 ,type是类上等等。。。
@Target({ElementType.METHOD,ElementType.TYPE})

//建立注解类
public @interface AnnotationClass
{
String color() default "defaultColor";//default指定默认值
String value() default "value";//只有一个value可以不用写value=
int a();//这样定义的话a就代表变量可以在注解的时候赋值
int a=11;//这样定义的话a就是一个常量
int[] arr() ;//定义数组
enumeration.TrafficLamp trafficLamp() default enumeration.TrafficLamp.RED;//也可以定义枚举属性
}

//添加注解类并赋值，没有默认值的一定要赋值
@AnnotationClass(color ="red",value="a",arr = {1,1,1},a=1)
public class annotation
{

//1.5的新特性注解
public static void main(String[] args)
{
//判断此类中是否有注解@AnnotationClass在
if(annotation.class.isAnnotationPresent(AnnotationClass.class))
{
//获取这个注解的对象
AnnotationClass atc = (AnnotationClass)annotation.class.getAnnotation(AnnotationClass.class);
//调用注解注解中的属性,并可参与运算
System.out.println(atc.color());
System.out.println(atc.trafficLamp());
System.out.println(atc.a()+1);
System.out.println(atc.a+10);
}
}

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
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

java1.6 新特性

1、在awt中新增Desktop类与SystemTray类

前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档；后者可以用来在系统托盘区创建一个托盘程序.

2、使用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等来实现同样的功能.

3、理解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)都会用到StAXSun决定把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文档映射到一颗内存树,这样就可以很容易地得到父节点和子结点以及兄弟节点的数据,但如果文档很大,将会严重影响性能.

4、使用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提供了更加丰富的方式去做动态编译，而且是跨平台的。

5、轻量级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实现类的回调方法。

6、插入式注解处理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来标识测试期间需要执行的测试方法。

7、用Console开发控制台程序

JDK1.6中提供了java.io.Console 类专用来访问基于字符的控制台设备。你的程序如果要与Windows下的cmd或者Linux下的Terminal交互，就可以用Console类代劳。但我们不总是能得到可用的Console，一个JVM是否有可用的Console依赖于底层平台和JVM如何被调用。如果JVM是在交互式命令行(比如Windows的cmd)中启动的，并且输入输出没有重定向到另外的地方，那么就可以得到一个可用的Console实例。

8、对脚本语言的支持 如：ruby,groovy,JavaScript

9、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的声明式事务），如果这些技术为通用目的都单独定义了自己的otations，显然有点重复建设，所以，为其他相关的Java技术定义一套公共的Annotation是有价值的，可以避免重复建设的同时，也保证Java SE和Java EE 各种技术的一致性。 

　　 下面列举出Common Annotations 1.0里面的10个Annotations Common Annotations Annotation Retention Target Description Generated SourceANNOTATION_TYPE，CONSTRUCTOR，FIELD，LOCAL_VARIABLE，METHOD，PACKAGE，PARAMETER，TYPE 用于标注生成的源代码Resource Runtime TYPE，METHOD，FIELD用于标注所依赖的资源，容器据此注入外部资源依赖，有基于字段的注入和基于setter方法的注入两种方式
Resources Runtime TYPE同时标注多个外部依赖，容器会把所有这些外部依赖注入PostConstructRuntime 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不能同时应用到一个类或方法上标注在方法上的RolesAllowed，PermitAll，DenyAll会覆盖标注在类上的 RolesAllowed，PermitAll，DenyAllRunAs，RolesAllowed，PermitAll，DenyAll和DeclareRoles还没有加到Java SE 6.0上来 处理以上Annotations的工作是由Java EE容器来做，Java SE6.0只是包含了上面表格的前五种Annotations的定义类，并没有包含处理这些Annotations的引擎，这个工作可以由Pluggable
Annotation Processing API(JSR 269)来做。

java 1.7 的新特性

1、二进制面值 

在java7里，整形(byte,short,int,long)类型的值可以用二进制类型来表示了，在使用二进制的值时，需要在前面加上ob或oB，例如：

int a =0b01111_00000_11111_00000_10101_01010_10;
short b = (short)0b01100_00000_11111_0;
byte c = (byte)0B0000_0001;

1
2
3
1
2
3

2、数字变量对下划线的支持 

数值类型的变量里面添加下滑线，但是有几个地方是不能添加的 

①数字的开头和结尾 ②小数点前后 ③F或者L前

例如：
int num = 1234_5678_9;
float num2 = 222_33F;
long num3 = 123_000_111L;

1
2
3
4
1
2
3
4

3、switch支持部分基本数据类型(primitive data types)与枚举类型，如：byte、short、int、long、char；不支持boolean、float、double， 增加对String的支持。

例如：
String status = "orderstate";
switch (status) {
case "ordercancel":
System.out.println("订单取消");
break;
case "orderSuccess":
System.out.println("预订成功");
break;
default:
System.out.println("状态未知");
}

1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

4、try - with - resource 自动资源管理

try-with-resources 是一个定义了一个或多个资源的try 声明，这个资源是指程序处理完它之后需要关闭它的对象。try-with-resources 确保每一个资源在处理完成后都会被关闭。 

可以使用try-with-resources的资源有： 

任何实现了java.lang.AutoCloseable 接口java.io.Closeable 接口的对象。

例如：
public static String readFirstLineFromFile(String path) throws IOException {

try (BufferedReader br = new BufferedReader(new FileReader(path))) {
return br.readLine();
}
}

1
2
3
4
5
6
7
1
2
3
4
5
6
7

在java 7 以及以后的版本里，BufferedReader实现了java.lang.AutoCloseable接口。
由于BufferedReader定义在try-with-resources 声明里，无论try语句正常还是异常的结束，
它都会自动的关掉。而在java7以前，你需要使用finally块来关掉这个对象。

5、捕获多种异常并用改进后的类型检查来重新抛出异常

例如：
public static void first(){
try {
BufferedReader reader = new BufferedReader(new FileReader(""));
Connection con = null;
Statement stmt = con.createStatement();
} catch (IOException | SQLException e) {
//捕获多个异常，e就是final类型的       e.printStackTrace();
}
}
优点：用一个catch处理多个异常，比用多个catch每个处理一个异常生成的字节码要更小更高效。

1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

6、创建泛型时类型推断

只要编译器可以从上下文中推断出类型参数，你就可以用一对空着的尖括号<>来代替泛型参数。这对括号私下被称为菱形(diamond)。 在Java SE 7之前，你声明泛型对象时要这样

List<String> list = new ArrayList<String>();
而在Java SE7以后，你可以这样
List<String> list = new ArrayList<>();
因为编译器可以从前面(List)推断出推断出类型参数，所以后面的ArrayList之后可以不用写泛型参数了，只用一对空着的尖括号就行。当然，你必须带着”菱形”<>，否则会有警告的。
Java SE7 只支持有限的类型推断：只有构造器的参数化类型在上下文中被显著的声明了，你才可以使用类型推断，否则不行。
List<String> list = new ArrayList<>();
list.add("A");
//这个不行
list.addAll(new ArrayList<>());
// 这个可以
List<? extends String> list2 = new ArrayList<>();
list.addAll(list2);

1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

java1.8新特性

Lambdas表达式与Functional接口
接口的默认与静态方法
方法引用
重复注解
更好的类型推测机制
扩展注解的支持