jdk8的特性

旧城等待， 2022-05-18 22:19 142阅读 0赞

### **1语言新特性** ###

1）新增了lambda表达式 和函数接口

Lambda表达式实例：

Arrays.asList( "a", "b", "d" ).forEach( e -> {
        System.out.print( e );
        System.out.print( e );
    } );

遍历：list.forEach(a -> System.out.println(a+""));  
过滤：List<Integer> list1 = list.stream().filter(a -> a>3).collect(Collectors.toList());  
判空： stream.filter(x -> x.getDateTime()!=null)  
排序：userList.sort(Comparator.comparing(User::getId).thenComparing(User::getAge));  
去重：idList.stream().distinct().collect(Collectors.toList());  
分组：userList.stream().collect(Collectors.groupingBy(User::getSex));

list转map和list

String[] departments = new String[] {"iERP", "iERP", "EIBU"}; 
    Map<Integer, String> map = Arrays.stream(departments)
          // key:hashCOde value:值 hashCode重复是取后面的
            .collect(Collectors.toMap(String::hashCode, str -> str, (v1, v2) -> v2));
    System.out.println(DateUtil.getYesterdayStr("YYYY-MM-dd"));

List<String> classNotOptionPracId = 
    practiceList.stream()// 转成流
    .filter(p -> p.getIsOptional() == ZeroOrOneEnum.ZERO.value)// 过滤，仍然返回stream
    .map(Practice::getId)// 只要id属性，返回stream
    .collect(Collectors.toList());// stream转list

这个问题阿里面试被问过。

函数接口：

函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface（Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：

@FunctionalInterface
    public interface FunctionalDefaultMethods {
        void method();
        default void defaultMethod() {            
        }        
    }

2）静态接口中增加-默认方法和静态方法

默认方法声明方式就是在方法前增加default关键字和方法体，则此时实现该接口的方法可以重写该方法，也可以直接使用默认方法

private interface Defaulable {
        // Interfaces now allow default methods, the implementer may or
        // may not implement (override) them.
        default String notRequired() {
            return "Default implementation";
        }        
    }
     //此时使用Defaulable 中的默认方法
    private static class DefaultableImpl implements Defaulable {
    }
    private static class OverridableImpl implements Defaulable {
        @Override
        public String notRequired() {
            return "Overridden implementation";
        }
    }

接口中定义静态方法

private interface DefaulableFactory {
        // Interfaces now allow static methods
        static Defaulable create( Supplier< Defaulable > supplier ) {
            return supplier.get();
        }
    }

调用方式如下

public static void main( String[] args ) {
        Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
        System.out.println( defaulable.notRequired() );
        defaulable = DefaulableFactory.create( OverridableImpl::new );
        System.out.println( defaulable.notRequired() );
    }

3)方法引用：方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象

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( "Collided " + car.toString() );
        }
        public void follow( final Car another ) {
            System.out.println( "Following the " + another.toString() );
        }
        public void repair() {   
            System.out.println( "Repaired " + this.toString() );
        }
    }

第一种方法引用的类型是构造器引用，语法是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 )

4)重复注解的定义

自从Java 5中引入注解以来，这个特性开始变得非常流行，并在各个框架和项目中被广泛使用。不过，注解有一个很大的限制是：在同一个地方不能多次使用同一个注解。Java 8打破了这个限制，引入了重复注解的概念，允许在同一个地方多次使用同一个注解。

在Java 8中使用@Repeatable注解定义重复注解，实际上，这并不是语言层面的改进，而是编译器做的一个trick，底层的技术仍然相同。可以利用下面的代码说明：

package com.javacodegeeks.java8.repeatable.annotations;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Repeatable;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    
    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();
        };
    
        @Filter( "filter1" )
        @Filter( "filter2" )
        public interface Filterable {        
        }
    
        public static void main(String[] args) {
            for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
                System.out.println( filter.value() );
            }
        }
    }

正如我们所见，这里的Filter类使用@Repeatable(Filters.class)注解修饰，而Filters是存放Filter注解的容器，编译器尽量对开发者屏蔽这些细节。这样，Filterable接口可以用两个Filter注解注释（这里并没有提到任何关于Filters的信息）。

另外，反射API提供了一个新的方法：getAnnotationsByType()，可以返回某个类型的重复注解，例如Filterable.class.getAnnoation(Filters.class)将返回两个Filter实例，输出到控制台的内容如下所示：

filter1

filter2

5）类型推断方面的增强

Java 8编译器在类型推断方面有很大的提升，在很多场景下编译器可以推导出某个参数的数据类型，从而使得代码更为简洁

6） 拓宽注解的应用场景

Java 8拓宽了注解的应用场景。现在，注解几乎可以使用在任何元素上：局部变量、接口类型、超类和接口实现类，甚至可以用在函数的异常定义上。

### **2Java编译器的新特性** ###

运行时获得Java程序中方法的参数名称，老一辈的Java程序员必须使用不同方法，例如Paranamer liberary。Java 8终于将这个特性规范化，在语言层面（使用反射API和Parameter.getName()方法）和字节码层面（使用新的javac编译器以及-parameters参数）提供支持。

package com.javacodegeeks.java8.parameter.names;
    
    import java.lang.reflect.Method;
    import java.lang.reflect.Parameter;
    
    public class ParameterNames {
        public static void main(String[] args) throws Exception {
            Method method = ParameterNames.class.getMethod( "main", String[].class );
            for( final Parameter parameter: method.getParameters() ) {
                System.out.println( "Parameter: " + parameter.getName() );
            }
        }
    }

在Java 8中这个特性是默认关闭的，因此如果不带-parameters参数编译上述代码并运行，则会输出如下结果：

Parameter: arg0

如果带-parameters参数，则会输出如下结果（正确的结果）：

Parameter: args

如果你使用Maven进行项目管理，则可以在maven-compiler-plugin编译器的配置项中配置-parameters参数：

<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
            <compilerArgument>-parameters</compilerArgument>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>

### **3java官方库的新特性** ###

1）Optional

Optional仅仅是一个容易：存放T类型的值或者null。它提供了一些有用的接口来避免显式的null检查，可以参考Java 8官方文档了解更多细节。

2）Streams

Steam API极大得简化了集合操作（后面我们会看到不止是集合）

3）Date类

新增了clock，**LocalDate**和**LocalTime**类，**Duration**类

4）Base64

对Base64编码的支持已经被加入到Java 8官方库中

### **4 新的Java工具** ###

Java 8提供了一些新的命令行工具，这部分会讲解一些对开发者最有用的工具。

4.1 Nashorn引擎：jjs