Java8知识梳理

Java 8 的改进

  • 速度更快
  • 代码更少(Lambda表达式
  • 引入强大的Stream API
  • 便于并行
  • 最大化减少空指针异常(Optional
  • Nashorn引擎,允许在JVM上运行js应用
  • 并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。相比较串行的流,并行的流可以很大程度上提高程序的执行效率。

一、Lambda 表达式

  • Lambda表达式的重要特征
  • 可选用类型声明:不需要声明参数类型,编译器可以统一识别参数值。
  • 可选用的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
  • 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
  • 可选的返回关键字:如果主体只有一个表达式,返回值则编译器会自动返回值,大括号需要指定表达式返回了一个数值。(即return…)
  • Lambda表达式是对象,而不是函数。
  • Lambda表达式基本语法
  1. 举例:

    (o1,o2) -> Integer.compare(o1,o2);
    
  2. 格式:

  • -> :lambda 操作符 或 箭头操作符
  • -> 左边:lambda 形参列表 (其实就是接口中的抽象方法的形参列表)
  • -> 右边:lambda 体(其实就是重写的抽象方法的方法体)
  • 举例
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));//10 + 5 = 15
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));//10 - 5 = 5
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));//10 x 5 = 50
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));//10 / 5 = 2
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");//Hello Runoob
      greetService2.sayMessage("Google");//Hello Google
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

  • 变量作用域
  1. lambda 表达式只能引用标记了 final 的外层局部变量,即不能在 lambda 内部修改定义在域外的局部变量,否则会编译错误。
public class Java8Tester {
    public static void main(String args[]) {
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));//访问外层的局部变量num
        s.convert(2);  // 输出结果为 3
    }
 
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}
  1. lambda 表达式的局部变量可以不用声明为 final,但是必须不可被后面的代码修改(即隐性的具有 final 的语义
int num = 1;  
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;  
//报错信息:Local variable num defined in an enclosing scope must be final or effectively final
  1. 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量

    String first = "";  
    Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错 
    
  • Lambda表达式的本质:作为函数式接口的实例(关于函数式接口的概念在下一点)

二、函数式接口

  • 什么是函数式接口

​ 如果一个接口中,只声明了一个抽象方法,则此接口就称为函数式接口。在接口中加上@FunctionalInterface注解可以用于检验该接口是否为一个函数式接口。

  • 四大核心函数式接口

public class LambdaTest3 {
    //消费型接口 Consumer<T>     void accept(T t)
    @Test
    public void test1() {
        //未使用Lambda表达式
        Learn("java", new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("学习什么? " + s);
            }
        });
        System.out.println("====================");
        //使用Lambda表达
        Learn("html", s -> System.out.println("学习什么? " + s));

    }

    private void Learn(String s, Consumer<String> stringConsumer) {
        stringConsumer.accept(s);
    }

    //供给型接口 Supplier<T>     T get()
    @Test
    public void test2() {
        //未使用Lambda表达式
        Supplier<String> sp = new Supplier<String>() {
            @Override
            public String get() {
                return new String("我能提供东西");
            }
        };
        System.out.println(sp.get());
        System.out.println("====================");
        //使用Lambda表达
        Supplier<String> sp1 = () -> new String("我能通过lambda提供东西");
        System.out.println(sp1.get());
    }

    //函数型接口 Function<T,R>   R apply(T t)
    @Test
    public void test3() {
        //使用Lambda表达式
        Employee employee = new Employee(1001, "Tom", 45, 10000);

        Function<Employee, String> func1 =e->e.getName();
        System.out.println(func1.apply(employee));
        System.out.println("====================");

        //使用方法引用
        Function<Employee,String> func2 = Employee::getName;
        System.out.println(func2.apply(employee));

    }

    //断定型接口 Predicate<T>    boolean test(T t)
    @Test
    public void test4() {
        //使用匿名内部类
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };
        System.out.println(func.apply(10.5));
        System.out.println("====================");

        //使用Lambda表达式
        Function<Double, Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.3));
        System.out.println("====================");

        //使用方法引用
        Function<Double,Long>func2 = Math::round;
        System.out.println(func2.apply(12.6));

    }
}
  • 其他函数式接口


三、方法引用

  • 方法引用就是Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法。(Lambda表达式深层次的表达)

  • 当要传递给Lambda体的操作,已经有实现的方法了,就可以使用方法引用。

  • 4种不同方法的引用

现有一个Car类如下:

@FunctionalInterface
public interface Supplier<T> {
 T get();
}

class Car {
 //Supplier是jdk1.8的接口,这里和lamda一起使用了
 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());
 }
}
  1. 构造器引用Class::new

    final Car car = Car.create( Car::new );
    final List< Car > cars = Arrays.asList( car );
    
  2. 静态方法引用Class::static_method

    cars.forEach( Car::collide );
    
  3. 特定类的任意对象的方法引用Class::method

    cars.forEach( Car::repair );
    
  4. 特定对象的方法引用instance::method

    final Car police = Car.create( Car::new );
    cars.forEach( police::follow );
    
  • 数组引用

    public void test4() {
        Function<Integer, String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));
    
        System.out.println("====================");
    
        //使用方法引用
        Function<Integer,String[]> func2 = String[]::new;  //数组引用
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));
    }
    

三、Stream API

  • Java8中有两大最为重要的改变。第一个是Lambda 表达式;另外一个则是Stream API。

  • Stream API ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充,因为Stream API可以极大提供Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。

  • Stream 是Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简言之,Stream API 提供了一种高效且易于使用的处理数据的方式。

  • 为什么要使用Stream API:实际开发中,项目中多数数据源都来自于Mysql,Oracle等。但现在数据源可以更多了,有MongDB,Radis等,而这些NoSQL的数据就需要Java层面去处理。

  • Stream 和Collection 集合的区别:Collection 是一种静态的内存数据结构,而Stream 是有关计算的。前者是主要面向内存,存储在内存中,后者主要是面向CPU,通过CPU 实现计算

  • 注意

    1. Stream自己不会存储元素
    2. Stream不会改变源对象。相反,他们会返回一个持有结果的新Stream
    3. Stream操作是延迟执行的。
  • Stream的操作三个步骤

  1. Stream的实例化:一个数据源(如集合、数组),获取一个流

    //创建Stream的方式一:通过集合
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
    
        //default Stream<E> stream():返回一个顺序流
        Stream<Employee> stream = employees.stream();
    
        //default Stream<E> parallelStream():返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }
    
    //创建Stream方式二:通过数组
    public void test2(){
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        //调用Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);//int数组
    
        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jerry");
        Employee[] arr1 = new Employee[]{e1, e2};
        Stream<Employee> stream2 = Arrays.stream(arr1);//Employee类数组
    }
    
    //创建Stream方式三:通过Stream的of()函数
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);//这里的1~6不是int类型数据,而是一个包装类 
    }
    
    //创建Stream方式四:创建无限流
    public void test4(){
        //①迭代
        //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t->t+2).limit(10).forEach(System.out::println);
    
        //②生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        //输出10个随机数
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
    
    • 顺序流与并行流的区别:顺序流的集合元素时按存入顺序储存的,取出时按顺序取出;并行流的集合元素是并行存储的,取出时是随机的。

  1. 一系列的中间操作:一个中间操作链,对数据源的数据进行处理。多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理,称为“惰性求值”。

    2.1 筛选与切片

    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Employee> employeeStream = employees.stream();
    
        //filter(Predicate p)——接收 Lambda , 从流中排除某些元素。
        employeeStream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);//查询员工表中薪资大于7000的员工信息
        System.out.println();
    
        //limit(n)——截断流,使其元素不超过给定数量。
        employees.stream().limit(3).forEach(System.out::println);//因为上一条代码中的Stream已经执行了终止操作,所以不能使用【employeeStream.limit(3).forEach(System.out::println)】,而是要重新创建一个Stream
        System.out.println();
    
        //skip(n) —— 跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个,则返回一个空流。与 limit(n) 互补
        employees.stream().skip(3).forEach(System.out::println);
        System.out.println();
    
        //distinct()——筛选,通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        employees.add(new Employee(1010,"刘庆东",56,8000));
        employees.add(new Employee(1010,"刘庆东",56,8000));
        employees.add(new Employee(1010,"刘庆东",56,8000));
        employees.add(new Employee(1010,"刘庆东",56,8000));
    
        employees.stream().distinct().forEach(System.out::println);
    }
    

    2.2 映射

    public void test2(){
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        //map(Function f)——接收一个函数作为参数,将元素转换成其他形式或提取信息,该函数会被应用到每个元素上,并将其映射成一个新的元素。
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        //练习1:获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(name -> name.length() >3).forEach(System.out::println);
        System.out.println();
        //练习2:使用map()中间操作实现flatMap()中间操作方法
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest2::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println();
    
        //flatMap(Function f)——接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest2::fromStringToStream);
        characterStream.forEach(System.out::println);
    
        //🔺map和flatMap区别:map——直接用转换后的元素替换流中的元素,flatMap——如果转换后的元素是一个流,会将该流中的元素依次取出,然后放入父流中
    }
    
    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character>fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c :
             str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
    
    //map()和flatMap()方法类似于List中的add()和addAll()方法
    @Test
    public void test(){
        ArrayList<Object> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
    
        ArrayList<Object> list2 = new ArrayList<>();
        list2.add(5);
        list2.add(6);
        list2.add(7);
        list2.add(8);
    
        list1.add(list2);
        System.out.println(list1);//[1, 2, 3, 4, [5, 6, 7, 8]]
        list1.addAll(list2);
        System.out.println(list1);//[1, 2, 3, 4, [5, 6, 7, 8], 5, 6, 7, 8]
    
    }
    

    2.3 排序

    @Test
    public void test3(){
        //sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 34, 54, 65, 32);
        list.stream().sorted().forEach(System.out::println);
    
        //抛异常,原因:Employee没有实现Comparable接口
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted().forEach(System.out::println);
    
        //sorted(Comparator com)——定制排序
        List<Employee> employees1 = EmployeeData.getEmployees();
        employees1.stream().sorted((e1,e2)->{
            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0){
                return ageValue;
            }else {
                return -Double.compare(e1.getSalary(),e2.getSalary());
            }
    
        }).forEach(System.out::println);
    }
    

  1. 终止操作(终端操作):一旦执行终止操作,就执行中间操作链,并产生结果(其结果可以是任何不是流的值,例如List、Integer、void)。之后不会再被使用。

    3.1 匹配与查找

    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
    
        //allMatch(Predicate p)——检查是否匹配所有元素。
        //练习:是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);
    
        //anyMatch(Predicate p)——检查是否至少匹配一个元素。
        //练习:是否存在员工的工资大于 5000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 5000);
        System.out.println(anyMatch);
    
        //noneMatch(Predicate p)——检查是否没有匹配的元素。
        //练习:是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
    
        //findFirst——返回第一个元素
        Optional<Employee> first = employees.stream().findFirst();
        System.out.println(first);
    
        //findAny——返回当前流中的任意元素
        Optional<Employee> employee = employees.parallelStream().findAny();
        System.out.println(employee);
    }
    
    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary()>5000).count();
        System.out.println(count);
    
        //max(Comparator c)——返回流中最大值
        //练习:返回最高的工资
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compareTo);
        System.out.println(maxSalary);
    
        //min(Comparator c)——返回流中最小值
        //练习:返回最低工资的员工
        Optional<Double> minSalary = employees.stream().map(e -> e.getSalary()).min(Double::compareTo);
        System.out.println(minSalary);
    
        //forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);
        System.out.println();
    
        //使用集合的遍历操作
        employees.forEach(System.out::println);
    }
    

    3.2 归约

    mapreduce 的连接通常称为 map-reduce 模式,因 Google 用它来进行网络搜索而出名

    @Test
    public void test3(){
        //reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来,得到一个值。返回 T
        //练习1:计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);
    
        //reduce(BinaryOperator) ——可以将流中元素反复结合起来,得到一个值。返回 Optional<T>
        //练习2:计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> sumSalary = employees.stream().map(e -> e.getSalary()).reduce(Double::sum);
        System.out.println(sumSalary);
    }
    

    3.3 收集

    Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 ListSetMap

    Collectors 实用类提供了很多静态方法,可以方便地创建常见收集器实例具体方法与实例如下表:

    @Test
    public void test4(){
        //collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法
        //练习1:查找工资大于6000的员工,结果返回为一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
    
        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        employeeSet.forEach(System.out::println);
    }
    


三、新日期时间 API

  • 旧版的Java中,日期时间API存在的问题:非线程安全设计很差时区处理麻烦
  • Java8 在java.time包下提供了很多新的API,涵盖了所有处理日期,时间,日期/时间,时区,时刻(instants),过程(during)与时钟(clock)的操作。以下为两种比较重要的API:
  1. Local(本地)——简化了日期时间的处理,没有时区的问题。

  2. Zoned(时区)——通过制定的时区处理日期时间。

  • 本地化日期时间API

LocalDate/LocalTimeLocalDateTime 类可以在处理时区不是必须的情况。代码如下:

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
 
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8tester = new Java8Tester();
      java8tester.testLocalDateTime();
   }
    
   public void testLocalDateTime(){
      // 获取当前的日期时间
      LocalDateTime currentTime = LocalDateTime.now();
      System.out.println("当前时间: " + currentTime);//输出运行程序时的时间,格式大致为2023-08-29T21:52:44.459
        
      LocalDate date1 = currentTime.toLocalDate();
      System.out.println("date1: " + date1);//输出运行程序时的日期,格式大致为2023-08-29
        
      Month month = currentTime.getMonth();//AUGUST
      int day = currentTime.getDayOfMonth();//29
      int seconds = currentTime.getSecond();//44
        
      System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
        
      LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);//运行结果为2012年,月份与运行程序时一致,10号,时间与运行程序时一致,输出格式与date1的格式一样
      System.out.println("date2: " + date2);
        
      // 12 december 2014
      LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
      System.out.println("date3: " + date3);//date3: 2014-12-12
        
      // 22 小时 15 分钟
      LocalTime date4 = LocalTime.of(22, 15);
      System.out.println("date4: " + date4);//date4: 22:15
        
      // 解析字符串
      LocalTime date5 = LocalTime.parse("20:15:30");
      System.out.println("date5: " + date5);//date5: 20:15:30
   }
}
  • 使用时区的日期时间API

如果我们需要考虑到时区,就可以使用时区的日期时间API。代码如下:

import java.time.ZonedDateTime;
import java.time.ZoneId;
 
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
    
   public void testZonedDateTime(){
      // 获取当前时间日期
      ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
      System.out.println("date1: " + date1);//date1: 2015-12-03T10:15:30+08:00[Asia/Shanghai]
        
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);//ZoneId: Europe/Paris
        
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("当期时区: " + currentZone);//当期时区: Asia/Shanghai
   }
}

四、接口默认方法

  • 接口默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法。只需在方法名前面加个default关键字即可实现默认方法,加个static关键字就是静态默认方法。

  • default修饰的函数

  1. 指在接口内部包含了一些默认的方法实现(即接口中可以包含方法体),使接口在进行扩展的时候,不会破坏与接口相关的实现类代码
  2. 类似于C++中的虚函数,default关键字在接口中修饰方法时,方法可以有方法体
  • 多个默认方法

一个接口有默认方法,考虑这样的情况,一个类实现了多个接口,且这些接口有相同的默认方法,以下实例说明了这种情况的解决方法:

public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}
 
public interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}

第一个解决方案是创建自己的默认方法,来覆盖重写接口的默认方法

public class Car implements Vehicle, FourWheeler {
   default void print(){//注意这里也加了default关键字
      System.out.println("我是一辆四轮汽车!");
   }
}

第二种解决方案可以使用 super 来调用指定接口的默认方法

public class Car implements Vehicle, FourWheeler {
   public void print(){//注意public
      Vehicle.super.print();//这里是继承Vehicle的默认方法
   }
}
  • 静态默认方法

Java 8 的另一个特性是接口可以声明(并且可以提供实现)静态方法。例如:

public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
    // 静态方法
   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}
  • 实例

    public class Java8Tester {
       public static void main(String args[]){
          Vehicle vehicle = new Car();
          vehicle.print();
       }
    }
     
    interface Vehicle {
       default void print(){
          System.out.println("我是一辆车!");
       }
        
       static void blowHorn(){
          System.out.println("按喇叭!!!");
       }
    }
     
    interface FourWheeler {
       default void print(){
          System.out.println("我是一辆四轮车!");
       }
    }
     
    class Car implements Vehicle, FourWheeler {
       public void print(){
          Vehicle.super.print();//我是一辆车!
          FourWheeler.super.print();//我是一辆四轮车!
          Vehicle.blowHorn();//按喇叭!!!
          System.out.println("我是一辆汽车!");//我是一辆汽车!
       }
    }
    

五、Optional类

  • Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
  • Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。
  • 类声明

以下是一个 java.util.Optional 类的声明:

public final class Optional<T>
extends Object
  • 类方法
序号 方法 & 描述
1 static Optional empty()返回空的 Optional 实例。
2 boolean equals(Object obj)判断其他对象是否等于 Optional。
3 Optional filter(Predicate<? super predicate)如果值存在,并且这个值匹配给定的 predicate,返回一个Optional用以描述这个值,否则返回一个空的Optional。
4 Optional flatMap(Function<? super T,Optional> mapper)如果值存在,返回基于Optional包含的映射方法的值,否则返回一个空的Optional
5 T get()如果在这个Optional中包含这个值,返回值,否则抛出异常:NoSuchElementException
6 int hashCode()返回存在值的哈希码,如果值不存在 返回 0。
7 void ifPresent(Consumer<? super T> consumer)如果值存在则使用该值调用 consumer , 否则不做任何事情。
8 boolean isPresent()如果值存在则方法会返回true,否则返回 false。
9 Optional map(Function<? super T,? extends U> mapper)如果有值,则对其执行调用映射函数得到返回值。如果返回值不为 null,则创建包含映射返回值的Optional作为map方法返回值,否则返回空Optional。
10 static Optional of(T value)返回一个指定非null值的Optional。
11 static Optional ofNullable(T value)如果为非空,返回 Optional 描述的指定值,否则返回空的 Optional。
12 T orElse(T other)如果存在该值,返回值, 否则返回 other。
13 T orElseGet(Supplier<? extends T> other)如果存在该值,返回值, 否则触发 other,并返回 other 调用的结果。
14 T orElseThrow(Supplier<? extends X> exceptionSupplier)如果存在该值,返回包含的值,否则抛出由 Supplier 继承的异常
15 String toString()返回一个Optional的非空字符串,用来调试

这些方法是从java.lang.Object类继承来的。

  • 实例

    import java.util.Optional;
     
    public class Java8Tester {
       public static void main(String args[]){
       
          Java8Tester java8Tester = new Java8Tester();
          Integer value1 = null;
          Integer value2 = new Integer(10);
            
          // Optional.ofNullable - 允许传递为 null 参数
          Optional<Integer> a = Optional.ofNullable(value1);
            
          // Optional.of - 如果传递的参数是 null,抛出异常 NullPointerException
          Optional<Integer> b = Optional.of(value2);
          System.out.println(java8Tester.sum(a,b));//10
       }
        
       public Integer sum(Optional<Integer> a, Optional<Integer> b){
        
          // Optional.isPresent - 判断值是否存在
            
          System.out.println("第一个参数值存在: " + a.isPresent());//false
          System.out.println("第二个参数值存在: " + b.isPresent());//true
            
          // Optional.orElse - 如果值存在,返回它,否则返回默认值
          Integer value1 = a.orElse(new Integer(0));
            
          //Optional.get - 获取值,值需要存在
          Integer value2 = b.get();
          return value1 + value2;
       }
    }
    


【参考资料】:菜鸟教程 https://www.runoob.com/java/java8-new-features.html;
尚硅谷Java入门视频教程 https://www.bilibili.com/video/BV1Kb411W75N?p=666&vd_source=cf21268954e139179e71f046bac01e56。

热门相关:我有一座恐怖屋   未来兽世:买来的媳妇,不生崽   不科学御兽   本法官萌萌哒   今天也没变成玩偶呢