jdk8 、 9、11 特性

jdk1.8 十大特性

1.Lambda表达式

2.Stream函数式操作流元素集合

3.接口新增：默认方法与静态方法

4.方法引用,与Lambda表达式联合使用

5.引入重复注解

6.类型注解

7.最新的Date/Time API (JSR 310)

8.新增base64加解密API

9.数组并行（parallel）操作

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

11、HashMap 底层数据结构的变化
	java 8 之前，HashMap 底层的数据结构是数组+链表实现的， Java 8 之后是数组+链表+红黑树实现的，当链表的长度超过 8 之后，会转换成红黑树。
	作用：解决因哈希冲突导致的链表过长，查询效率低的问题。

/**
 * 
 * @ClassName:JDK8_features
 * @Description:JDK8新特性
 * @author diandian.zhang
 * @date 2017年4月17日上午9:13:24
 */
public class JDK8_features {
    
    public List<Integer> list = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
    
    /**
     * 1.Lambda表达式
     */
    @Test
    public void testLambda(){
        list.forEach(System.out::println);
        list.forEach(e -> System.out.println("方式二："+e));
    }
    
    /**
     * 2.Stream函数式操作流元素集合
     */
    @Test
    public void testStream(){
        List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
        System.out.println("求和："+nums
                .stream()//转成Stream
                .filter(team -> team!=null)//过滤
                .distinct()//去重
                .mapToInt(num->num*2)//map操作
                .skip(2)//跳过前2个元素
                .limit(4)//限制取前4个元素
                .peek(System.out::println)//流式处理对象函数
                .sum());//
    }
    
    /**
     * 3.接口新增：默认方法与静态方法
     *  default 接口默认实现方法是为了让集合类默认实现这些函数式处理，而不用修改现有代码
     *  （List继承于Iterable<T>，接口默认方法不必须实现default forEach方法）
     */
    @Test
    public void testDefaultFunctionInterface(){
        //可以直接使用接口名.静态方法来访问接口中的静态方法
        JDK8Interface1.staticMethod();
        //接口中的默认方法必须通过它的实现类来调用
        new JDK8InterfaceImpl1().defaultMethod();
        //多实现类，默认方法重名时必须复写
        new JDK8InterfaceImpl2().defaultMethod();
    }
    
    public class JDK8InterfaceImpl1 implements JDK8Interface1 {
        //实现接口后，因为默认方法不是抽象方法，重写/不重写都成！
//        @Override
//        public void defaultMethod(){
//            System.out.println("接口中的默认方法");
//        }
    }
    
    public class JDK8InterfaceImpl2 implements JDK8Interface1,JDK8Interface2 {
        //实现接口后，默认方法名相同，必须复写默认方法
        @Override
        public void defaultMethod() {
            //接口的
            JDK8Interface1.super.defaultMethod();
            System.out.println("实现类复写重名默认方法！！！！");
        }
    }
        
    /**
     * 4.方法引用,与Lambda表达式联合使用
     */
    @Test
    public void testMethodReference(){
        //构造器引用。语法是Class::new，或者更一般的Class< T >::new，要求构造器方法是没有参数；
        final Car car = Car.create( Car::new );
        final List< Car > cars = Arrays.asList( car );
        //静态方法引用。语法是Class::static_method，要求接受一个Class类型的参数；
        cars.forEach( Car::collide );
        //任意对象的方法引用。它的语法是Class::method。无参，所有元素调用；
        cars.forEach( Car::repair );
        //特定对象的方法引用，它的语法是instance::method。有参，在某个对象上调用方法，将列表元素作为参数传入；
        final Car police = Car.create( Car::new );
        cars.forEach( police::follow );
    }
    
    public static class Car {
        public static Car create( final Supplier< Car > supplier ) {
            return supplier.get();
        }              
             
        public static void collide( final Car car ) {
            System.out.println( "静态方法引用 " + car.toString() );
        }
             
        public void repair() {   
            System.out.println( "任意对象的方法引用 " + this.toString() );
        }
        
        public void follow( final Car car ) {
            System.out.println( "特定对象的方法引用 " + car.toString() );
        }
    }
    
    /**
     * 5.引入重复注解
     * 1.@Repeatable 
     * 2.可以不用以前的“注解容器”写法，直接写2次相同注解即可
     * 
     * Java 8在编译器层做了优化，相同注解会以集合的方式保存，因此底层的原理并没有变化。
     */
    @Test
    public void RepeatingAnnotations(){
        RepeatingAnnotations.main(null);
    }
    
    /**
     * 6.类型注解
     * 新增类型注解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER（在Target上）
     * 
     */
    @Test
    public void ElementType(){
        Annotations.main(null);
    }
    
    /**
     * 7.最新的Date/Time API (JSR 310)
     */
    @Test
    public void DateTime(){
        //1.Clock
        final Clock clock = Clock.systemUTC();
        System.out.println( clock.instant() );
        System.out.println( clock.millis() );
        
        //2. ISO-8601格式且无时区信息的日期部分
        final LocalDate date = LocalDate.now();
        final LocalDate dateFromClock = LocalDate.now( clock );
                 
        System.out.println( date );
        System.out.println( dateFromClock );
                 
        // ISO-8601格式且无时区信息的时间部分
        final LocalTime time = LocalTime.now();
        final LocalTime timeFromClock = LocalTime.now( clock );
                 
        System.out.println( time );
        System.out.println( timeFromClock );
        
        // 3.ISO-8601格式无时区信息的日期与时间
        final LocalDateTime datetime = LocalDateTime.now();
        final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
                 
        System.out.println( datetime );
        System.out.println( datetimeFromClock );
        
        // 4.特定时区的日期/时间，
        final ZonedDateTime zonedDatetime = ZonedDateTime.now();
        final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
        final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );
                 
        System.out.println( zonedDatetime );
        System.out.println( zonedDatetimeFromClock );
        System.out.println( zonedDatetimeFromZone );
        
        //5.在秒与纳秒级别上的一段时间
        final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );
        final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );
         
        final Duration duration = Duration.between( from, to );
        System.out.println( "Duration in days: " + duration.toDays() );
        System.out.println( "Duration in hours: " + duration.toHours() );
    }
    
    /**
     * 8.新增base64加解密API
     */
    @Test
    public void testBase64(){
        final String text = "就是要测试加解密！！abjdkhdkuasu!!@@@@";
        String encoded = Base64.getEncoder()
            .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
        System.out.println("加密后="+ encoded );
         
        final String decoded = new String( 
            Base64.getDecoder().decode( encoded ),
            StandardCharsets.UTF_8 );
        System.out.println( "解密后="+decoded );
    }
    
    /**
     * 9.数组并行（parallel）操作
     */
    @Test
    public void testParallel(){
        long[] arrayOfLong = new long [ 20000 ];        
        //1.给数组随机赋值
        Arrays.parallelSetAll( arrayOfLong, 
            index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
        //2.打印出前10个元素
        Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
            i -> System.out.print( i + " " ) );
        System.out.println();
        //3.数组排序
        Arrays.parallelSort( arrayOfLong );     
        //4.打印排序后的前10个元素
        Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
            i -> System.out.print( i + " " ) );
        System.out.println();
    }
    
    /**
     * 10.JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）元空间
     */
    @Test
    public void testMetaspace(){
        //-XX:MetaspaceSize初始空间大小，达到该值就会触发垃圾收集进行类型卸载，同时GC会对该值进行调整
        //-XX:MaxMetaspaceSize最大空间，默认是没有限制
        //-XX:MinMetaspaceFreeRatio在GC之后，最小的Metaspace剩余空间容量的百分比，减少为分配空间所导致的垃圾收集
        //-XX:MaxMetaspaceFreeRatio在GC之后，最大的Metaspace剩余空间容量的百分比，减少为释放空间所导致的垃圾收集
    }
    
}
引用到的相关类：
public interface JDK8Interface1 {

    //1.接口中可以定义静态方法了
    public static void staticMethod(){
        System.out.println("接口中的静态方法");
    }
    
    //2.使用default之后就可以定义普通方法的方法体了
    public default void defaultMethod(){
        System.out.println("接口中的默认方法");
    }
}

public interface JDK8Interface2 {

    //接口中可以定义静态方法了
    public static void staticMethod(){
        System.out.println("接口中的静态方法");
    }
    //使用default之后就可以定义普通方法的方法体了
    public default void defaultMethod(){
        System.out.println("接口中的默认方法");
    }
}

/**
 * 
 * @ClassName:RepeatingAnnotations
 * @Description:重复注解@Repeatable
 * @author diandian.zhang
 * @date 2017年3月31日下午3:48:13
 */
public class RepeatingAnnotations {
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface Filters {
        Filter[] value();
    }
     
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    @Repeatable( Filters.class )
    public @interface Filter {
        String value();
        String value2();
    };
     
    @Filter( value="filter1",value2="111" )
    @Filter( value="filter2", value2="222")
    //@Filters({@Filter(  value="filter1",value2="111" ),@Filter(  value="filter2", value2="222")}).注意：JDK8之前：1.没有@Repeatable2.采用本行“注解容器”写法
    public interface Filterable {        
    }
         
    public static void main(String[] args) {
        //获取注解后遍历打印值
        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
            System.out.println( filter.value() +filter.value2());
        }
    }
}

/**
 * 
 * @ClassName:Annotations
 * @Description:新增类型注解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER（在Target上）
 * @author diandian.zhang
 * @date 2017年3月31日下午4:39:57
 */
public class Annotations {
    @Retention( RetentionPolicy.RUNTIME )
    @Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
    public @interface NonEmpty {        
    }
         
    public static class Holder< @NonEmpty T > extends @NonEmpty Object {
        public void method() throws @NonEmpty Exception {           
        }
    }
         
    public static void main(String[] args) {
        final Holder< String > holder = new @NonEmpty Holder< String >();       
        @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();       
    }
}
```java



## Java 9 新特性

1. 模块系统

	模块是一个包的容器，Java 9 最大的变化之一是引入模块系统。（Jigsaw 项目）
	
	作用：解决大型项目模块化开发的需求。

2. 支持 HTTP/2 标准

	HTTP/2 标准是 HTTP 协议的最新版本，新的 HTTPClient API 支持 Websocket 和 HTTP2 流以及服务器推送特性。

	深入理解http1.x、http 2和https：https://segmentfault.com/a/1190000015316332

3. 提供创建不可变集合的静态工厂方法

	List、Set、Map 接口中，提供新的静态工厂方法直接创建不可变的集合实例。
	
	作用：创建不可变集合更方便，一行代码就搞定，节省了开销。

4. 私有接口方法

	在接口中也允许编写 private 修饰的私有方法了。

	作用：增强了接口的功能，提高了可扩展性。

5. 轻量级的 JSON API

	内置了一个轻量级的 JSON API。

6. 引入响应式流 API

	Java 9 引入了新的响应式流 API。


## Java11的新特性

1、本地变量类型推断

	什么是局部变量类型推断？
	
	var javastack = "javastack";
	
	System.out.println(javastack);
	
	大家看出来了，局部变量类型推断就是左边的类型直接使用 var 定义，而不用写具体的类型，编译器能根据右边的表达式自动推断类型，如上面的 String 。
	
	var javastack = "javastack";
	
	就等于：
	
	String javastack = "javastack";

2、字符串加强

	Java 11 增加了一系列的字符串处理方法，如以下所示。
	
	// 判断字符串是否为空白
	
	" ".isBlank(); // true
	
	// 去除首尾空格
	
	" Javastack ".strip(); // "Javastack"
	
	// 去除尾部空格
	
	" Javastack ".stripTrailing(); // " Javastack"
	
	// 去除首部空格
	
	" Javastack ".stripLeading(); // "Javastack "
	
	// 复制字符串
	
	"Java".repeat(3);// "JavaJavaJava"
	
	// 行数统计
	
	"A\nB\nC".lines().count(); // 3

3、集合加强

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

4、Stream 加强

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

		1) 增加单个参数构造方法，
		
		2) 增加 takeWhile 和 dropWhile 方法
		
		3）iterate重载
		
		这个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

5、Optional 加强

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

6、InputStream 加强

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

7、HTTP Client API

	这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API，该 API 支持同步和异步，而在 Java 11 中已经为正式可用状态，你可以在 java.net 包中找到这个 API。

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

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