Jdk8的新特性

Posted 2020-11-20 jike1219

jdk1.8的新特性

 

  我知道现在发jdk8的新特性纯属搞笑，jdk9都在流行呢，但是我确实真的新接触jdk1.8.下面我从网上找找资料看看jdk有哪些常用的特性。

 

一. 接口的默认方法

jdk1.8实现了接口可以有静态方法和默认方法： 

interface TestInterface {

      double calculate(double a);

       //这个是jdk1.8默认方法
     default double get(double a){
     System.out.println("我是默认实现方法...");
      return Math.sqrt(a);
}
     String aa="2222";

     //这个是jdk1.8静态方法
    static void staticmethod(){

    System.out.println("我是静态方法"+aa);}
}

 

TestInterface 接口在calculate方法之外同时还定义了get方法，实现了TestInterface 接口的子类只需要实现一个calculate方法，默认的方法将在子类上可以直接使用

TestInterface  test = new TestInterface (){

    @Override
    public double calculate(double a) {
        return get(a * 100);
    }

};

   test.calculate(100); //100.0

   test.get(16); //4.0

 

二.Lambda 表达式

lambda表达式提供了更简洁语法，使得代码更加具有可读性，方便极了！

    List<String> names = Arrays.asList("付达", "班乐乐", "王文星", "梅文和","love");

来看看以前对一个存放String类型的数组按照指定顺序依靠比较器来给names排序
    Collections.sort(names, new Comparator<String>() {
        @Override
        public int compare(String a, String b) {
               return b.compareTo(a);
          }
     });
     for(String name:names){
     System.out.println(name);
      }

那接下来使用lambda表达式来简化：

  Collections.sort(names,(String a,String b) ->{return b.compareTo(a)});

   还可以更短  Collections.sort(names,(a,b)->b.compareTo(a)); //因为java编译器可以自动的推导出参数类型，所以不必要再写一次类型，当函数体只有一行代码的话还可以去掉{}以及return关键字。

 

三.函数式接口与静态导入

Lambda表达式是如何在java的类型系统中表示的呢？每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。

 

我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

     public static void main(String[] args) {
    Converter<String, Integer> a = (from) -> Integer.valueOf(from);

    //Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用
    Converter<String, Integer> converter = Integer::valueOf;//这个是静态方式导入

      Integer m=a.convert("123");
       System.out.println(m);
       test test=mmm -> "aaaa";//mmm代表你要传入的参数
       String testResult=test.aa("");//aa代表你要传入的方法
       System.out.println(testResult);
}

@FunctionalInterface
interface Converter<F, T> {
          T convert(F from);
}

interface test{
          String aa(String mmm);
}

//使用函数式接口时，接口的定义只能有一个，@FunctionalInterface注解可有可无

 

四.方法和构造函数的引用

 Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用，下面的代码展示了如何引用一个静态方法

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

我们也可以引用一个对象的方法：

 converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

也可以引用一个类构造函数

首先定义一个包含多个构造函数的Person类

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

然后指定一个用来创建Person对象的对象工厂接口：

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

这里我们使用构造函数引用来将他们关联起来，而不是实现一个完整的工厂：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我们只需要使用Person:new 来获取Person类构造函数的引用，Java编译器会自动的根据PersonFactory.create方法来选择合适的构造方法；

 

五.Lambda 作用域

在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。可以直接访问标记final的外层的局部变量，或者实例的字段以及静态变量。

 

六.访问局部变量

final int num = 1;
Converter<Integer, String> stringConverter =(from) -> String.valueOf(from + num);
String str=stringConverter.convert(2);
System.out.println(str);//输出3
//final关键字可以去掉，但是默认是存在的，所以，对num变量不能再次赋值修改
}

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

 

七.访问对象字段与静态变量

public class Test {
        public static void main(String[] args) {
        Lambda4 lambda4=new Lambda4();
        lambda4.testScopes();
}

@FunctionalInterface
interface Converter<F, T> {
         T convert(F from);
}

static class Lambda4 {
       static int outerStaticNum=0;
       int outerNum=0;
       void testScopes() {
              Converter<Integer, String> stringConverter1 = (from) -> {outerNum = 23;return String.valueOf(outerNum);};
              String a=stringConverter1.convert(outerNum);
              System.out.println(a);//输出23
              Converter<Integer, String> stringConverter2 = (from) -> {
                     outerStaticNum = 72;
                     return String.valueOf(outerStaticNum);
                 };

             }
      }
//这里的意思是outerStaticNum与outerNum两个参数可以多次赋值
}

 

七.访问对象字段与静态变量

和本地变量不同的是，lanbda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的：

class Lambda4 {
    static int outerStaticNum;
    int outerNum;

    void testScopes() {
        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };

        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
}

 

八.访问接口的默认方法

第一个例子中接口TestInterface定义了一个默认方法get可以直接被formula的实例包含匿名对象访问到，但是在lambda表达式是不行的。Lambda表达式中是无法访问到默认方法的，以下代码将无法编译：

Formula formula = (a) -> sqrt( a * 100);
Built-in Functional Interfaces

JDK 1.8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，这些接口都增加了@FunctionalInterface注解以便能用在lambda上。

 

九.Data API

Java8在包java.time下包含了一组权限的时间日期API。新的日期API和开源的Joda-Time库差不多，但又不完全相同。

Clock 时钟，Timezones 时区，LocalTime 本地时间，LocalDate 本地日期，LocalDateTime 本地日期时间

 

十.Annotation注解

Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下@Repeatable即可。

@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}