java5-11各个版本新特性

转载:https://blog.csdn.net/zl1zl2zl3/article/details/85055948

Java 5

---

Java5开发代号为Tiger(老虎),于2004-09-30发行

特性列表

• 泛型

• 枚举

• 自动装箱拆箱

• 可变参数

• 注解

• foreach循环（增强for、for/in）

• 静态导入

• 格式化（System.out.println 支持%s %d等格式化输出）

• 线程框架/数据结构 JUC

• Arrays工具类/StringBuilder/instrument

1、泛型

所谓类型擦除指的就是Java源码中的范型信息只允许停留在编译前期，而编译后的字节码文件中将不再保留任何的范型信息。也就是说，范型信息在编译时将会被全部删除，其中范型类型的类型参数则会被替换为Object类型，并在实际使用时强制转换为指定的目标数据类型。而C++中的模板则会在编译时将模板类型中的类型参数根据所传递的指定数据类型生成相对应的目标代码。

Map squares = new HashMap();

通配符类型：避免unchecked警告，问号表示任何类型都可以接受

1.  
   public void printList(List list, PrintStream out) throws IOException {
2.  
        for (Iterator i = list.iterator(); i.hasNext(); ) {
3.  
         out.println(i.next().toString());
4.  
       }
5.  
     }

限制类型

1.  
   public static  double sum(Box box1,Box box2){
2.  
        double total = 0;
3.  
        for (Iterator i = box1.contents.iterator(); i.hasNext(); ) {
4.  
         total = total + i.next().doubleValue();
5.  
       }
6.  
        for (Iterator i = box2.contents.iterator(); i.hasNext(); ) {
7.  
         total = total + i.next().doubleValue();
8.  
       }
9.  
        return total;
10.  
      }

2、枚举

EnumMap

1.  
   public void testEnumMap(PrintStream out) throws IOException {
2.  
        // Create a map with the key and a String message
3.  
       EnumMap antMessages =
4.  
          new EnumMap(AntStatus.class);
5.  
        // Initialize the map
6.  
       antMessages.put(AntStatus.INITIALIZING,  "Initializing Ant...");
7.  
       antMessages.put(AntStatus.COMPILING,     "Compiling Java classes...");
8.  
       antMessages.put(AntStatus.COPYING,       "Copying files...");
9.  
       antMessages.put(AntStatus.JARRING,       "JARring up files...");
10.  
        antMessages.put(AntStatus.ZIPPING,       "ZIPping up files...");
11.  
        antMessages.put(AntStatus.DONE,          "Build complete.");
12.  
        antMessages.put(AntStatus.ERROR,         "Error occurred.");
13.  
         // Iterate and print messages
14.  
         for (AntStatus status : AntStatus.values() ) {
15.  
          out.println( "For status " + status + ", message is: " +
16.  
                      antMessages.get(status));
17.  
        }
18.  
      }
19.  
     

switch枚举

1.  
   public String getDescription() {
2.  
        switch(this) {
3.  
          case ROSEWOOD:      return "Rosewood back and sides";
4.  
          case MAHOGANY:      return "Mahogany back and sides";
5.  
          case ZIRICOTE:      return "Ziricote back and sides";
6.  
          case SPRUCE:        return "Sitka Spruce top";
7.  
          case CEDAR:         return "Wester Red Cedar top";
8.  
          case AB_ROSETTE:    return "Abalone rosette";
9.  
          case AB_TOP_BORDER: return "Abalone top border";
10.  
           case IL_DIAMONDS:   
11.  
             return "Diamonds and squares fretboard inlay";
12.  
           case IL_DOTS:
13.  
             return "Small dots fretboard inlay";
14.  
           default: return "Unknown feature";
15.  
        }
16.  
      }

3、自动拆箱/装箱

将primitive类型转换成对应的wrapper类型：Boolean、Byte、Short、Character、Integer、Long、Float、Double

4、可变参数

1.  
   private String print(Object... values) {
2.  
       StringBuilder sb =  new StringBuilder();
3.  
        for (Object o : values) {
4.  
         sb.append(o.toString())
5.  
           .append( " ");
6.  
       }
7.  
        return sb.toString();
8.  
     }

5、注解

Inherited表示该注解是否对类的子类继承的方法等起作用

1.  
   @Documented
2.  
   @Inherited
3.  
   @Retention(RetentionPolicy.RUNTIME)
4.  
   public @interface InProgress { }

Target类型
Rentation表示annotation是否保留在编译过的class文件中还是在运行时可读。

6、增强for循环 for/in

for/in循环办不到的事情：
（1）遍历同时获取index
（2）集合逗号拼接时去掉最后一个
（3）遍历的同时删除元素

7、静态导入

1.  
   import static java.lang.System.err;
2.  
   import static java.lang.System.out;
3.  
    
4.  
   err.println(msg); 

8、print输出格式化

System.out.println("Line %d: %s%n", i++, line);

9、并发支持（JUC）

线程池
uncaught exception（可以抓住多线程内的异常）

1.  
   class SimpleThreadExceptionHandler implements
2.  
        Thread.UncaughtExceptionHandler {
3.  
      public void uncaughtException(Thread t, Throwable e) {
4.  
       System.err.printf( "%s: %s at line %d of %s%n",
5.  
           t.getName(), 
6.  
           e.toString(),
7.  
           e.getStackTrace()[ 0].getLineNumber(),
8.  
           e.getStackTrace()[ 0].getFileName());
9.  
     }

blocking queue(BlockingQueue)
JUC类库

10、Arrays、Queue、线程安全StringBuilder

Arrays工具类

1.  
   Arrays.sort(myArray);
2.  
   Arrays.toString(myArray)
3.  
   Arrays.binarySearch(myArray,  98)
4.  
   Arrays.deepToString(ticTacToe)
5.  
   Arrays.deepEquals(ticTacToe, ticTacToe3)

Queue
避开集合的add/remove操作，使用offer、poll操作（不抛异常）

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接口。

Queue q = new LinkedList(); //采用它来实现queue

Override返回类型
单线程StringBuilder
java.lang.instrument

 

Java 6

---

Java6开发代号为Mustang(野马),于2006-12-11发行。评价：鸡肋的版本，有JDBC4.0更新、Complier API、WebSevice支持的加强等更新。

1、Web Services

优先支持编写 XML web service 客户端程序。你可以用过简单的annotaion将你的API发布成.NET交互的web services. Mustang 添加了新的解析和 XML 在 Java object-mapping APIs中, 之前只在Java EE平台实现或者Java Web Services Pack中提供.

2、Scripting（开启JS的支持，算是比较有用的）

现在你可以在Java源代码中混入JavaScript了，这对开发原型很有有用，你也可以插入自己的脚本引擎。

3、Database

Mustang 将联合绑定 Java DB (Apache Derby). JDBC 4.0 增加了许多特性例如支持XML作为SQL数据类型，更好的集成Binary Large OBjects (BLOBs) 和 Character Large OBjects (CLOBs) .

4、More Desktop APIs

GUI 开发者可以有更多的技巧来使用 SwingWorker utility ，以帮助GUI应用中的多线程。, JTable 分类和过滤，以及添加splash闪屏。

很显然，这对于主攻服务器开发的Java来说，并没有太多吸引力

5、Monitoring and Management.

绑定了不是很知名的 memory-heap 分析工具Jhat 来查看内核导出。

6、Compiler Access（这个很厉害）

compiler API提供编程访问javac，可以实现进程内编译，动态产生Java代码。

7、Pluggable Annotation

8、Desktop Deployment.

Swing拥有更好的 look-and-feel , LCD 文本呈现, 整体GUI性能的提升。Java应用程序可以和本地平台更好的集成，例如访问平台的系统托盘和开始菜单。Mustang将Java插件技术和Java Web Start引擎统一了起来。

9、Security

XML-数字签名(XML-DSIG) APIs 用于创建和操纵数字签名); 新的方法来访问本地平台的安全服务

10、The -ilities（很好的习惯）

质量，兼容性，稳定性。 80,000 test cases 和数百万行测试代码(只是测试活动中的一个方面). Mustang 的快照发布已经被下载15个月了，每一步中的Bug都被修复了，表现比J2SE 5还要好。

 

Java 7

---

特性列表

• switch中添加对String类型的支持

• 数字字面量的改进 / 数值可加下划

• 异常处理（捕获多个异常） try-with-resources

• 增强泛型推断

• JSR203 NIO2.0（AIO）新IO的支持

• JSR292与InvokeDynamic指令

• Path接口、DirectoryStream、Files、WatchService（重要接口更新）

• fork/join framework

1、switch中添加对String类型的支持

1.  
          String title =  "";  
2.  
           switch (gender) {  
3.  
               case "男":  
4.  
                  title = name +  " 先生";  
5.  
                   break;  
6.  
               case "女":  
7.  
                  title = name +  " 女士";  
8.  
                   break;  
9.  
               default:  
10.  
                   title = name;  
11.  
           }  
12.  
            return title;  

编译器在编译时先做处理：
①case仅仅有一种情况。直接转成if。
②假设仅仅有一个case和default，则直接转换为if…else…。
③有多个case。先将String转换为hashCode，然后相应的进行处理，JavaCode在底层兼容Java7曾经版本号。

2、数字字面量的改进

Java7前支持十进制（123）、八进制（0123）、十六进制（0X12AB）
Java7添加二进制表示（0B11110001、0b11110001）
数字中可加入分隔符
Java7中支持在数字量中间添加’_'作为分隔符。更直观，如（12_123_456）。下划线仅仅能在数字中间。编译时编译器自己主动删除数字中的下划线。

int one_million = 1_000_000;

3、异常处理（捕获多个异常） try-with-resources

catch子句能够同一时候捕获多个异常

1.  
   public void testSequence() {  
2.  
            try {  
3.  
               Integer.parseInt( "Hello");  
4.  
           }  
5.  
            catch (NumberFormatException | RuntimeException e) {  //使用'|'切割，多个类型，一个对象e  
6.  
    
7.  
           }  
8.  
       } 

try-with-resources语句
Java7之前须要在finally中关闭socket、文件、数据库连接等资源；
Java7中在try语句中申请资源，实现资源的自己主动释放（资源类必须实现java.lang.AutoCloseable接口，一般的文件、数据库连接等均已实现该接口，close方法将被自己主动调用）。

1.  
   public void read(String filename) throws IOException {  
2.  
             try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {  
3.  
                StringBuilder builder =  new StringBuilder();  
4.  
       String line =  null;  
5.  
        while((line=reader.readLine())!=null){  
6.  
           builder.append(line);  
7.  
           builder.append(String.format( "%n"));  
8.  
       }  
9.  
        return builder.toString();  
10.  
             }   
11.  
         } 

4、增强泛型推断

Map> map = new HashMap>();  

Java7之后可以简单的这么写

Map> anagrams = new HashMap<>(); 

5、NIO2.0（AIO）新IO的支持

bytebuffer

1.  
   public class ByteBufferUsage {
2.  
        public void useByteBuffer() {
3.  
           ByteBuffer buffer = ByteBuffer.allocate( 32);
4.  
           buffer.put(( byte)1);
5.  
           buffer.put( new byte[3]);
6.  
           buffer.putChar( 'A');
7.  
           buffer.putFloat( 0.0f);
8.  
           buffer.putLong( 10, 100L);
9.  
           System.out.println(buffer.getChar( 4));
10.  
            System.out.println(buffer.remaining());
11.  
        }
12.  
         public void byteOrder() {
13.  
            ByteBuffer buffer = ByteBuffer.allocate( 4);
14.  
            buffer.putInt( 1);
15.  
            buffer.order(ByteOrder.LITTLE_ENDIAN);
16.  
            buffer.getInt( 0); //值为16777216
17.  
        }
18.  
         public void compact() {
19.  
            ByteBuffer buffer = ByteBuffer.allocate( 32);
20.  
            buffer.put( new byte[16]);
21.  
            buffer.flip();
22.  
            buffer.getInt();
23.  
            buffer.compact();
24.  
             int pos = buffer.position();
25.  
        }
26.  
         public void viewBuffer() {
27.  
            ByteBuffer buffer = ByteBuffer.allocate( 32);
28.  
            buffer.putInt( 1);
29.  
            IntBuffer intBuffer = buffer.asIntBuffer();
30.  
            intBuffer.put( 2);
31.  
             int value = buffer.getInt(); //值为2
32.  
        }
33.  
         /**
34.  
         * @param args the command line arguments
35.  
         */
36.  
         public static void main(String[] args) {
37.  
            ByteBufferUsage bbu =  new ByteBufferUsage();
38.  
            bbu.useByteBuffer();
39.  
            bbu.byteOrder();
40.  
            bbu.compact();
41.  
            bbu.viewBuffer();
42.  
        }
43.  
    }

filechannel

1.  
   public class FileChannelUsage {
2.  
        public void openAndWrite() throws IOException {
3.  
           FileChannel channel = FileChannel.open(Paths.get( "my.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
4.  
           ByteBuffer buffer = ByteBuffer.allocate( 64);
5.  
           buffer.putChar( 'A').flip();
6.  
           channel.write(buffer);
7.  
       }
8.  
        public void readWriteAbsolute() throws IOException {
9.  
           FileChannel channel = FileChannel.open(Paths.get( "absolute.txt"), StandardOpenOption.READ, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
10.  
            ByteBuffer writeBuffer = ByteBuffer.allocate( 4).putChar('A').putChar('B');
11.  
            writeBuffer.flip();
12.  
            channel.write(writeBuffer,  1024);
13.  
            ByteBuffer readBuffer = ByteBuffer.allocate( 2);
14.  
            channel.read(readBuffer,  1026);
15.  
            readBuffer.flip();
16.  
             char result = readBuffer.getChar(); //值为'B'
17.  
        }
18.  
         /**
19.  
         * @param args the command line arguments
20.  
         */
21.  
         public static void main(String[] args) throws IOException {
22.  
            FileChannelUsage fcu =  new FileChannelUsage();
23.  
            fcu.openAndWrite();
24.  
            fcu.readWriteAbsolute();
25.  
        }
26.  
    }

6、JSR292与InvokeDynamic

JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform，支持在JVM上运行动态类型语言。在字节码层面支持了InvokeDynamic。

1.  
   public class ThreadPoolManager {
2.  
        private final ScheduledExecutorService stpe = Executors
3.  
               .newScheduledThreadPool( 2);
4.  
        private final BlockingQueue> lbq;
5.  
        public ThreadPoolManager(BlockingQueue> lbq_) {
6.  
           lbq = lbq_;
7.  
       }
8.  
        public ScheduledFuture run(QueueReaderTask msgReader) {
9.  
           msgReader.setQueue(lbq);
10.  
             return stpe.scheduleAtFixedRate(msgReader, 10, 10, TimeUnit.MILLISECONDS);
11.  
        }
12.  
         private void cancel(final ScheduledFuture hndl) {
13.  
            stpe.schedule( new Runnable() {
14.  
                 public void run() {
15.  
                    hndl.cancel( true);
16.  
                }
17.  
            },  10, TimeUnit.MILLISECONDS);
18.  
        }
19.  
         /**
20.  
         * 使用传统的反射api
21.  
         */
22.  
         public Method makeReflective() {
23.  
            Method meth =  null;
24.  
             try {
25.  
                Class[] argTypes =  new Class[]{ScheduledFuture.class};
26.  
                meth = ThreadPoolManager.class.getDeclaredMethod( "cancel", argTypes);
27.  
                meth.setAccessible( true);
28.  
            }  catch (IllegalArgumentException | NoSuchMethodException
29.  
                    | SecurityException e) {
30.  
                e.printStackTrace();
31.  
            }
32.  
             return meth;
33.  
        }
34.  
         /**
35.  
         * 使用代理类
36.  
         * @return
37.  
         */
38.  
         public CancelProxy makeProxy() {
39.  
             return new CancelProxy();
40.  
        }
41.  
         /**
42.  
         * 使用Java7的新api，MethodHandle
43.  
         * invoke virtual 动态绑定后调用 obj.xxx
44.  
         * invoke special 静态绑定后调用 super.xxx
45.  
         * @return
46.  
         */
47.  
         public MethodHandle makeMh() {
48.  
            MethodHandle mh;
49.  
            MethodType desc = MethodType.methodType( void.class, ScheduledFuture.class);
50.  
             try {
51.  
                mh = MethodHandles.lookup().findVirtual(ThreadPoolManager.class,
52.  
                         "cancel", desc);
53.  
            }  catch (NoSuchMethodException | IllegalAccessException e) {
54.  
                 throw (AssertionError) new AssertionError().initCause(e);
55.  
            }
56.  
             return mh;
57.  
        }
58.  
         public static class CancelProxy {
59.  
             private CancelProxy() {
60.  
            }
61.  
             public void invoke(ThreadPoolManager mae_, ScheduledFuture hndl_) {
62.  
                mae_.cancel(hndl_);
63.  
            }
64.  
        }
65.  
    }

调用invoke

1.  
   public class ThreadPoolMain {
2.  
        /**
3.  
        * 如果被继承，还能在静态上下文寻找正确的class
4.  
        */
5.  
        private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
6.  
        private ThreadPoolManager manager;
7.  
        public static void main(String[] args) {
8.  
           ThreadPoolMain main =  new ThreadPoolMain();
9.  
           main.run();
10.  
        }
11.  
         private void cancelUsingReflection(ScheduledFuture hndl) {
12.  
            Method meth = manager.makeReflective();
13.  
             try {
14.  
                System.out.println( "With Reflection");
15.  
                meth.invoke(hndl);
16.  
            }  catch (IllegalAccessException | IllegalArgumentException
17.  
                    | InvocationTargetException e) {
18.  
                e.printStackTrace();
19.  
            }
20.  
        }
21.  
         private void cancelUsingProxy(ScheduledFuture hndl) {
22.  
            CancelProxy proxy = manager.makeProxy();
23.  
            System.out.println( "With Proxy");
24.  
            proxy.invoke(manager, hndl);
25.  
        }
26.  
         private void cancelUsingMH(ScheduledFuture hndl) {
27.  
            MethodHandle mh = manager.makeMh();
28.  
             try {
29.  
                System.out.println( "With Method Handle");
30.  
                mh.invokeExact(manager, hndl);
31.  
            }  catch (Throwable e) {
32.  
                e.printStackTrace();
33.  
            }
34.  
        }
35.  
         private void run() {
36.  
            BlockingQueue> lbq =  new LinkedBlockingQueue<>();
37.  
            manager =  new ThreadPoolManager(lbq);
38.  
             final QueueReaderTask msgReader = new QueueReaderTask(100) {
39.  
                 @Override
40.  
                 public void doAction(String msg_) {
41.  
                     if (msg_ != null)
42.  
                        System.out.println( "Msg recvd: " + msg_);
43.  
                }
44.  
            };
45.  
            ScheduledFuture hndl = manager.run(msgReader);
46.  
            cancelUsingMH(hndl);
47.  
             // cancelUsingProxy(hndl);
48.  
             // cancelUsingReflection(hndl);
49.  
        }
50.  
    }

7、Path接口(重要接口更新)

Path

1.  
   public class PathUsage {
2.  
        public void usePath() {
3.  
           Path path1 = Paths.get( "folder1", "sub1");
4.  
           Path path2 = Paths.get( "folder2", "sub2");
5.  
           path1.resolve(path2);  //folder1\sub1\folder2\sub2
6.  
           path1.resolveSibling(path2);  //folder1\folder2\sub2
7.  
           path1.relativize(path2);  //..\..\folder2\sub2
8.  
           path1.subpath( 0, 1); //folder1
9.  
           path1.startsWith(path2);  //false
10.  
            path1.endsWith(path2);  //false
11.  
            Paths.get( "folder1/./../folder2/my.text").normalize(); //folder2\my.text
12.  
        }
13.  
         /**
14.  
         * @param args the command line arguments
15.  
         */
16.  
         public static void main(String[] args) {
17.  
            PathUsage usage =  new PathUsage();
18.  
            usage.usePath();
19.  
        }
20.  
    }

DirectoryStream

1.  
   public class ListFile {
2.  
        public void listFiles() throws IOException {
3.  
           Path path = Paths.get( "");
4.  
            try (DirectoryStream stream = Files.newDirectoryStream(path, "*.*")) {
5.  
                for (Path entry: stream) {
6.  
                    //使用entry
7.  
                   System.out.println(entry);
8.  
               }
9.  
           }
10.  
        }
11.  
         /**
12.  
         * @param args the command line arguments
13.  
         */
14.  
         public static void main(String[] args) throws IOException {
15.  
            ListFile listFile =  new ListFile();
16.  
            listFile.listFiles();
17.  
        }
18.  
    }

Files

1.  
   public class FilesUtils {
2.  
        public void manipulateFiles() throws IOException {
3.  
           Path newFile = Files.createFile(Paths.get( "new.txt").toAbsolutePath());
4.  
           List content =  new ArrayList();
5.  
           content.add( "Hello");
6.  
           content.add( "World");
7.  
           Files.write(newFile, content, Charset.forName( "UTF-8"));
8.  
           Files.size(newFile);
9.  
            byte[] bytes = Files.readAllBytes(newFile);
10.  
            ByteArrayOutputStream output =  new ByteArrayOutputStream();
11.  
            Files.copy(newFile, output);
12.  
            Files.delete(newFile);
13.  
        }
14.  
         /**
15.  
         * @param args the command line arguments
16.  
         */
17.  
         public static void main(String[] args) throws IOException {
18.  
            FilesUtils fu =  new FilesUtils();
19.  
            fu.manipulateFiles();
20.  
        }
21.  
    }

WatchService

1.  
   public class WatchAndCalculate {
2.  
        public void calculate() throws IOException, InterruptedException {
3.  
           WatchService service = FileSystems.getDefault().newWatchService();
4.  
           Path path = Paths.get( "").toAbsolutePath();
5.  
           path.register(service, StandardWatchEventKinds.ENTRY_CREATE);
6.  
            while (true) {
7.  
               WatchKey key = service.take();
8.  
                for (WatchEvent event : key.pollEvents()) {
9.  
                   Path createdPath = (Path) event.context();
10.  
                    createdPath = path.resolve(createdPath);
11.  
                     long size = Files.size(createdPath);
12.  
                    System.out.println(createdPath +  " ==> " + size);
13.  
                }
14.  
                key.reset();
15.  
            }
16.  
        }
17.  
         /**
18.  
         * @param args the command line arguments
19.  
         */
20.  
         public static void main(String[] args) throws Throwable {
21.  
            WatchAndCalculate wc =  new WatchAndCalculate();
22.  
            wc.calculate();
23.  
        }
24.  
    }

8、fork/join计算框架

Java7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。

该框架为Java8的并行流打下了坚实的基础

 

Java 8

---

Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。

一、Lambda表达式

Lambda表达式可以说是Java 8最大的卖点，她将函数式编程引入了Java。Lambda允许把函数作为一个方法的参数，或者把代码看成数据。

一个Lambda表达式可以由用逗号分隔的参数列表、–>符号与函数体三部分表示。例如：

Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e -> System.out.println( e ) );

为了使现有函数更好的支持Lambda表达式，Java 8引入了函数式接口的概念。函数式接口就是只有一个方法的普通接口。java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的例子。为此，Java 8增加了一种特殊的注解@FunctionalInterface

二、接口的默认方法与静态方法

我们可以在接口中定义默认方法，使用default关键字，并提供默认的实现。所有实现这个接口的类都会接受默认方法的实现，除非子类提供的自己的实现。例如：

1.  
   public interface DefaultFunctionInterface {
2.  
         default String defaultFunction() {
3.  
             return "default function";
4.  
        }
5.  
    }

我们还可以在接口中定义静态方法，使用static关键字，也可以提供实现。例如：

1.  
   public interface StaticFunctionInterface {
2.  
         static String staticFunction() {
3.  
             return "static function";
4.  
        }
5.  
    }

接口的默认方法和静态方法的引入，其实可以认为引入了C＋＋中抽象类的理念，以后我们再也不用在每个实现类中都写重复的代码了。

三、方法引用（含构造方法引用）

通常与Lambda表达式联合使用，可以直接引用已有Java类或对象的方法。一般有四种不同的方法引用：

构造器引用。语法是Class::new，或者更一般的Class< T >::new，要求构造器方法是没有参数；
静态方法引用。语法是Class::static_method，要求接受一个Class类型的参数；
特定类的任意对象方法引用。它的语法是Class::method。要求方法是没有参数的；
特定对象的方法引用，它的语法是instance::method。要求方法接受一个参数，与3不同的地方在于，3是在列表元素上分别调用方法，而4是在某个对象上调用方法，将列表元素作为参数传入；

四、重复注解

在Java 5中使用注解有一个限制，即相同的注解在同一位置只能声明一次。Java 8引入重复注解，这样相同的注解在同一地方也可以声明多次。重复注解机制本身需要用@Repeatable注解。Java 8在编译器层做了优化，相同注解会以集合的方式保存，因此底层的原理并没有变化。

五、扩展注解的支持（类型注解）

Java 8扩展了注解的上下文，几乎可以为任何东西添加注解，包括局部变量、泛型类、父类与接口的实现，连方法的异常也能添加注解。

private @NotNull String name;

六、Optional

Java 8引入Optional类来防止空指针异常，Optional类最先是由Google的Guava项目引入的。Optional类实际上是个容器：它可以保存类型T的值，或者保存null。使用Optional类我们就不用显式进行空指针检查了。

七、Stream

Stream API是把真正的函数式编程风格引入到Java中。其实简单来说可以把Stream理解为MapReduce，当然Google的MapReduce的灵感也是来自函数式编程。她其实是一连串支持连续、并行聚集操作的元素。从语法上看，也很像linux的管道、或者链式编程，代码写起来简洁明了，非常酷帅！

八、Date/Time API (JSR 310)

Java 8新的Date-Time API (JSR 310)受Joda-Time的影响，提供了新的java.time包，可以用来替代 java.util.Date和java.util.Calendar。一般会用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration这些类，对于时间日期的改进还是非常不错的。

九、JavaScript引擎Nashorn

Nashorn允许在JVM上开发运行JavaScript应用，允许Java与JavaScript相互调用。

十、Base64

在Java 8中，Base64编码成为了Java类库的标准。Base64类同时还提供了对URL、MIME友好的编码器与解码器。

说在后面

除了这十大特性，还有另外的一些新特性：

更好的类型推测机制：Java 8在类型推测方面有了很大的提高，这就使代码更整洁，不需要太多的强制类型转换了。

编译器优化：Java 8将方法的参数名加入了字节码中，这样在运行时通过反射就能获取到参数名，只需要在编译时使用-parameters参数。

并行（parallel）数组：支持对数组进行并行处理，主要是parallelSort()方法，它可以在多核机器上极大提高数组排序的速度。

并发（Concurrency）：在新增Stream机制与Lambda的基础之上，加入了一些新方法来支持聚集操作。

Nashorn引擎jjs：基于Nashorn引擎的命令行工具。它接受一些JavaScript源代码为参数，并且执行这些源代码。

类依赖分析器jdeps：可以显示Java类的包级别或类级别的依赖。

JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）。

 

Java 9

---

经过4次跳票，历经曲折的java 9 终于终于在2017年9月21日发布（距离上个版本足足3年半时间）java 9 提供了超过 150 项新功能特性，包括备受期待的模块化系统、可交互的 REPL 工具：jshell，JDK 编译工具，Java 公共 API 和私有代码，以及安全增强、扩展提升、性能管理改善等。可以说 Java 9 是一个庞大的系统工程，完全做了一个整体改变。但本博文只介绍最重要的十大新特性

特性列表

• 平台级modularity（原名：Jigsaw） 模块化系统

• Java 的 REPL 工具： jShell 命令

• 多版本兼容 jar 包（这个在处理向下兼容方面，非常好用）

• 语法改进：接口的私有方法

• 语法改进：UnderScore(下划线)使用的限制

• 底层结构：String 存储结构变更（这个很重要）

• 集合工厂方法：快速创建只读集合

• 增强的 Stream API

• 全新的 HTTP 客户端 API

• 其它特性

• 它的新特性来自于100于项JEP和40于项JSR

 

Java 10

---

2018年3月20日，Java 10 正式发布，这一次没有跳票。它号称有109项新特性，包含12个JEP。需要注意的是，本次Java10并不是Oracle的官方LTS版本，还是坐等java11的发布再考虑在生产中使用

特性列表

• 局部变量的类型推断 var关键字

• GC改进和内存管理 并行全垃圾回收器 G1

• 垃圾回收器接口

• 线程-局部变量管控

• 合并 JDK 多个代码仓库到一个单独的储存库中

• 新增API：ByteArrayOutputStream

• 新增API：List、Map、Set

• 新增API：java.util.Properties

• 新增API： Collectors收集器

• 其它特性

1、局部变量的类型推断 var关键字

这个新功能将为Java增加一些语法糖 - 简化它并改善开发者体验。新的语法将减少与编写Java相关的冗长度，同时保持对静态类型安全性的承诺。

这可能是Java10给开发者带来的最大的一个新特性。下面主要看例子：

1.  
   public static void main(String[] args) {
2.  
           var list =  new ArrayList();
3.  
           list.add( "hello，world！");
4.  
           System.out.println(list);
5.  
       }

这是最平常的使用。注意赋值语句右边，最好写上泛型类型，否则会有如下情况：

1.  
   public static void main(String[] args) {
2.  
           var list =  new ArrayList<>();
3.  
           list.add( "hello，world！");
4.  
           list.add( 1);
5.  
           list.add( 1.01);
6.  
           System.out.println(list);
7.  
       }

list什么都可以装，非常的不安全了。和js等语言不同的是，毕竟Java还是强类型的语言，所以下面语句是编译报错的：

1.  
   public static void main(String[] args) {
2.  
           var list =  new ArrayList();
3.  
           list.add( "hello，world！");
4.  
           System.out.println(list);
5.  
    
6.  
           list =  new ArrayList(); //编译报错
7.  
       }

注意：下面几点使用限制

局部变量初始化
for循环内部索引变量
传统的for循环声明变量

1.  
   public static void main(String[] args) {
2.  
            //局部变量初始化
3.  
           var list =  new ArrayList();
4.  
            //for循环内部索引变量
5.  
            for (var s : list) {
6.  
               System.out.println(s);
7.  
           }
8.  
            //传统的for循环声明变量
9.  
            for (var i = 0; i < list.size(); i++) {
10.  
                System.out.println(i);
11.  
            }
12.  
        }

下面这几种情况，都是不能使用var的

方法参数
全局变量

1.  
   public static var list = new ArrayList(); //编译报错
2.  
   public static List list = new ArrayList<>(); //正常编译通过

构造函数参数
方法返回类型
字段
捕获表达式（或任何其他类型的变量声明）

2、GC改进和内存管理 并行全垃圾回收器 G1

JDK 10中有2个JEP专门用于改进当前的垃圾收集元素。
Java 10的第二个JEP是针对G1的并行完全GC（JEP 307），其重点在于通过完全GC并行来改善G1最坏情况的等待时间。G1是Java 9中的默认GC，并且此JEP的目标是使G1平行。

3、垃圾回收器接口

这不是让开发者用来控制垃圾回收的接口；而是一个在 JVM 源代码中的允许另外的垃圾回收器快速方便的集成的接口。

4、线程-局部变量管控

这是在 JVM 内部相当低级别的更改，现在将允许在不运行全局虚拟机安全点的情况下实现线程回调。这将使得停止单个线程变得可能和便宜，而不是只能启用或停止所有线程。

5、合并 JDK 多个代码仓库到一个单独的储存库中

在 JDK9 中，有 8 个仓库： root、corba、hotspot、jaxp、jaxws、jdk、langtools 和 nashorn 。在 JDK10 中这些将被合并为一个，使得跨相互依赖的变更集的存储库运行 atomic commit （原子提交）成为可能。

6、新增API：ByteArrayOutputStream

String toString(Charset): 重载 toString()，通过使用指定的字符集解码字节，将缓冲区的内容转换为字符串。

7、新增API：List、Map、Set

这3个接口都增加了一个新的静态方法，copyOf(Collection）。这些函数按照其迭代顺序返回一个不可修改的列表、映射或包含给定集合的元素的集合。

8、新增API：java.util.Properties

增加了一个新的构造函数，它接受一个 int 参数。这将创建一个没有默认值的空属性列表，并且指定初始大小以容纳指定的元素数量，而无需动态调整大小。还有一个新的重载的 replace 方法，接受三个 Object 参数并返回一个布尔值。只有在当前映射到指定值时，才会替换指定键的条目。

9、新增API： Collectors收集器

toUnmodifiableList():
toUnmodifiableSet():
toUnmodifiableMap(Function, Function):
toUnmodifiableMap(Function, Function, BinaryOperator):
这四个新方法都返回 Collectors ，将输入元素聚集到适当的不可修改的集合中。

10、其它特性

线程本地握手（JEP 312）
其他Unicode语言 - 标记扩展（JEP 314）
基于Java的实验性JIT编译器
根证书颁发认证（CA）
删除工具javah（JEP 313）
从JDK中移除了javah工具，这个很简单并且很重要。

最后

JDK10的升级幅度其实主要还是以优化为主，并没有带来太多对使用者惊喜的特性。所以建议广大开发者还是坐等Java11吧，预计2018年9月份就会到来，最重要的是它是LTS版本哦，所以是可以运用在生产上的。

 

Java 11

---

2018年9月26日，Oracle 官方宣布 Java 11 正式发布。这是 Java 大版本周期变化后的第一个长期支持版本（LTS版本，Long-Term-Support，持续支持到2026年9月），非常值得关注。
Java11 带来了 ZGC、Http Client 等重要特性，一共包含 17 个 JEP（JDK Enhancement Proposals，JDK 增强提案）。

特性列表

官方新特性：

本文针对于读者对关心、也是最实用的八大新特性做出一些讲解

• 本地变量类型推断

• 字符串加强

• 集合加强

• Stream 加强

• Optional 加强

• InputStream 加强

• HTTP Client API

• 化繁为简，一个命令编译运行源代码

3、集合加强

自 Java 9 开始，Jdk 里面为集合（List/ Set/ Map）都添加了 of 和 copyOf 方法，它们两个都用来创建不可变的集合，来看下它们的使用和区别。
示例1：

1.  
   var list = List.of( "Java", "Python", "C");
2.  
   var copy = List.copyOf(list);
3.  
   System.out.println(list == copy);  // true

示例2：

1.  
   var list =  new ArrayList();
2.  
   var copy = List.copyOf(list);
3.  
   System.out.println(list == copy);  // false

示例1和2代码差不多，为什么一个为true,一个为false?
来看下它们的源码：

1.  
   static  List of(E... elements) {
2.  
      switch (elements.length) { // implicit null check of elements
3.  
        case 0:
4.  
            return ImmutableCollections.emptyList();
5.  
        case 1:
6.  
            return new ImmutableCollections.List12<>(elements[0]);
7.  
        case 2:
8.  
            return new ImmutableCollections.List12<>(elements[0], elements[1]);
9.  
        default:
10.  
             return new ImmutableCollections.ListN<>(elements);
11.  
      }
12.  
    }
13.  
    static  List copyOf(Collection coll) {
14.  
         return ImmutableCollections.listCopy(coll);
15.  
    }
16.  
    static  List listCopy(Collection coll) {
17.  
         if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {
18.  
             return (List)coll;
19.  
        }  else {
20.  
             return (List)List.of(coll.toArray());
21.  
        }
22.  
    }

可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的，如果是，就直接返回，如果不是，则调用 of 创建一个新的集合。

示例2因为用的 new 创建的集合，不属于不可变 AbstractImmutableList 类的子类，所以 copyOf 方法又创建了一个新的实例，所以为false.

注意：使用of和copyOf创建的集合为不可变集合，不能进行添加、删除、替换、排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

上面演示了 List 的 of 和 copyOf 方法，Set 和 Map 接口都有。

1.  
   public static void main(String[] args) {
2.  
           Set names = Set.of( "Fred", "Wilma", "Barney", "Betty");
3.  
            //JDK11之前我们只能这么写
4.  
           System.out.println(Arrays.toString(names.toArray( new String[names.size()])));
5.  
            //JDK11之后  可以直接这么写了
6.  
           System.out.println(Arrays.toString(names.toArray(size ->  new String[size])));
7.  
           System.out.println(Arrays.toString(names.toArray(String[]:: new)));
8.  
       }

Collection.toArray(IntFunction)
在java.util.Collection接口中添加了一个新的默认方法toArray（IntFunction）。此方法允许将集合的元素传输到新创建的所需运行时类型的数组。

1.  
   public static void main(String[] args) {
2.  
           Set names = Set.of( "Fred", "Wilma", "Barney", "Betty");
3.  
            //JDK11之前我们只能这么写
4.  
           System.out.println(Arrays.toString(names.toArray( new String[names.size()])));
5.  
            //JDK11之后  可以直接这么写了
6.  
           System.out.println(Arrays.toString(names.toArray(size ->  new String[size])));
7.  
           System.out.println(Arrays.toString(names.toArray(String[]:: new)));
8.  
       }

4、Stream 加强

Stream 是 Java 8 中的新特性，Java 9 开始对 Stream 增加了以下 4 个新方法。

• 增加单个参数构造方法，可为null

1.  
   Stream.ofNullable( null).count(); // 0
2.  
   //JDK8木有ofNullable方法哦

源码可看看：

1.  
   /**
2.  
    * @since 9
3.  
    */
4.  
     public static Stream ofNullable(T t) {
5.  
         return t == null ? Stream.empty()
6.  
                         : StreamSupport.stream( new Streams.StreamBuilderImpl<>(t), false);
7.  
    }
8.  
    

• 增加 takeWhile 和 dropWhile 方法

1.  
   Stream.of( 1, 2, 3, 2, 1)
2.  
   .takeWhile(n -> n <  3)
3.  
   .collect(Collectors.toList());  // [1, 2]

takeWhile表示从开始计算，当 n < 3 时就截止。

1.  
   Stream.of( 1, 2, 3, 2, 1)
2.  
   .dropWhile(n -> n <  3)
3.  
   .collect(Collectors.toList());  // [3, 2, 1]

• iterate重载

这个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

1.  
   public static void main(String[] args) {
2.  
            // 这构造的是无限流  JDK8开始
3.  
           Stream.iterate( 0, (x) -> x + 1);
4.  
            // 这构造的是小于10就结束的流  JDK9开始
5.  
           Stream.iterate( 0, x -> x < 10, x -> x + 1);
6.  
       }

5、Optional 加强

Opthonal 也增加了几个非常酷的方法，现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

1.  
   Optional.of( "javastack").orElseThrow(); // javastack
2.  
   Optional.of( "javastack").stream().count(); // 1
3.  
   Optional.ofNullable( null)
4.  
   .or(() -> Optional.of( "javastack"))
5.  
   .get();  // javastac

or方法和stream方法显然都是新增的

6、InputStream 加强

InputStream 终于有了一个非常有用的方法：transferTo，可以用来将数据直接传输到 OutputStream，这是在处理原始数据流时非常常见的一种用法，如下示例。

1.  
   var classLoader = ClassLoader.getSystemClassLoader();
2.  
   var inputStream = classLoader.getResourceAsStream( "javastack.txt");
3.  
   var javastack = File.createTempFile( "javastack2", "txt");
4.  
   try (var outputStream = new FileOutputStream(javastack)) {
5.  
       inputStream.transferTo(outputStream);
6.  
   }

7、HTTP Client API(重磅)

在java9及10被标记incubator的模块jdk.incubator.httpclient，在java11被标记为正式，改为java.net.http模块。
这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API，该 API 支持同步和异步，而在 Java 11 中已经为正式可用状态，你可以在 java.net 包中找到这个 API。

来看一下 HTTP Client 的用法：

上面的 .GET() 可以省略，默认请求方式为 Get！

更多使用示例可以看这个 API，后续有机会再做演示。

现在 Java 自带了这个 HTTP Client API，我们以后还有必要用 Apache 的 HttpClient 工具包吗？我觉得没啥必要了

8、化繁为简，一个命令编译运行源代码

看下面的代码。

1.  
   // 编译
2.  
   javac Javastack.java
3.  
   // 运行
4.  
   java Javastack

在我们的认知里面，要运行一个 Java 源代码必须先编译，再运行，两步执行动作。而在未来的 Java 11 版本中，通过一个 java 命令就直接搞定了，如以下所示。

java Javastack.java

移除项

移除了com.sun.awt.AWTUtilities

移除了sun.misc.Unsafe.defineClass，

使用 java.lang.invoke.MethodHandles.Lookup.defineClass来替代
移除了Thread.destroy()以及 Thread.stop(Throwable)方法移除了

sun.nio.ch.disableSystemWideOverlappingFileLockCheck、sun.locale.formatasdefault属性
移除了jdk.snmp模块
移除了javafx，openjdk估计是从java10版本就移除了，oracle jdk10还尚未移除javafx，而java11版本则oracle的jdk版本也移除了javafx
移除了Java Mission Control，从JDK中移除之后，需要自己单独下载
移除了这些Root Certificates ：Baltimore Cybertrust Code Signing CA，SECOM ，AOL and Swisscom

废弃项

废弃了Nashorn JavaScript Engine
废弃了-XX+AggressiveOpts选项
-XX:+UnlockCommercialFeatures以及

-XX:+LogCommercialFeatures选项也不- 再需要
废弃了Pack200工具及其API

说到最后

java11是java改为6个月发布一版的策略之后的第一个LTS(Long-Term Support)版本(oracle版本才有LTS)，这个版本最主要的特性是：在模块方面移除Java EE以及CORBA模块，在JVM方面引入了实验性的ZGC，在API方面正式提供了HttpClient类。

从java11版本开始，不再单独发布JRE或者Server JRE版本了，有需要的可以自己通过jlink去定制runtime image

备注：ZGC作为实验性功能包含在内。要启用它，因此需要将-XX：+ UnlockExperimentalVMOptions选项与-XX：+ UseZGC选项结合使用。
ZGC的这个实验版具有以下限制：

• 它仅适用于Linux / x64。

• 不支持使用压缩的oops和/或压缩的类点。默认情况下禁用-XX：+UseCompressedOops和-XX：+UseCompressedClassPointers选项。启用它们将不起作用。

• 不支持类卸载。默认情况下禁用-XX：+ ClassUnloading和-XX：+ - - ClassUnloadingWithConcurrentMark选项。启用它们将不起作用。

• 不支持将ZGC与Graal结合使用。