JDK1.5 JDK1.6 JDK1.7新特性总结分析

jdk1.5新特性
       1.泛型                                     2.foreach                           3.自动拆箱装箱                       4.枚举
        5.静态导入（Static import）      6.元数据（Metadata）           7.线程池                                 8.Java Generics 

下面详细讨论每个新特性： 
1、泛型（Generics） 

　　 泛型是JDK1.5中一个最“酷”的特征。引入泛型，我们将获得编译时类型的安全和运行时更小地抛出 ClassCastExceptions的可能。

      JDK1.5中，你可以声明一个集合将接收/返回的对象的类型。

      JDK1.4中，创建雇员名字的清单 （List）需要一个集合对象，像下面的语句： 

　      　List   listOfEmployeeName = new ArrayList(); 
　　在JDK1.5中，你将使用下面语句 
　       　List < String >   listOfEmployeeName = new   ArrayList < String > (); 
　　 最“酷”的是，若你试图插入非string类型的值，你将在编译时发现并且修正这类问题。没有泛型，你会发现这样一个bug，当你的客户调用后会告       诉你，你所编写的程序抛出ClassCastException异常而崩溃。 
　　             另外，当你从集合中得到一个元素时你无需进行强制转换。故原先为： 
　　            String employeeName = ((String) listOfEmployee.get(i)); 
　　而下面的语句将比上面的更加简单： 
　　             String employeeName = listOfEmployee.get(i); 
　　不清楚对象的类型而强制转换对象是不合理的，且更重要的是，它将在运行时失败。假使用户无意间传入一个包含string buffers类型而非string类型的集合，那结果会怎样呢。在Listing A中，客户被要求传入一个编译器无法强制的strings类型集合。Listing B中显示了同样的方法使用泛型是如何实现的。 
　　Listing A 
　　static  boolean   checkName(Collection employeeNameList, String name) { 
　　        for (Iteratori = employeeNamList.iterator(); i.hasNext(); ) { 
　　                 String s = (String) i.next(); 
　　                if(s.equals(name)){ 
　　                      return true; 
　　                     //print employee name here ...... 
　　                 } 
　　        } 
　　   return  false; 
　　} 
　　Listing B 
　　static   boolean    checkName(Collection employeeNameList, String name) { 
　　       for (Iteratori = employeeNamList.iterator(); i.hasNext(); ) { 
　　              if(i.next().equals(name)){ 
　　                   return    true; 
　　                   //print employee name here ...... 
　　               } 
　　          } 
　　   return   false; 
　　} 
　　现在，通过方法签名可以清楚知道输入集合必须只能包含strings。如果客户试图传入一个包含string buffers的集合，程序将不会编译。同时注意，该方法不包含任何强制转换。它只需要短短一行，一旦你习惯泛型后，它也更加清晰。 

2、在JDK当前版本下的For循环语法如下： 

　　void   printAll(Collection c) { 
         　for (Iteratori = c.iterator(); i.hasNext(); ) { 
　　                Employee emp = (Employee)i.next(); 
　                　System.out.println(emp.getName()); 
　　        } 
　　} 
     现在，用增强的For语句实现相同方法： 

　　void    printAll(Collection c) { 
           for (Object   o :  c) 
           　System.out.println((TimerTask)o).getName()); 
　　} 
   　在这类For循环中，你应该将":"看成"in"，所以，在该例中可以看成"for Object o in c"。你可以发现这种For循环更具可读性。 

3、自动置入/自动取出（Autoboxing/unboxing） 
       Java有基本数据类型，在这些基本数据类型周围又有包装类。通常，编程人员需要将一种类型转换成另一种。看看Listing C.中的代码片断。 
Listing C  
　　 public class Employee { 
　　        private static  final  Integer  CHILD = new Integer(0); 
　　             public static void main(String args[]) { 
　　              //code for adding n to an Integer 
　　             int   n=10; 
　　             Integer age= new Integer(30); 
　            　Integer ageAfterTenYear= new Integer(age.intValue +10); 
　　      } 
　　} 
　　请注意，用于计算ageAfterTenYear的内循环代码看上去是多么杂乱。现在，在Listing D.中看看相同的程序使用autoboxing重写后的样子。 

　　Listing D 

　　public class Employee { 
           　public static void main(String args[]) { 
　　        int  n=10; 
          　Integer  age= new Integer(30); 
          　Integer  ageAfterTenYear= age +10; 
　     　} 
　　} 
　　值得注意的是：先前，若你取出（unbox）Null值，它将变为0。在次代码中，编译器将自动转换Integer为int然后加上10后将其转换回Integer 

4、类型安全的枚举（Typesafeenums） 
          类型安全枚举提供下列特性： 
　　他们提供编译时类型安全。 
　　他们都是对象，因此你不需要将他们放入集合中。 
　　他们作为一种类的实现，因此你可以添加一些方法。 
　　他们为枚举类型提供了合适的命名空间。 
　　他们打印的值具有情报性（informative）― 如果你打印一个整数枚举（intenum），你只是看见一个数字，它可能并不具有情报性。 
　　例一： 
　     　enum  Season { winter, spring, summer, fall } 
　　例二： 
　　   public  enum   Coin { 
　　             penny(1), nickel(5), dime(10), quarter(25); 

　　             Coin(int value) { this.value = value; }  

　　             private final  int  value; 
                   public   int  value() { return value; } 
　　   } 
5、静态导入（Static import） 
　　静态导入使代码更易读。通常，你要使用定义在另一个类中的常量（constants），像这样： 
    　import   org.yyy.pkg.Increment; 
　　        class Employee { 
　　              public Double calculateSalary(Double salary{ 
　                       　return salary + Increment.INCREMENT * salary; 
                　  } 
          　 } 
　　当时使用静态导入，我们无需为常量名前缀类名就能使用这些常量，像这样： 
　　import   static   org.yyy.pkg.Increment; 
            class Employee { 
           　　public   Double calculateSalary(Double salary{ 
                            return salary + INCREMENT * salary; 
　　           } 
　　      } 
　　注意，我们可以调用INCREMENT这一常量而不要使用类名Increment.。 
6、元数据（Metadata） 
　　元数据特征志于使开发者们借助厂商提供的工具可以进行更简易的开发。看一看Listing E.中的代码。 
　Listing E 
　　import    org.yyy.hr; 
　　public   interface   EmployeeI   extends   Java.rmi.Remote {  
　　        public  String   getName()  throwsJava.rmi.RemoteException; 
           　public  String   getLocation ()  throwsJava.rmi.RemoteException; 
　　} 

　　public class  EmployeeImpl  implements  EmployeeI { 
        　   public    String getName(){ 
　　         } 
              public String getLocation (){ 
　         　} 
　　}  
　　通过元数据的支持，你可以改写Listing E中的代码为： 
  　 import    org.yyy.hr; 
　　public class Employee { 
　　        @Remote public String getName() { 
　            　... 
　　         } 
　　       @Remote public public String getLocation() { 
　            　...
　　         } 
　　} 
7线程池
Java5中，对Java线程的类库做了大量扩展，其中 线程池 就是Java5的新特征之一，除了线程池之外，还有很多多线程相关内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。

有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类，熟悉这部分API特征是一项艰难的学习过程。目前有关这方面的资料和书籍都少之又少，大所属介绍线程方面书籍还停留在java5之前的知识层面上。当然新特征对做多线程程序没有必须的关系，在java5之前通用可以写出很优秀的多线程程序。只是代价不一样而已。

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由 池管理器 来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需按照提供的API来使用，即可享受线程池带来的极大便利。

Java5的线程池分好多种：固定尺寸的线程池、可变尺寸连接池、。

在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。
一、固定大小的线程池
import java.util.concurrent.Executors ; 
import java.util.concurrent.ExecutorService ; 
/** 
* Java线程：线程池
*/ 
public class Test { 
        public static void main(String[] args) { 
                //创建一个可重用固定线程数的线程池 
                ExecutorService  pool = Executors.newFixedThreadPool(2); 
                //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 
                Thread   t1 = new  MyThread(); 
                Thread   t2 = new  MyThread(); 
                Thread   t3 = new  MyThread(); 
                Thread   t4 = new  MyThread(); 
                Thread   t5 = new  MyThread(); 
                //将线程放入池中进行执行 
                     pool.execute(t1); 
                     pool.execute(t2); 
                     pool.execute(t3); 
                     pool.execute(t4); 
                     pool.execute(t5); 
                //关闭线程池 
                pool.shutdown(); 
        } 
} 
class MyThread extends Thread{ 
        @Override 
        public void run() { 
                System.out.println(Thread.currentThread().getName()+"正在执行。。。"); 
        } 
}

pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 

Process finished with exit code 0

二、单任务线程池

在上例的基础上改一行创建pool对象的代码为：
                //创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 
                ExecutorService pool = Executors.newSingleThreadExecutor(); 

输出结果为：
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 

Process finished with exit code 0

对于以上两种连接池，大小都是固定的，当要加入的池的线程（或者任务）超过池最大尺寸时候，则入此线程池需要排队等待。
一旦池中有线程完毕，则排队等待的某个线程会入池执行。

三、可变尺寸的线程池

与上面的类似，只是改动下pool的创建方式：
                //创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。 
                ExecutorService pool = Executors.newCachedThreadPool(); 

pool-1-thread-5正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-4正在执行。。。 
pool-1-thread-3正在执行。。。 
pool-1-thread-2正在执行。。。 

Process finished with exit code 0

四、延迟连接池
import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.TimeUnit; 
/** 

* Java线程：线程池

*/ 

public  class  Test { 
        public  static  void  main(String[] args) { 
                //创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。 
                ScheduledExecutorService pool = Executors.newScheduledThreadPool(2); 
                //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 
                Thread   t1 = new   MyThread(); 
                Thread   t2 = new   MyThread(); 
                Thread   t3 = new   MyThread(); 
                Thread   t4 = new   MyThread(); 
                Thread   t5 = new   MyThread(); 
                //将线程放入池中进行执行 
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                //使用延迟执行风格的方法 
                pool.schedule(t4, 10, TimeUnit.MILLISECONDS); 
                pool.schedule(t5, 10, TimeUnit.MILLISECONDS); 
                //关闭线程池 
                pool.shutdown(); 
        } 
} 
class MyThread extends Thread { 
        @Override 
        public void run() { 
                System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 
        } 
}
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 

Process finished with exit code 0

五、单任务延迟连接池

在四代码基础上，做改动
                //创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。 
                ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 

Process finished with exit code 0 
六、自定义线程池

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.BlockingQueue; 
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 
/** 
* Java线程：线程池-自定义线程池 
*/ 
public class Test { 
        public static void main(String[] args) { 
                //创建等待队列 
                BlockingQueue bqueue = new ArrayBlockingQueue(20); 
                //创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。 
                ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue); 
                //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 
                Thread    t1 = new   MyThread(); 
                Thread    t2 = new   MyThread(); 
                Thread    t3 = new   MyThread(); 
                Thread    t4 = new   MyThread(); 
                Thread    t5 = new   MyThread(); 
                Thread    t6 = new   MyThread(); 
                Thread    t7 = new   MyThread(); 
                //将线程放入池中进行执行 
                   pool.execute(t1); 
                   pool.execute(t2); 
                   pool.execute(t3); 
                   pool.execute(t4); 
                   pool.execute(t5); 
                   pool.execute(t6); 
                   pool.execute(t7); 
                //关闭线程池 
                pool.shutdown(); 
        } 
} 
class MyThread extends Thread { 
        @Override 
        public void run() { 
                System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 
                try { 
                        Thread.sleep(100L); 
                } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                } 
        } 
}
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 

Process finished with exit code 0

创建自定义线程池的构造方法很多，本例中参数的含义如下：
ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue)
用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。
参数：
corePoolSize - 池中所保存的线程数，包括空闲线程。
maximumPoolSize - 池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
抛出：
IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于零，或者 maximumPoolSize 小于或等于零，或者 corePoolSize 大于 maximumPoolSize。
NullPointerException - 如果 workQueue 为 null

自定义连接池稍麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。

8.Java Generics 

在JDK1.5之前的版本中，对于一个Collection类库中的容器类实例，可将任意类型 
对象加入其中（都被当作Object实例看待）；从容器中取出的对象也只是一个Object实例，需要将其强制转型为期待的类型，这种强制转型的运行时正确性由程序员自行保证。 

例如以下代码片断： 

List intList = new ArrayList(); //创建一个List，准备存放一些Integer实例 
      intList.add(new Integer(0)); 
      intList.add(“1”); //不小心加入了一个字符串；但在编译和运行时都不报错，只有仔细的代码走 才能揪出 
Integer  i0 = (Integer)intList.get(0); 
Integer  i1 = (Integer)intList.get(1); //编译通过，直到运行时才抛ClassCastException 

而在JDK1.5中，可以创建一个明确只能存放某种特定类型对象的容器类实例，例如如下代码： 
     List intList = new ArrayList(); //intList为存放Integer实例的List 
                         intList.add(new Integer(0)); 
            Integer i0 = intList.get(0); //无需(Integer)强制转型；List的get()返回的就是Integer类 型对象 
                         intList.add(“1”); //编译不通过，因为List的add()方法只接受Integer类型的参数 

“List intList = new ArrayList();”就是最简单且最常用的Generic应用；显然，运用Generic后的代码更具可读性和健壮性。 

2         Generic类 
JDK1.5中Collection类库的大部分类都被改进为Generic类。以下是从JDK1.5源码中 

截取的关于List和Iterator接口定义的代码片断： 
public interface List { 
       void add(E x); 
       Iterator iterator; 
} 
public interface Iterator { 
       E next(); 
       boolean hasNext(); 
} 

以List为例，“public interface List”中的E是List的类型参数，用户在使用List时可为类型参数指定一个确定类型值（如List）。

   类型值为Java编译器所用，确保用户代码类型安全。例如，编 译器知道List的add()方法只接受Integer类型的参数，因此如果你在代码中将一个字符串传入add()将导致 编译错误；

    编译器知道Iterator的next()方法返回一个Integer的实例，你在代码中也就无需对返回结果进 行(Integer)强制转型。

    代码检验通过（语法正确且不会导致运行时类型安全问题）后，编译器对现有代码有一个转换工作。简单的说，就是去除代码中的 类型值信息，在必要处添加转型代码。例如如下代码： 

public   String   demo() { 
       List strList = new ArrayList(); 
                          strList.add(“Hello!”); 
                  return   strList.get(0); 
} 
编译器在检验通过后，将其转换为： 
public   String   demo() { 
       List   strList = new  ArrayList(); //去除类型值 
               strList.add(“Hello!”); 
      return    (String)strList.get(0);  //添加转型动作代码(String) 
} 

    可见，类型值信息只为Java编译器在编译时所用，确保代码无类型安全问题；验证通过之后，即被去除。

    对于JVM而言，只有如JDK1.5之前版本一样的 List，并无List和List之分。这也就是Java Generics实现中关键技术Erasure的基本思想。以下代码在控制台输出的就是“true”。 

              List      strList = new ArrayList(); 
              List     intList = new ArrayList(); 
                 System.out.println(strList.getClass() == intList.getClass()); 

     可以将Generic理解为：为提高Java代码类型安全性（在编译时确保，而非等到运行时才暴露），Java代码与Java编译器之间新增的一种约定规 范。Java编译器在编译结果*.class文件中供JVM读取的部分里没有保留Generic的任何信息；JVM看不到Generic的存在。 

 对于Generic类（设为GenericClass）的类型参数（设为T）： 

1) 由于对于JVM而言，只有一个GenericClass类，所以GenericClass类的静态字段和静态方法的定义中不能使用T。

    T只能出现在 GenericClass的非静态字段或非静态方法中。也即T是与GenericClass的实例相关的信息； 

2)T只在编译时被编译器理解，因此也就不能与运行时被JVM理解并执行其代表的操作的操作符（如instanceof 和new）联用。 

class GenericClass { 
             T   t1; 
          public void    method1(T t){ 
                          t1 = new T(); //编译错误，T不能与new联用 
               if (t1 instanceof T) {}; //编译错误，T不能与instanceof联用 
           }; 
    static   T   t2; //编译错误，静态字段不能使用T 
                public static void method2(T t){};//编译错误，静态方法不能使用T 
} 

      Generic类可以有多个类型参数，且类型参数命名一般为大写单字符。例如Collection类库中的Map声明为： 
               public   interface   Map { 
                          ……; 
      } 

3   Generic类和原（Raw）类 

    对每一个Generic类，用户在使用时可以不指定类型参数。例如，对于List，用户可以以“List list;”方式使用，也可以以“List list;”方式使用。

    “List”被称为参数化的Generic类（类型参数被赋值），而“List”称为原类。原类 List的使用方式和效果与JDK1.5之前版本List的一样；使用原类也就失去了Generic带来的可读性和健壮性的增强。 

       允许原类使用方式的存在显然是为了代码的向前兼容：即JDK1.5之前的代码在JDK1.5下仍然编译通过且正常运行。 
       当你在JDK1.5中使用原类并向原类实例中添加对象时，编译器会产生警告，因为它无法保证待添加对象类型的正确性。编译通过是为了保证代码向前兼容，产生警告是提醒潜在的风险。 

public void test () { 
    List list = new ArrayList(); 
    list.add("tt");//JDK1.5编译器对此行产生警告 
} 

4 Generic类和子类 
List ls = new ArrayList(); 
List