java五、java六、java七、java8的新特性

时间 2019-11-19

标签 java java8 特性栏目 Java 繁體版

原文原文链接

Java5:

一、泛型 Generics:

引用泛型以后，容许指定集合里元素的类型，免去了强制类型转换，而且能在编译时刻进行类型检查的好处。javascript

Parameterized Type做为参数和返回值，Generic是vararg、annotation、enumeration、collection的基石。html

A、类型安全java

抛弃List、Map，使用List<T>、Map<K,V>给它们添加元素或者使用Iterator<T>遍历时，编译期就能够给你检查出类型错误git

B、方法参数和返回值加上了Type程序员

抛弃List、Map，使用List<T>、Map<K,V>数据库

C、不须要类型转换编程

    List<String> list=new ArrayList<String>();

    String str=list.get(i);

D、类型通配符“?”c#

假设一个打印List<T>中元素的方法printList,咱们但愿任何类型T的List<T>均可以被打印：windows

代码：api

public void printList(List<?> list,PrintStream out)throws IOException{  
  for(Iterator<?> i=list.iterator();i.hasNext();){  
    System.out.println(i.next.toString());  
  } 
}

若是通配符？让咱们的参数类型过于普遍，咱们能够把List<?>、Iterator<?> 修改成

List<? Extends Number>、Iterator<? Extends Number>限制一下它。

二、枚举类型 Enumeration:

三、自动装箱拆箱（自动类型包装和解包）autoboxing & unboxing:

简单的说是类型自动转换。

自动装包：基本类型自动转为包装类（int ——Integer）

自动拆包：包装类自动转为基本类型（Integer——int）

四、可变参数varargs(varargs number of arguments)

参数类型相同时，把重载函数合并到一块儿了。如：

public void test(object... objs){
  for(Object obj:objs){
    System.out.println(obj);
  }
}

五、Annotations 它是Java中的metadata（注释）

A、Tiger中预约义的三种标准annotation

a 、Override

指出某个method覆盖了superclass 的method当你要覆盖的方法名拼写错时编译不经过

b、Deprecated

指出某个method或element类型的使用是被阻止的，子类将不能覆盖该方法

c、SupressWarnings

关闭class、method、field、variable 初始化的编译期警告，好比：List没有使用 Generic,则@SuppressWarnings("unchecked")去掉编译期警告。

B、自定义annotation

public @interface Marked{}

C、meta-annotation

或者说annotation的annotation

         四种标准的meta-annotation所有定义在java.lang.annotaion包中:
            a, Target
            指定所定义的annotation能够用在哪些程序单元上
           若是Target没有指定，则表示该annotation可使用在任意程序单元上
      代码

@Retention(RetentionPolicy.RUNTIME)    
@Target({ ElementType.FIELD, ElementType.METHOD })    
public @interface RejectEmpty {    
   /** hint title used in error message */    
  String value() default "";    
}    
   
@Retention(RetentionPolicy.RUNTIME)    
@Target( { ElementType.FIELD, ElementType.METHOD })    
public @interface AcceptInt {    
  int min() default Integer.MIN_VALUE;    
  int max() default Integer.MAX_VALUE;    
  String hint() default "";    
}

            b, Retention
            指出Java编译期如何对待annotation
            annotation能够被编译期丢掉，或者保留在编译过的class文件中
            在annotation被保留时，它也指定是否会在JVM加载class时读取该annotation
代码

@Retention(RetentionPolicy.SOURCE)  // Annotation会被编译期丢弃    
public @interface TODO1 {}    

@Retention(RetentionPolicy.CLASS)   // Annotation保留在class文件中，但会被JVM忽略    
public @interface TODO2 {}    

@Retention(RetentionPolicy.RUNTIME) // Annotation保留在class文件中且会被JVM读取    
public @interface TODO3 {}

            c, Documented
            指出被定义的annotation被视为所熟悉的程序单元的公开API之一
            被@Documented标注的annotation会在javadoc中显示，这在annotation对它标注的元素被客户端使用时有影响时起做用
            d, Inherited
           该meta-annotation应用于目标为class的annotation类型上，被此annotattion标注的class会自动继承父类的annotation
        D, Annotation的反射
    咱们发现java.lang.Class有许多与Annotation的反射相关的方法，如getAnnotations、isAnnotationpresent
        咱们能够利用Annotation反射来作许多事情，好比自定义Annotation来作Model对象验证
代码

@Retention(RetentionPolicy.RUNTIME)    
@Target({ ElementType.FIELD, ElementType.METHOD })    
public @interface RejectEmpty {    
   /** hint title used in error message */    
   String value() default "";    
}    
     
@Retention(RetentionPolicy.RUNTIME)    
@Target( { ElementType.FIELD, ElementType.METHOD })    
public @interface AcceptInt {    
   int min() default Integer.MIN_VALUE;    
   int max() default Integer.MAX_VALUE;    
   String hint() default "";    
}

使用@RejectEmpty和@AcceptInt标注咱们的Model的field，而后利用反射来作Model验证

六、新的迭代语句（for(int n:numbers)）

七、静态导入（import static）

八、新的格式化方法（java.util.Formatter）

formatter.format("Remaining account balance: $%.2f", balance);

九、新的线程模型和并发库Thread Framework

HashMap的替代者ConcurrentHashMap和ArrayList的替代者CopyOnWriteArrayList
在大并发量读取时采用java.util.concurrent包里的一些类会让你们满意BlockingQueue、Callable、Executor、Semaphore...

Java6:

1.Desktop类和SystemTray类

在JDK6中 ,AWT新增长了两个类:Desktop和SystemTray。

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

2.使用JAXB2来实现对象与XML之间的映射（对WebService支持的加强（JAX-WS2.0和JAXB2.0））

JAXB是Java Architecture for XML Binding的缩写，能够将一个Java对象转变成为XML格式，反之亦然。

咱们把对象与关系数据库之间的映射称为ORM, 其实也能够把对象与XML之间的映射称为OXM(Object XML Mapping). 原来JAXB是Java EE的一部分，在JDK6中，SUN将其放到了Java SE中，这也是SUN的一向作法。JDK6中自带的这个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)是JDK6.0中除了DOM和SAX以外的又一种处理XML文档的API。

StAX 的来历：在JAXP1.3(JSR 206)有两种处理XML文档的方法:DOM(Document Object Model)和SAX(Simple API for XML).

由于JDK6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR 224)都会用到StAX因此Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版本). JDK6里面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

如今我们能够用JDK6 的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

JDK6 提供了一个简单的Http Server API,据此咱们能够构建本身的嵌入式Http Server,它支持Http和Https协议,提供了HTTP1.1的部分实现，没有被实现的那部分能够经过扩展已有的Http Server API来实现,程序员必须本身实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,在这里,咱们把一个Http请求和它的响应称为一个交换,包装成HttpExchange类,HttpServer负责将HttpExchange传给 HttpHandler实现类的回调方法.

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

7.用Console开发控制台程序

JDK6 中提供了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的声明式事务）, 若是这些技术为通用目的都单独定义了本身的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)来作

10.UI的加强

改动的地方最大的就是java GUI界面的显示了，JDK6.0（也就是JDK1.6）支持最新的windows vista系统的Windows Aero视窗效果，而JDK1.5不支持！！！

你要在vista环境下编程的话最好装jdk6.0，不然它老是换到windows basic视窗效果.

11.一系列新的安全相关的加强

12.JDBC4.0

Java7:

1，switch中可使用字串了

String s = "test";   
switch (s) {   
case "test" :   
  System.out.println("test");   
case "test1" :   
  System.out.println("test1");   
break ;   
  default :   
  System.out.println("break");   
break ;   
}

2.运用List<String> tempList = new ArrayList<>(); 即泛型实例化类型自动推断

3.语法上支持集合，而不必定是数组

final List<Integer> piDigits = [ 1,2,3,4,5,8 ];

4.新增一些取环境信息的工具方法

File System.getJavaIoTempDir() // IO临时文件夹  
File System.getJavaHomeDir() // JRE的安装目录  
File System.getUserHomeDir() // 当前用户目录  
File System.getUserDir() // 启动java进程时所在的目录5

5.Boolean类型反转，空指针安全,参与位运算

Boolean Booleans.negate(Boolean booleanObj)  
True => False , False => True, Null => Null  
boolean Booleans.and(boolean[] array)  
boolean Booleans.or(boolean[] array)  
boolean Booleans.xor(boolean[] array)  
boolean Booleans.and(Boolean[] array)  
boolean Booleans.or(Boolean[] array)  
boolean Booleans.xor(Boolean[] array)

6.两个char间的equals
boolean Character.equalsIgnoreCase(char ch1, char ch2)

7.安全的加减乘除

int Math.safeToInt(long value)  
int Math.safeNegate(int value)  
long Math.safeSubtract(long value1, int value2)  
long Math.safeSubtract(long value1, long value2)  
int Math.safeMultiply(int value1, int value2)  
long Math.safeMultiply(long value1, int value2)  
long Math.safeMultiply(long value1, long value2)  
long Math.safeNegate(long value)  
int Math.safeAdd(int value1, int value2)  
long Math.safeAdd(long value1, int value2)  
long Math.safeAdd(long value1, long value2)  
int Math.safeSubtract(int value1, int value2)

8.map集合支持并发请求，且能够写成 Map map = {name:"xxx",age:18};

9.自定义自动关闭类

如下是jdk7 api中的接口，（不过注释太长，删掉了close()方法的一部分注释）

/**
 * A resource that must be closed when it is no longer needed.
 *
 * @author Josh Bloch
 * @since 1.7
 */
public interface AutoCloseable {
    /**
     * Closes this resource, relinquishing any underlying resources.
     * This method is invoked automatically on objects managed by the
     * {@code try}-with-resources statement.
     *
     */
    void close() throws Exception;
}

只要实现该接口，在该类对象销毁时自动调用close方法，你能够在close方法关闭你想关闭的资源，例子以下

class TryClose implements AutoCloseable {

 @Override
 public void close() throw Exception {
  System.out.println(" Custom close method …
                                         close resources ");
 }
}
//请看jdk自带类BufferedReader如何实现close方法（固然还有不少相似类型的类）

  public void close() throws IOException {
        synchronized (lock) {
            if (in == null)
                return;
            in.close();
            in = null;
            cb = null;
        }
    }

10.数值可加下划线

例如：int one_million = 1_000_000;

11.支持二进制文字

例如：int binary = 0b1001_1001;

12.简化了可变参数方法的调用

当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操做”的警告。

13.在try catch异常扑捉中，一个catch能够写多个异常类型，用"|"隔开，

jdk7以前：

try {
   ......
} catch(ClassNotFoundException ex) {
   ex.printStackTrace();
} catch(SQLException ex) {
   ex.printStackTrace();
}

jdk7例子以下

try {
   ......
} catch(ClassNotFoundException|SQLException ex) {
   ex.printStackTrace();
}

14.无需finally中关闭资源

jdk7以前，你必须用try{}finally{}在try内使用资源，在finally中关闭资源，无论try中的代码是否正常退出或者异常退出。jdk7以后，你能够没必要要写finally语句来关闭资源，只要你在try()的括号内部定义要使用的资源。请看例子：

jdk7以前

import java.io.*;
// Copy from one file to another file character by character.
// Pre-JDK 7 requires you to close the resources using a finally block.
public class FileCopyPreJDK7 {
   public static void main(String[] args) {
      BufferedReader in = null;
      BufferedWriter out = null;
      try {
         in  = new BufferedReader(new FileReader("in.txt"));
         out = new BufferedWriter(new FileWriter("out.txt"));
         int charRead;
         while ((charRead = in.read()) != -1) {
            System.out.printf("%c ", (char)charRead);
            out.write(charRead);
         }
      } catch (IOException ex) {
         ex.printStackTrace();
      } finally {            // always close the streams
         try {
            if (in != null) in.close();
            if (out != null) out.close();
         } catch (IOException ex) {
            ex.printStackTrace();
         }
      }
 
      try {
         in.read();   // Trigger IOException: Stream closed
      } catch (IOException ex) {
         ex.printStackTrace();
      }
   }
}

jdk7以后

import java.io.*;
// Copy from one file to another file character by character.
// JDK 7 has a try-with-resources statement, which ensures that
// each resource opened in try() is closed at the end of the statement.
public class FileCopyJDK7 {
   public static void main(String[] args) {
      try (BufferedReader in  = new BufferedReader(new FileReader("in.txt"));
           BufferedWriter out = new BufferedWriter(new FileWriter("out.txt"))) {
         int charRead;
         while ((charRead = in.read()) != -1) {
            System.out.printf("%c ", (char)charRead);
            out.write(charRead);
         }
      } catch (IOException ex) {
         ex.printStackTrace();
      }
   }
}

JAVA8：

java8的新特新逐一列出，并将使用简单的代码示例来指导你如何使用默认接口方法，lambda表达式，方法引用以及多重Annotation，以后你将会学到最新的API上的改进，好比流，函数式接口，Map以及全新的日期API

1、接口的默认方法

Java 8容许咱们给接口添加一个非抽象的方法实现，只须要使用 default关键字便可，这个特征又叫作扩展方法，示例以下：

interface Formula {  
    double calculate(int a);    
    default double sqrt(int a) {  
       return Math.sqrt(a);  
    }  
}

Formula接口在拥有calculate方法以外同时还定义了sqrt方法，实现了Formula接口的子类只须要实现一个calculate方法，默认方法sqrt将在子类上能够直接使用。

Formula formula = new Formula() {  
    @Override  
    public double calculate(int a) {  
        return sqrt(a * 100);  
    }  
};    
formula.calculate(100);     // 100.0  
formula.sqrt(16);           // 4.0

文中的formula被实现为一个匿名类的实例，该代码很是容易理解，6行代码实现了计算 sqrt(a * 100)。在下一节中，咱们将会看到实现单方法接口的更简单的作法。译者注：在Java中只有单继承，若是要让一个类赋予新的特性，一般是使用接口来实现，在C++中支持多继承，容许一个子类同时具备多个父类的接口与功能，在其余语言中，让一个类同时具备其余的可复用代码的方法叫作mixin。新的Java 8 的这个特新在编译器实现的角度上来讲更加接近Scala的trait。在C#中也有名为扩展方法的概念，容许给已存在的类型扩展方法，和Java 8的这个在语义上有差异。

2、Lambda 表达式

首先看看在老版本的Java中是如何排列字符串的：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");    
 Collections.sort(names, new Comparator<String>() {  
    @Override  
    public int compare(String a, String b) {  
        return b.compareTo(a);  
    }  
});

只须要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。一般作法都是建立一个匿名的比较器对象而后将其传递给sort方法。在Java 8 中你就不必使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：

Collections.sort(names, (String a, String b) -> {  
    return b.compareTo(a);  
});

看到了吧，代码变得更段且更具备可读性，可是实际上还能够写得更短：

Collections.sort(names, (String a, String b) -> b.compareTo(a));

对于函数体只有一行代码的，你能够去掉大括号{}以及return关键字，可是你还能够写得更短点：

Collections.sort(names, (a, b) -> b.compareTo(a));

Java编译器能够自动推导出参数类型，因此你能够不用再写一次类型。接下来咱们看看lambda表达式还能做出什么更方便的东西来：

3、函数式接口

Lambda表达式是如何在java的类型系统中表示的呢？每个lambda表达式都对应一个类型，一般是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每个该类型的lambda表达式都会被匹配到这个抽象方法。由于默认方法不算抽象方法，因此你也能够给你的函数式接口添加默认方法。

咱们能够将lambda表达式看成任意只包含一个抽象方法的接口类型，确保你的接口必定达到这个要求，你只须要给你的接口添加 @FunctionalInterface 注解，编译器若是发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

@FunctionalInterface  
interface Converter<F, T> {  
    T convert(F from);  
}  
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);  
Integer converted = converter.convert("123");  
System.out.println(converted);    // 123

须要注意若是@FunctionalInterface若是没有指定，上面的代码也是对的。

译者注将lambda表达式映射到一个单方法的接口上，这种作法在Java 8以前就有别的语言实现，好比Rhino JavaScript解释器，若是一个函数参数接收一个单方法的接口而你传递的是一个function，Rhino 解释器会自动作一个单接口的实例到function的适配器，典型的应用场景有 org.w3c.dom.events.EventTarget 的addEventListener 第二个参数 EventListener。

4、方法与构造函数引用

前一节中的代码还能够经过静态方法引用来表示：

Converter<String, Integer> converter = Integer::valueOf;  
Integer converted = converter.convert("123");  
System.out.println(converted);   // 123

Java 8 容许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展现了如何引用一个静态方法，咱们也能够引用一个对象的方法：

converter = something::startsWith;  
String converted = converter.convert("Java");  
System.out.println(converted);    // "J"

接下来看看构造函数是如何使用::关键字来引用的，首先咱们定义一个包含多个构造函数的简单类：