java8新特性实践

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xcg132566/article/details/79295359

Lambda表达式

  • Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中),或者把代码看成数据

  • 最简单的形式中,一个lambda可以由用逗号分隔的参数列表、–>符号与函数体三部分表示:

    Arrays.asList( 1, 2, 3 ).forEach( e -> System.out.println( e ) );
    
  • Lambda可以引用类的成员变量与局部变量(如果这些变量不是final的话,它们会被隐含的转为final,这样效率更高):

    String str = ",";           //等价于:final String str = ",";
    Arrays.asList( "a", "b", "c" ).forEach( 
        ( String e ) -> System.out.print( e + str ) );  
    
  • Lambda可能会返回一个值。返回值的类型也是由编译器推测出来的。如果lambda的函数体只有一行的话,那么没有必要显式使用return语句:

    List<Integer> list = Arrays.asList( 4, 2, 1,3);
    list.sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
    list.forEach(e->System.out.println(e)); 
    

函数式接口

  • 如何使现有的函数友好地支持lambda,java8采取了增加函数式接口的概念。
  • 函数式接口就是一个只有一个方法的普通接口,可以隐式的转换成lambda表达式,除了特殊方法:默认方法,静态方法以及继承自Object类的一些方法(toString(),equels()等)
  • 在使用中,函数式接口容易出错,如果接口中被定义了另一个方法,那么接口将不再是函数式接口,导致编译失败。为此Java8新增注解@FunctionalInterface。注意default默认方法和静态方法不会影响函数式接口。

    @FunctionalInterface
    public interface Runnable {
        public abstract void run();
    }
    
  • java8新增默认方法和静态方法扩展接口的声明。

    public interface Convert {
    
        //可以包含静态方法
        public static void hasStaticMethod(){
            System.out.println("包含静态方法");
        }
    
        default void hasDefaultMethod(){
            System.out.println("包含默认方法");
        }
    }
    
  • 函数式接口示例

    @FunctionalInterface
    public interface Convert<F,T> {
    
        T convert(F from);
    
        //可以包含静态方法
        public static void hasStaticMethod(){
            System.out.println("包含静态方法");
        }
    
        default void hasDefaultMethod(){
            System.out.println("包含默认方法");
        }
    }
    
    public class ConvertMain {
    public static void main(String[] args) {
    
        Convert<String, Integer> converter = (from) -> Integer.valueOf(from);
        Integer converted = converter.convert("123");
        System.out.println(converted);
        converter.hasDefaultMethod();
        Convert.hasStaticMethod();
    
    
        // Function<T, R> -T作为输入,返回的R作为输出
        Function<String,String> function = (x) -> {System.out.print(x+": ");return "Function";};
        System.out.println(function.apply("hello world"));
    
        //Predicate<T> -T作为输入,返回的boolean值作为输出
        Predicate<String> pre = (x) ->{System.out.print(x);return false;};
        System.out.println(": "+pre.test("hello World"));
    
        //Consumer<T> - T作为输入,执行某种动作但没有返回值
        Consumer<String> con = (x) -> {System.out.println(x);};
        con.accept("hello world");
    
        //Supplier<T> - 没有任何输入,返回T
        Supplier<String> supp = () -> {return "Supplier";};
        System.out.println(supp.get());
    
    
        //BinaryOperator<T> -两个T作为输入,返回一个T作为输出,对于“reduce”操作很有用
        BinaryOperator<String> bina = (x,y) ->{System.out.print(x+" "+y);return "BinaryOperator";};
        System.out.println("  "+bina.apply("hello ","world"));
    
    }
    

    }

方法引用(::)

  • 以直接引用已有Java类或对象(实例)的方法或构造器。与lambda联合使用

  • 第一种方法引用是构造器引用,它的语法是Class::new,或者更一般的Class< T >::new。请注意构造器没有参数。

    final Car car = Car.create( Car::new );
    final List< Car > cars = Arrays.asList( car );
    
  • 第二种方法引用是静态方法引用,它的语法是Class::static_method。请注意这个方法接受一个Car类型的参数。

    cars.forEach( Car::collide );
    
  • 第三种方法引用是特定类的任意对象的方法引用,它的语法是Class::method。请注意,这个方法没有参数。

    cars.forEach( Car::repair );
    
  • 最后,第四种方法引用是特定对象的方法引用,它的语法是instance::method。请注意,这个方法接受一个Car类型的参数

    final Car police = Car.create( Car::new );
    cars.forEach( police::follow );     
    
    
    private void sort(){
        List<Commodity> commodities=new ArrayList<>();
        //java 8之前
        commodities.sort(new Comparator<Commodity>() {
        @Override
        public int compare(Commodity o1, Commodity o2) {
                return o1.getPrice()-o2.getPrice();
            }
        });
        //java 8 lambda的写法
        commodities.sort((Commodity o1,Commodity o2)->o1.getPrice()-o2.getPrice());
        //java 8 方法应用的写法
        commodities.sort(Comparator.comparing(Commodity::getPrice));
    }
    

重复注解

  • java5开始引用注解机制,然而相同注解在同样的地方只能声明一次,java8引入重复注解。

  • 重复注解机制本身必须用@Repeatable注解。事实上是编译器技巧的改变

更好的类型推断

  • Java 8在类型推测方面有了很大的提高。在很多情况下,编译器可以推测出确定的参数类型,这样就能使代码更整洁。

    public class Value< T > {
        public static< T > T defaultValue() { 
            return null; 
        }
    
        public T getOrDefault( T value, T defaultValue ) {
            return ( value != null ) ? value : defaultValue;
        }
    }
    
    public class TypeInference {
        public static void main(String[] args) {
            final Value< String > value = new Value<>();
            value.getOrDefault( "22", Value.defaultValue() );
        }
    }
    

扩展注解的支持

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

    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 {           
            }
        }
    
        @SuppressWarnings( "unused" )
        public static void main(String[] args) {
            final Holder< String > holder = new @NonEmpty Holder< String >();       
            @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();       
        }
    }
    

    ElementType.TYPE_USE和ElementType.TYPE_PARAMETER是两个新添加的用于描述适当的注解上下文的元素类型。

Optional

  • 新增类库,为解决java中常见的空指针异常导致程序无法正常运行

  • Optional实际上是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

    //允许为空值,当值为空时也不会报错
    Optional< String > name = Optional.ofNullable( null );
    System.out.println( "name是否有值 " + name.isPresent() );        
    System.out.println( "如果名称为空: " + name.orElseGet( () -> "代替名称" ) ); 
    System.out.println( name.map( s -> "名称为: " + s  ).orElse( "名称为空" ) );
    
    //不允许为空值,当值为空时会报错
    Optional< String > firstName = Optional.of( "name" );
    System.out.println( "firstName是否有值 " + firstName.isPresent() );        
    System.out.println( "如果名称为空: " + firstName.orElseGet( () -> "代替名称" ) ); 
    System.out.println( firstName.map( s -> "名称为: " + s  ).orElse( "名称为空" ) );
    

    Optional文档

Stream

  • 把真正的函数式编程风格引入到Java中。简化了集合框架的处理。

    public class Streams  {
        private enum Status {
            OPEN, CLOSED
        };
    
        private static final class Task {
            private final Status status;
            private final Integer points;
    
            Task( final Status status, final Integer points ) {
                this.status = status;
                this.points = points;
            }
    
            public Integer getPoints() {
                return points;
            }
    
            public Status getStatus() {
                return status;
            }
    
            @Override
            public String toString() {
                return String.format( "[%s, %d]", status, points );
            }
        }
    }
    
    //task集合
    final Collection< Task > tasks = Arrays.asList(
        new Task( Status.OPEN, 5 ),
        new Task( Status.OPEN, 13 ),
        new Task( Status.CLOSED, 8 ) 
    );
    
    
    //所有状态为OPEN的任务一共有多少分数
    final long totalPointsOfOpenTasks = tasks
        .stream()
        .filter( task -> task.getStatus() == Status.OPEN )
        .mapToInt( Task::getPoints )
        .sum();
    
    System.out.println( "Total points: " + totalPointsOfOpenTasks );
    

    首先,task集合被转换化为stream。然后,filter操作过滤掉状态为CLOSED的task。下一步,mapToInt操作通过Task::getPoints方法调用把Task的stream转化为Integer的stream。最后,用sum函数把所有的分数加起来,得到最终的结果。

    stream注意事项:Ops

  • .stream操作被分成了中间操作与最终操作,中间操作返回一个新的stream对象。中间操作总是采用惰性求值方式,运行一个像filter这样的中间操作实际上没有进行任何过滤,相反它在遍历元素时会产生了一个新的stream对象,这个新的stream对象包含原始stream中符合给定谓词的所有元素。

  • 像forEach、sum这样的最终操作可能直接遍历stream,产生一个结果。当最终操作执行结束之后,stream管道被认为已经被消耗了,不能再使用。在大多数情况下,最终操作都是采用及早求值方式,及早完成底层数据源的遍历

  • stream另一个有价值的地方是能够原生支持并行处理

    final double totalPoints = tasks
       .stream()
       .parallel()
       .map( task -> task.getPoints() ) // or map( Task::getPoints ) 
       .reduce( 0, Integer::sum );
    
    System.out.println( "Total points (all tasks): " + totalPoints );
    
    
    //按照某种准则来对集合中的元素进行分组。
    final Map< Status, List< Task > > map = tasks
        .stream()
        .collect( Collectors.groupingBy( Task::getStatus ) );
    System.out.println( map );
    
    //计算整个集合中每个task分数(或权重)的平均值来结束task
    final Collection< String > result = tasks
        .stream()                                        // Stream< String >
        .mapToInt( Task::getPoints )                     // IntStream
        .asLongStream()                                  // LongStream
        .mapToDouble( points -> points / totalPoints )   // DoubleStream
        .boxed()                                         // Stream< Double >
        .mapToLong( weigth -> ( long )( weigth * 100 ) ) // LongStream
        .mapToObj( percentage -> percentage + "%" )      // Stream< String> 
        .collect( Collectors.toList() );                 // List< String > 
    
    System.out.println( result );
    
  • Stream API不仅仅处理Java集合框架。像从文本文件中逐行读取数据这样典型的I/O操作也很适合用Stream API来处理

    final Path path = new File( filename ).toPath();
    try( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {
        lines.onClose( () -> System.out.println("Done!") ).forEach( System.out::println );
    }
    

    对一个stream对象调用onClose方法会返回一个在原有功能基础上新增了关闭功能的stream对象,当对stream对象调用close()方法时,与关闭相关的处理器就会执行。

Date/Time API (JSR 310)

  • Joda-Time——一个可替换标准日期/时间处理且功能非常强大的Java API

  • 新的java.time包涵盖了所有处理日期,时间,日期/时间,时区,时刻(instants),过程(during)与时钟(clock)的操作

  • Clock类,它通过指定一个时区,然后就可以获取到当前的时刻,日期与时间。Clock可以替换System.currentTimeMillis()与TimeZone.getDefault()。

    final Clock clock = Clock.systemUTC();
    System.out.println( clock.instant() );
    System.out.println( clock.millis() );
    
  • LocaleDate与LocalTime。LocaleDate只持有ISO-8601格式且无时区信息的日期部分。相应的,LocaleTime只持有ISO-8601格式且无时区信息的时间部分。LocaleDate与LocalTime都可以从Clock中得到

    final LocalDate date = LocalDate.now();
    final LocalDate dateFromClock = LocalDate.now( clock );
    
    System.out.println( date );
    System.out.println( dateFromClock );
    
    // Get the local date and local time
    final LocalTime time = LocalTime.now();
    final LocalTime timeFromClock = LocalTime.now( clock );
    
    System.out.println( time );
    System.out.println( timeFromClock );
    
  • LocaleDateTime把LocaleDate与LocaleTime的功能合并起来,它持有的是ISO-8601格式无时区信息的日期与时间。

    final LocalDateTime datetime = LocalDateTime.now();
    final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
    
    System.out.println( datetime );
    System.out.println( datetimeFromClock );
    
  • 如果你需要特定时区的日期/时间,可以使用ZonedDateTime。它持有ISO-8601格式具具有时区信息的日期与时间

    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 );
    
  • Duration类:Duration使计算两个日期间的差变的十分简单。

    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() );
    

JavaScript引擎Nashorn

  • Nashorn,一个新的JavaScript引擎随着Java 8一起公诸于世,它允许在JVM上开发运行某些JavaScript应用。Nashorn就是javax.script.ScriptEngine的另一种实现,并且它们俩遵循相同的规则,允许Java与JavaScript相互调用。

    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName( "JavaScript" );
    
    System.out.println( engine.getClass().getName() );
    System.out.println( "Result:" + engine.eval( "function f() { return 1; }; f() + 1;" ) );
    

Base64:Java 8中,Base64编码已经成为Java类库的标准。

        import java.nio.charset.StandardCharsets;
        import java.util.Base64;

        public class Base64Test {
            public static void main(String[] args) {
                final String text = "Base64 finally in Java 8!";

                final 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 );
            }
        }

    Base64类同时还提供了对URL、MIME友好的编码器与解码器(Base64.getUrlEncoder() / Base64.getUrlDecoder(), Base64.getMimeEncoder() / Base64.getMimeDecoder())。

并行(parallel)数组

  • Java 8增加了大量的新方法来对数组进行并行处理。可以说,最重要的是parallelSort()方法,因为它可以在多核机器上极大提高数组排序的速度。

        import java.util.Arrays;
        import java.util.concurrent.ThreadLocalRandom;
    
        public class ParallelArrays {
            public static void main( String[] args ) {
                long[] arrayOfLong = new long [ 20000 ];        
    
                Arrays.parallelSetAll( arrayOfLong, 
                    index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
                Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
                    i -> System.out.print( i + " " ) );
                System.out.println();
    
                Arrays.parallelSort( arrayOfLong );     
                Arrays.stream( arrayOfLong ).limit( 10 ).forEach( 
                    i -> System.out.print( i + " " ) );
                System.out.println();
            }
        }
    
    上面的代码片段使用了parallelSetAll()方法来对一个有20000个元素的数组进行随机赋值。然后,调用parallelSort方法。这个程序首先打印出前10个元素的值,之后对整个数组排序。
    

并发(Concurrency)

  • 在新增Stream机制与lambda的基础之上,在java.util.concurrent.ConcurrentHashMap中加入了一些新方法来支持聚集操作。同时也在java.util.concurrent.ForkJoinPool类中加入了一些新方法来支持共有资源池(common pool)

  • 新增的java.util.concurrent.locks.StampedLock类提供一直基于容量的锁,这种锁有三个模型来控制读写操作(它被认为是不太有名的java.util.concurrent.locks.ReadWriteLock类的替代者)。

    在java.util.concurrent.atomic包中还增加了下面这些类:

    DoubleAccumulator
    DoubleAdder
    LongAccumulator
    LongAdder
    

类依赖分析器jdeps

  • jdeps是一个很有用的命令行工具。它可以显示Java类的包级别或类级别的依赖。它接受一个.class文件,一个目录,或者一个jar文件作为输入。jdeps默认把结果输出到系统输出(控制台)上。

    jdeps org.springframework.core-3.0.5.RELEASE.jar    
    

Java虚拟机(JVM)的新特性

  • PermGen空间被移除了,取而代之的是Metaspace(JEP 122)。JVM选项-XX:PermSize与-XX:MaxPermSize分别被-XX:MetaSpaceSize与-XX:MaxMetaspaceSize所代替。

参考:Java 8 Features Tutorial
github:示例

阅读更多
换一批

没有更多推荐了,返回首页