jdk8 特性

1、十大特性。

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）元空間

 

junit測試

/**
 * 
 * @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<>();       
    }
}

 

摘自，https://www.cnblogs.com/dennyzhangdd/p/6722445.html