zoukankan      html  css  js  c++  java
  • jdk8十大特性并代码demo(转)

    一、十大特性

    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)元空间

    二、demo

    demo基于junit可测。

    复制代码
      1 /**
      2  * 
      3  * @ClassName:JDK8_features
      4  * @Description:JDK8新特性
      5  * @author diandian.zhang
      6  * @date 2017年4月17日上午9:13:24
      7  */
      8 public class JDK8_features {
      9     
     10     public List<Integer> list = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
     11     
     12     /**
     13      * 1.Lambda表达式
     14      */
     15     @Test
     16     public void testLambda(){
     17         list.forEach(System.out::println);
     18         list.forEach(e -> System.out.println("方式二:"+e));
     19     }
     20     
     21     /**
     22      * 2.Stream函数式操作流元素集合
     23      */
     24     @Test
     25     public void testStream(){
     26         List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
     27         System.out.println("求和:"+nums
     28                 .stream()//转成Stream
     29                 .filter(team -> team!=null)//过滤
     30                 .distinct()//去重
     31                 .mapToInt(num->num*2)//map操作
     32                 .skip(2)//跳过前2个元素
     33                 .limit(4)//限制取前4个元素
     34                 .peek(System.out::println)//流式处理对象函数
     35                 .sum());//
     36     }
     37     
     38     /**
     39      * 3.接口新增:默认方法与静态方法
     40      *  default 接口默认实现方法是为了让集合类默认实现这些函数式处理,而不用修改现有代码
     41      *  (List继承于Iterable<T>,接口默认方法不必须实现default forEach方法)
     42      */
     43     @Test
     44     public void testDefaultFunctionInterface(){
     45         //可以直接使用接口名.静态方法来访问接口中的静态方法
     46         JDK8Interface1.staticMethod();
     47         //接口中的默认方法必须通过它的实现类来调用
     48         new JDK8InterfaceImpl1().defaultMethod();
     49         //多实现类,默认方法重名时必须复写
     50         new JDK8InterfaceImpl2().defaultMethod();
     51     }
     52     
     53     public class JDK8InterfaceImpl1 implements JDK8Interface1 {
     54         //实现接口后,因为默认方法不是抽象方法,重写/不重写都成!
     55 //        @Override
     56 //        public void defaultMethod(){
     57 //            System.out.println("接口中的默认方法");
     58 //        }
     59     }
     60     
     61     public class JDK8InterfaceImpl2 implements JDK8Interface1,JDK8Interface2 {
     62         //实现接口后,默认方法名相同,必须复写默认方法
     63         @Override
     64         public void defaultMethod() {
     65             //接口的
     66             JDK8Interface1.super.defaultMethod();
     67             System.out.println("实现类复写重名默认方法!!!!");
     68         }
     69     }
     70         
     71     /**
     72      * 4.方法引用,与Lambda表达式联合使用
     73      */
     74     @Test
     75     public void testMethodReference(){
     76         //构造器引用。语法是Class::new,或者更一般的Class< T >::new,要求构造器方法是没有参数;
     77         final Car car = Car.create( Car::new );
     78         final List< Car > cars = Arrays.asList( car );
     79         //静态方法引用。语法是Class::static_method,要求接受一个Class类型的参数;
     80         cars.forEach( Car::collide );
     81         //任意对象的方法引用。它的语法是Class::method。无参,所有元素调用;
     82         cars.forEach( Car::repair );
     83         //特定对象的方法引用,它的语法是instance::method。有参,在某个对象上调用方法,将列表元素作为参数传入;
     84         final Car police = Car.create( Car::new );
     85         cars.forEach( police::follow );
     86     }
     87     
     88     public static class Car {
     89         public static Car create( final Supplier< Car > supplier ) {
     90             return supplier.get();
     91         }              
     92              
     93         public static void collide( final Car car ) {
     94             System.out.println( "静态方法引用 " + car.toString() );
     95         }
     96              
     97         public void repair() {   
     98             System.out.println( "任意对象的方法引用 " + this.toString() );
     99         }
    100         
    101         public void follow( final Car car ) {
    102             System.out.println( "特定对象的方法引用 " + car.toString() );
    103         }
    104     }
    105     
    106     /**
    107      * 5.引入重复注解
    108      * 1.@Repeatable 
    109      * 2.可以不用以前的“注解容器”写法,直接写2次相同注解即可
    110      * 
    111      * Java 8在编译器层做了优化,相同注解会以集合的方式保存,因此底层的原理并没有变化。
    112      */
    113     @Test
    114     public void RepeatingAnnotations(){
    115         RepeatingAnnotations.main(null);
    116     }
    117     
    118     /**
    119      * 6.类型注解
    120      * 新增类型注解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER(在Target上)
    121      * 
    122      */
    123     @Test
    124     public void ElementType(){
    125         Annotations.main(null);
    126     }
    127     
    128     /**
    129      * 7.最新的Date/Time API (JSR 310)
    130      */
    131     @Test
    132     public void DateTime(){
    133         //1.Clock
    134         final Clock clock = Clock.systemUTC();
    135         System.out.println( clock.instant() );
    136         System.out.println( clock.millis() );
    137         
    138         //2. ISO-8601格式且无时区信息的日期部分
    139         final LocalDate date = LocalDate.now();
    140         final LocalDate dateFromClock = LocalDate.now( clock );
    141                  
    142         System.out.println( date );
    143         System.out.println( dateFromClock );
    144                  
    145         // ISO-8601格式且无时区信息的时间部分
    146         final LocalTime time = LocalTime.now();
    147         final LocalTime timeFromClock = LocalTime.now( clock );
    148                  
    149         System.out.println( time );
    150         System.out.println( timeFromClock );
    151         
    152         // 3.ISO-8601格式无时区信息的日期与时间
    153         final LocalDateTime datetime = LocalDateTime.now();
    154         final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
    155                  
    156         System.out.println( datetime );
    157         System.out.println( datetimeFromClock );
    158         
    159         // 4.特定时区的日期/时间,
    160         final ZonedDateTime zonedDatetime = ZonedDateTime.now();
    161         final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
    162         final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );
    163                  
    164         System.out.println( zonedDatetime );
    165         System.out.println( zonedDatetimeFromClock );
    166         System.out.println( zonedDatetimeFromZone );
    167         
    168         //5.在秒与纳秒级别上的一段时间
    169         final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );
    170         final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );
    171          
    172         final Duration duration = Duration.between( from, to );
    173         System.out.println( "Duration in days: " + duration.toDays() );
    174         System.out.println( "Duration in hours: " + duration.toHours() );
    175     }
    176     
    177     /**
    178      * 8.新增base64加解密API
    179      */
    180     @Test
    181     public void testBase64(){
    182         final String text = "就是要测试加解密!!abjdkhdkuasu!!@@@@";
    183         String encoded = Base64.getEncoder()
    184             .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
    185         System.out.println("加密后="+ encoded );
    186          
    187         final String decoded = new String( 
    188             Base64.getDecoder().decode( encoded ),
    189             StandardCharsets.UTF_8 );
    190         System.out.println( "解密后="+decoded );
    191     }
    192     
    193     /**
    194      * 9.数组并行(parallel)操作
    195      */
    196     @Test
    197     public void testParallel(){
    198         long[] arrayOfLong = new long [ 20000 ];        
    199         //1.给数组随机赋值
    200         Arrays.parallelSetAll( arrayOfLong, 
    201             index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
    202         //2.打印出前10个元素
    203         Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
    204             i -> System.out.print( i + " " ) );
    205         System.out.println();
    206         //3.数组排序
    207         Arrays.parallelSort( arrayOfLong );     
    208         //4.打印排序后的前10个元素
    209         Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
    210             i -> System.out.print( i + " " ) );
    211         System.out.println();
    212     }
    213     
    214     /**
    215      * 10.JVM的PermGen空间被移除:取代它的是Metaspace(JEP 122)元空间
    216      */
    217     @Test
    218     public void testMetaspace(){
    219         //-XX:MetaspaceSize初始空间大小,达到该值就会触发垃圾收集进行类型卸载,同时GC会对该值进行调整
    220         //-XX:MaxMetaspaceSize最大空间,默认是没有限制
    221         //-XX:MinMetaspaceFreeRatio在GC之后,最小的Metaspace剩余空间容量的百分比,减少为分配空间所导致的垃圾收集
    222         //-XX:MaxMetaspaceFreeRatio在GC之后,最大的Metaspace剩余空间容量的百分比,减少为释放空间所导致的垃圾收集
    223     }
    224     
    225 }
  • 相关阅读:
    常用 Git 命令清单
    谈谈关于PHP的代码安全相关的一些致命知识
    九个Console命令,让 JS 调试更简单
    有趣的博客小工具
    利用fputcsv导出数据备份数据
    IT小天博客APP版本
    七牛云存储文件批量下载工具使用教程
    Mysql的常见几种错误:1045,1044
    我是一个线程
    两行代码快速创建一个iOS主流UI框架
  • 原文地址:https://www.cnblogs.com/panxuejun/p/8673250.html
Copyright © 2011-2022 走看看