Pythoner

Préfèrez :

la beauté à la laideur,
l’explicite à l’implicite,
le simple au complexe
et le complexe au compliqué,
le déroulé à l’imbriqué,
l’aéré au compact.
Prends en compte la lisibilité.
Les cas particuliers ne le sont jamais assez pour violer les règles.
Mais, à la pureté, privilégie l’aspect pratique.
Ne passe pas les erreurs sous silence,
... ou bâillonne-les explicitement.
Face à l’ambiguïté, à deviner ne te laisse pas aller.
Sache qu’il ne devrait avoir qu’une et une seule façon de procéder,
même si, de prime abord, elle n’est pas évidente, à moins d’être Néerlandais.
Mieux vaut maintenant que jamais.
Cependant jamais est souvent mieux qu’immédiatement.
Si l’implémentation s’explique difficilement, c’est une mauvaise idée.
Si l’implémentation s’explique aisément, c’est peut-être une bonne idée.
Les espaces de nommage ! Sacrée bonne idée ! Faisons plus de trucs comme ça.

Eclipse RCP Technologies and other Technologies related to Eclipse RCP based projects

Eclipse RCP (Rich Client Platform) is a powerful free open-source platform for developing general purpose applications.

Eclipse RCP was chosen because of several goals:
It is based on OSGi principles. This means that we have a good flexibility between different modules. Eclipse RCP projects are based on plug-ins that provide possibility to easily include or exclude any modules. Or for example make two kinds of application –Trial version that contains only the Core functionality and Real version with the full functionality. Eclipse RCP supports a good Updating mechanism of existing projects with new versions.

Eclipse RCP platform already contains many solutions for implementing different tasks in GUI, Text handling etc.

There are many free open-sources Eclipse RCP based projects and plug-ins for many specific technologies and tasks that can be used instead of bootstrapping


Directly in our projects we use the following technologies:
SWT/JFace – for building GUI.
Resources plugin – provides access to file system.
Eclipse Workbench – to have a good organization of different GUI elements.
Eclipse Debug – organization of launching of different kind of scripts.

But also in our projects many specific technologies based on Eclipse were used such as:
uDIG SDK – Eclipse RCP based project for visualization and working with Geo Information Systems (maps, layers etc.). Particularly it was used to show specific user-defined information on maps.
EMF (Eclipse Modeling Framework) – Eclipse RCP module for Modeling. It was used as alternative for structural information storing (e.g. Map contents).
Neoclipse – Eclipse RCP based project for visualization content of Graph Database Neo4j.
RDT (Ruby Development Tool) – Ruby IDE based on Eclipse RCP.
GEF – framework to create different user-specific editors.
AWT-SWT Bridge – was used to create a powerful alternative of Excel – Splash.

Also in Eclipse RCP based projects many specific technologies that are not related to Eclipse RCP were used:
Neo4j Database - is a graph database. It is an embedded, disk-based, fully transactional Java persistence engine that stores data structured in graphs rather than in tables.
jRuby – Java based interpreter of Ruby language. Ruby was used as a scripting language for Splash (analog of Excel) and console. Directly jRuby was used to have access to Java classes.
jTestR – Junit based testing framework for Ruby.
Maven and Tycho maven plugin – automatic building of Eclipse RCP based applications.

Hash tree (tiger tree)在大量文件实时同步中的应用

大型集群系统常需要进行多个服务器的大量文件的内容同步。

传统的文件同步方案有rsync(单向) 和 unison(双向)等，它们需要扫描所有文件后进行比对，差量传输。文件扫描计算摘要是非常耗时的，我用rsync同步maven中央仓库的内容，每次同步都要花至少几十分钟的时间计算本地的文件摘要后，才会开始从远程取新的内容。

在受控的服务器(有权限管理)的环境中，可以通过Hash Tree，就是tiger tree来实现变化文件的同步。 Sun的ZFS，Amazon的Dynamo中都有用到这种结构。

可参考
http://en.wikipedia.org/wiki/Hash_tree

http://blog.daviesliu.net/2008/04/24/sync/

简言之，Hash Tree是将所有数据的摘要信息存储成树状结构，每个节点的Hash是其所有子节点的Hash的Hash，叶子节点的Hash是其内容的Hash。这样一旦某个节点发生变化，其Hash的变化会迅速传播到根节点。需要同步的系统只需要不断查询根节点的hash，一旦有变化，顺着树状结构就能够在logN级别的时间找到发生变化的内容，马上同步。

Linux下可利用2.6内核的新特性inotify来自动感知某个目录内文件发生变化的信息，当应用程序感知到变化时，更新Hash tree的所有父节点。Windows下可使用文件系统的hook来感知文件的变化。

在需要同步时，若发现根目录的Hash值有变化，顺着目录结构往下找即可有变化的文件，再做同步。

原文：http://www.beyondlinux.com/2011/04/03/hash-tree-tiger-tree%E5%9C%A8%E5%A4%A7%E9%87%8F%E6%96%87%E4%BB%B6%E5%AE%9E%E6%97%B6%E5%90%8C%E6%AD%A5%E4%B8%AD%E7%9A%84%E5%BA%94%E7%94%A8/

Speed up your eclipse as a super fast IDE

Follow these steps to speed up your eclipse as a super fast IDE , it works for 32 & 64 bit version eclipse/jdk on my windows 7 x64.

1.Disable antivirus software, or add your jdk & eclipse & workspace & other related folder to white list in your antivirus software.

2.Disable unecessary validations and startup action in eclipse reference.

For validations: on eclipse menu Windows -> Preferences -> Validation, click “Disable All”, and then select the validator which you need. I selected “Classpath Dependency Validator” only.

For startup action: on eclipse menu Windows -> Preferences, type “startup”, select “Startup and Shutdown”, untick the options you don’t need. (Thanks for David’s suggest,  I’ve added the above 2 detail steps for readers)

3.Modify eclipse.ini to set the Xmn(new generation size), Xms and Xmx, enable parallel GC
-vm
C:/jdk1.6.0_25/bin
-startup
plugins/org.eclipse.equinox.launcher_1.2.0.v20110502.jar
–launcher.library
plugins/org.eclipse.equinox.launcher.win32.win32.x86_64_1.1.100.v20110502
-product
org.eclipse.epp.package.jee.product
–launcher.defaultAction
openFile
–launcher.XXMaxPermSize
256M
-showsplash
org.eclipse.platform
–launcher.XXMaxPermSize
256m
–launcher.defaultAction
openFile
-vmargs
-server
-Dosgi.requiredJavaVersion=1.5
-Xmn128m
-Xms1024m
-Xmx1024m
-Xss2m
-XX:PermSize=128m
-XX:MaxPermSize=128m
-XX:+UseParallelGC

4.Create a ram disk(virtual disk) on memory, and put your jdk on the ram disk.
You can use imdisk to create ram disk. Firstly download it from: http://www.ltr-data.se/opencode.html/#ImDisk,  and install it.

Then set the ImDisk driver to auto-load at Command Prompt with administrative privileges (for example right-click, start as Administrator), type:

sc config imdisk start= auto
net start imdisk

create a 200m ram disk as driver n by:
imdisk -a -t vm -s 300m -m n:

then you should format the ram disk manually.

later ,if you would like to remove the ram disk, just run the command:
imdisk -D -m n:

5.Make sure you are using sun jdk, not open jdk/gcj nor other jdk on linux.
If you are not satified with the after the above steps, install jrockit instead of sun jdk, and change some of the vm options by jrocket specification,
jrockit is faster than sun jdk.

Some note:

On my laptop(Aspire 4745G 4G mem ), windows 7 x64, by default, it takes more than 30 seconds to start eclipse.  After the vm options tuned,  takes only 15 seconds.

And after jdk moved to ram disk, it takes 10 seconds to startup.

see:http://www.beyondlinux.com/2011/06/25/speed-up-your-eclipse-as-a-super-fast-ide/

How to improve eclipse performance for starting

Increase the following Java virtual memory (-vmargs) settings:

Xms Initial size (bytes) of the memory allocation pool. This value must be a multiple of 1024, greater than 1 MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. 

Xmx Maximum size (bytes) of the memory allocation pool. This value must a multiple of 1024, greater than 2 MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes.

XX:MaxPermSize Maximum size of Permanent Generation

XX:PermSize Initial size of Permanent Generation

Follow these steps to increase the Java virtual memory settings.

Ensure that Eclipse is not running on your computer.

Locate and open the eclipse.ini file, as applicable, on your computer. The .ini file is located within your Eclipse installation directory.

Change or add the following Java -vmargs settings in the eclipse.ini file:

Xms256m

Xmx512m

XX:MaxPermSize=256m

XX:PermSize=64m

Save the file and restart Eclipse, as applicable.

For more information:

• http://wiki.eclipse.org/Eclipse.ini
• http://wiki.eclipse.org/FAQ_How_do_I_increase_the_heap_size_available_to_Eclipse
• http://wiki.eclipse.org/FAQ_How_do_I_increase_the_permgen_size_available_to_Eclipse
• http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html

Hibernate 3.5.0-Final release Features

hello, everbody,

Here is the list of the major accomplishments embodied in 3.5.0-Final

• JSR 317 (JPA2) support.
• Integration of hibernate-annotations, hibernate-entitymanager and hibernate-envers into the core project.  See http://in.relation.to/14172.lace for details
• Added Infinispan as a standard second-level cache. See http://infinispan.blogspot.com/2009/10/infinispan-based-hibernate-cache.html for details
• Improvements to the new second-level caching SPI introduced in 3.3 based on feedback from implementers including Ehcache, Inifinispan and JBoss Cache.
• Far better read only / immutable support. See the new chapter added to the core reference manual dedicated to the subject.
• Support for JDBC 4 such that Hibernate can be used in JDK 1.6 JVMs and make use of JDBC4-compliant drivers.'
• Support for column-level read/write fragments (HBM only for now)
• Initial support for fetch profiles

Check out the release page for the full list of changes (just in 3.5.0-Final, aka not cumulative).

you can see http://relation.to/15040.lace for details.

ericssonxiao

jdk1.5、1.6、1.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 
　　staticbooleancheckName(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 
　　staticbooleancheckName(Collection<String> 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语句实现相同方法： 

　　voidprintAll(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），像这样： 

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

　　importorg.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中的代码为： 

　　importorg.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线程：线程池- 
* 
* @author Administrator 2009-11-4 23:30:44 
*/ 
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线程：线程池- 
* 
* @author Administrator 2009-11-4 23:30:44 
*/ 
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线程：线程池-自定义线程池 
* 
* @author Administrator 2009-11-4 23:30:44 
*/ 
public class Test { 
        public static void main(String[] args) { 
                //创建等待队列 
                BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(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<Runnable> 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<Integer> intList = new ArrayList<Integer>(); //intList为存放Integer实例的List 
intList.add(new Integer(0)); 
Integer i0 = intList.get(0); //无需(Integer)强制转型；List<Integer>的get()返回的就是Integer类 
                                    //型对象 
intList.add(“1”); //编译不通过，因为List<Integer>的add()方法只接受Integer类型的参数 

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

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

截取的关于List和Iterator接口定义的代码片断： 

public interface List<E> { 
       void add(E x); 
       Iterator<E> iterator; 
} 

public interface Iterator<E> { 
       E next(); 
       boolean hasNext(); 
} 

以List为例，“public interface List<E>”中的E是List的类型参数，用户在使用List 

时可为类型参数指定一个确定类型值（如List<Integer>）。类型值为Java编译器所用，确保用户代码类型安全。例如，编译器知道List<Integer>的add()方法只接受Integer类型的参数，因此如果你在代码中将一个字符串传入add()将导致编译错误；编译器知道Iterator<Integer>的next()方法返回一个Integer的实例，你在代码中也就无需对返回结果进行(Integer)强制转型。代码检验通过（语法正确且不会导致运行时类型安全问题）后，编译器对现有代码有一个转换工作。简单的说，就是去除代码中的类型值信息，在必要处添加转型代码。例如如下代码： 

public String demo() { 

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

       strList.add(“Hello!”); 

       return strList.get(0); 

} 

编译器在检验通过后，将其转换为： 

public String demo() { 

       List strList = new ArrayList(); //去除类型值<String> 

       strList.add(“Hello!”); 

       return (String)strList.get(0);  //添加转型动作代码(String) 

} 


       可见，类型值信息只为Java编译器在编译时所用，确保代码无类型安全问题；验证通过之后，即被去除。对于JVM而言，只有如JDK1.5之前版本一样的List，并无List<Integer>和List<String>之分。这也就是Java Generics实现中关键技术Erasure的基本思想。以下代码在控制台输出的就是“true”。 

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

List<Integer> intList = new ArrayList<Integer>(); 

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

    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<K,V> { 

       ……; 

} 

3         Generic类和原（Raw）类 
对每一个Generic类，用户在使用时可以不指定类型参数。例如，对于List<E>，用户 

可以以“List<String> list;”方式使用，也可以以“List list;”方式使用。“List<String>”被称为参数化的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<String> ls = new ArrayList<String>(); 

List<Object> lo = ls; //编译错误：Type mismatch: cannot convert from List<Dummy> to 
                                                           //List<Object> 

以上第二行代码导致的编译错误“Type mismatch: cannot convert from List<Dummy> to 

List<Object>”是不是有点出人意料？直观上看，就像String是Object的子类，因此‘Object o = “String”’合法一样，存放String的List是存放Object的List的子类，因此第二行应该是合法的。反过来分析，如果第二行是合法的，那么如下会导致运行时异常的代码也是合法的： 

lo.add(new Object); //会导致在ls中添加了非String对象 

String s = ls.get(0); //ls.get(0)返回的实际上只是一个Object实例，会导致ClassCastException 

       编译器显然不允许此种情形发生，因此不允许“List<Object> lo = ls”编译通过。 

       因此，直观上的“存放String的List是存放Object的List的子类”是错误的。更一般的说，设Foo是Bar的子类，G是Generic类型声明，G<Foo>不是G<Bar>的子类。 

5 参数化的Generic类和数组 
我们知道，如果T是S的子类，则T[]也是S[]的子类。因此，如下代码编译通过，只 

在运行时于第三行代码处抛ArrayStoreException。 

String[] words = new String[10]; 

Object[] objects = words; 

Objects[0] = new Object(); //编译通过，但运行时会抛ArrayStoreException 


再分析如下代码： 

List<String>[] wordLists = new ArrayList<String>[10]; 

ArrayList<Integer> integerList = new ArrayList<Integer>(); 

integerList.add(123); 

Object[] objects = wordLists; 

objects[0] = integerList;//运行时不出错，因为运行时ArrayList<String>和ArrayList<Integer>都 
                                 //为ArrayList 

String s = wordlists[0].get(0); //编译通过，运行时抛ClassCastException 

       就出现了“正确使用了Generic，但在运行时仍然出现ClassCastException”的情形。显然Java编译器不允许此种情形的发生。事实上，以上代码的第一行“List<String>[] wordLists = new ArrayList<String>[10];”就是编译不通过的，也就不存在接下来的代码。 

更一般地说，不能创建参数化的Generic类的数组。 

6 类型参数通配符? 
由“Generic类和子类”节知，Collection<Object>不是存放其它类型对象的Collection（例 

如Collection<String>）的基类（抽象），那么如何表示任一种参数化的Collection的呢？使用Collection<?>。？即代表任一类型参数值。例如，我们可以很容易写出下面的通用函数printCollection()： 

public static void printCollection(Collection<?> c) { 

    //如此遍历Collection的简洁方式也是JDK1.5新引入的 

       for (Object o : c) { 

              System.out.println(o); 

    } 

} 

       这样，既可以将Collection<String>的实例，也可以将Collection<Integer>的实例作为参数调用printCollection()方法。 

       然而，要注意一点，你不能往Collection<?>容器实例中加入任何非null元素，例如如下代码的第三行编译不通过： 

public static void testAdd(Collection<?> c) { 

       c.add(null); //编译通过 

       c.add(“test”); //编译错误 

} 

       很好理解：c中要存放的对象的具体类型不确定，编译器无法验证待添加对象类型的正确性，因此不能加入对象实例；而null可以看作是任一个类的实例，因而允许加入。 

       另外，尽管c中要存放的对象的类型不确定，但我们知道任何类都是Object子类，因此从c中取出的对象都统一作为Object实例。 

       更进一步，如果BaseClass代表某个可被继承的类的类名，那么Collection<? extends BaseClass>代表类型参数值为BaseClass或BaseClass某个子类的任一参数化Collection。对于Collection<? extends BaseClass>的实例c，因为c中要存放的对象具体类型不确定，不能往其加入非null对象，但从c中取出的对象都统一作为BaseClass实例。事实上，你可以把Collection<?>看作Collection<? extends Object>的简洁形式。 

       另一种情形：如果SubClass代表任一个类的类名，那么Collection<? super SubClass>代表类型参数值为SubClass或SubClass某个祖先类的任一参数化Collection。对于Collection<? super SubClass>的实例c，你可以将SubClass实例加入其中，但从中取出的对象都是Object实例。 

7 Generic方法 
我们可以定义Generic类，同样可以定义Generic方法，即将方法的一个或多个参数的类型参数化，如代码： 


public static <T> void fromArrayToCollection(T[] a, Collection<T> c) { 

       for (T o : a) { 

           c.add(o); //合法。注意与Collection<?>的区别 

    } 

} 


我们可以以如下方式调用fromArrayToCollection()： 

Object[] oa = new Object[100]; 

Collection<Object> co = new ArrayList<Object>(); 

fromArrayToCollection(oa, co); //此时，T即为Object 


String[] sa = new String[100]; 

Collection<String> cs = new ArrayList<String>(); 

fromArrayToCollection(sa, cs); //此时，T即为String 

fromArrayToCollection(sa, co); //此时，T即为Object 

Integer[] ia = new Integer[100]; 

Float[] fa = new Float[100]; 

Number[] na = new Number[100]; 

Collection<Number> cn = new ArrayList<Number>(); 

fromArrayToCollection(ia, cn); //此时，T即为Number 

fromArrayToCollection(fa, cn); //此时，T即为Number 

fromArrayToCollection(na, cn); //此时，T即为Number 

fromArrayToCollection(na, co); //此时，T即为Object 

fromArrayToCollection(na, cs); //编译错误 

       通过以上代码可以看出，我们在调用fromArrayToCollection()时，无需明确指定T为何种类型（与Generic类的使用方式不同），而是像调用一般method一样，直接提供参数值，编译器会根据提供的参数值自动为T赋类型值或提示编译错误（参数值不当）。 
考虑如下函数sum() 
public static long sum(Collection<? extends Number> numbers) { 
    long sum = 0; 
    for (Number n : numbers) { 
       sum += n.longValue(); 
    } 
    return sum; 
} 

我们也可以将其以Generic方法实现： 

public static <T extends Number> long sum(Collection<T> numbers) { 

    long sum = 0; 

    for (Number n : numbers) { 

       sum += n.longValue(); 

    } 

    return sum; 
} 

       那么对于一个方法，当要求参数类型可变时，是采用Generic方法，还是采用类型参数通配符方式呢？一般而言，如果参数类型间或参数类型与返回值类型间存在某种依赖关系，则采取Generic方法，否则采取类型参数通配符方式。 

       这一原则在Collection类库的源代码中得到了很好的体现，例如Collection接口的containsAll()、addAll()和toArray()方法： 


interface Collection<E> { 

       public boolean containsAll(Collecion<?> c); //参数间类型以及参数与返回 
                                                                    //值间类型无依赖 
       <T> T[] toArray(T[] a); //参数a与返回值都是相同类的数组，有依赖 
} 

当然，根据需要，二者也可以结合使用，例如Collections中的copy()方法： 

class Collections { 

       public static <T> void copy(List<T> dest, List<? extends T> src) { 

           ……. 

       } 

} 


jdk1.6新特性 
1.Desktop类和SystemTray类 
2.使用JAXB2来实现对象与XML之间的映射 
3.StAX 
4.使用Compiler API 
5.轻量级Http Server API 
6.插入式注解处理API(Pluggable Annotation Processing API) 
7.用Console开发控制台程序 
8.对脚本语言的支持 
9.Common Annotations 

1.Desktop类和SystemTray类 
在JDK1.6中,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(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开发控制台程序 
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的声明式事务）,如果这些技术为通用目的都单独定义了自己的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来检验安全角色. 



jdk1.7新特性 
1 对集合类的语言支持； 
2 自动资源管理； 
3 改进的通用实例创建类型推断； 
4 数字字面量下划线支持； 
5 switch中使用string； 
6 二进制字面量； 
7 简化可变参数方法调用。 


   下面我们来仔细看一下这7大新功能： 
      1 对集合类的语言支持 
      Java将包含对创建集合类的第一类语言支持。这意味着集合类的创建可以像Ruby和Perl那样了。 
      原本需要这样： 
         List<String> list = new ArrayList<String>(); 
         list.add("item"); 
         String item = list.get(0); 
   
         Set<String> set = new HashSet<String>(); 
         set.add("item"); 
         Map<String, Integer> map = new HashMap<String, Integer>(); 
         map.put("key", 1); 
         int value = map.get("key"); 

      现在你可以这样： 
         List<String> list = ["item"]; 
         String item = list[0]; 
         
         Set<String> set = {"item"}; 
         
         Map<String, Integer> map = {"key" : 1}; 
         int value = map["key"]; 

      这些集合是不可变的。 

   
      2 自动资源管理 
      Java中某些资源是需要手动关闭的，如InputStream，Writes，Sockets，Sql classes等。这个新的语言特性允许try语句本身申请更多的资源， 
   这些资源作用于try代码块，并自动关闭。 
      这个： 
         BufferedReader br = new BufferedReader(new FileReader(path)); 
         try { 
         return br.readLine(); 
               } finally { 
                   br.close(); 
         } 

      变成了这个： 
          try (BufferedReader br = new BufferedReader(new FileReader(path)) { 
             return br.readLine(); 
          } 
    
      你可以定义关闭多个资源： 
         try ( 
             InputStream in = new FileInputStream(src); 
             OutputStream out = new FileOutputStream(dest)) 
         { 
         // code 
         } 
      为了支持这个行为，所有可关闭的类将被修改为可以实现一个Closable（可关闭的）接口。 
   

      3 增强的对通用实例创建（diamond）的类型推断 
      类型推断是一个特殊的烦恼，下面的代码： 
         Map<String, List<String>> anagrams = new HashMap<String, List<String>>(); 

      通过类型推断后变成： 
         Map<String, List<String>> anagrams = new HashMap<>(); 
      这个<>被叫做diamond（钻石）运算符，这个运算符从引用的声明中推断类型。 

   
      4 数字字面量下划线支持 
      很长的数字可读性不好，在Java 7中可以使用下划线分隔长int以及long了，如： 
         int one_million = 1_000_000; 
   运算时先去除下划线，如：1_1 * 10 = 110，120 – 1_0 = 110 
   

      5 switch中使用string 
      以前你在switch中只能使用number或enum。现在你可以使用string了： 
         String s = ... 
         switch(s) { 
         case "quux": 
              processQuux(s); 
     // fall-through 
         case "foo": 
   case "bar": 
              processFooOrBar(s); 
     break; 
         case "baz": 
        processBaz(s); 
              // fall-through 
   default: 
              processDefault(s); 
            break; 
  } 

  
      6 二进制字面量 
      由于继承C语言，Java代码在传统上迫使程序员只能使用十进制，八进制或十六进制来表示数(numbers)。 
      由于很少的域是以bit导向的，这种限制可能导致错误。你现在可以使用0b前缀创建二进制字面量： 
         int binary = 0b1001_1001; 
   现在，你可以使用二进制字面量这种表示方式，并且使用非常简短的代码，可将二进制字符转换为数据类型，如在byte或short。 
   byte aByte = (byte)0b001;    
   short aShort = (short)0b010;    

   
      7 简化的可变参数调用 
      当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操作”的警告。 
   JDK 7将警告从call转移到了方法声明(methord declaration)的过程中。这样API设计者就可以使用vararg，因为警告的数量大大减少了。