JavaSE基础入门_019_Java8特性

Java8 新特性

Java8概述

• Java8（又称 JDK 1.8）是 Java 语言开发的一个主要版本。Oracle 公司于 2014.03.18 发布 Java 8

  • 支持 Lambda 表达式

  • 函数式接口

  • 新的 Stream API

  • 新的日期 API

  • 其他特性

 

Lambda表达式

• Lambda 表达式：特殊的匿名内部类，语法更简洁。

• Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。

• // 匿名内部类
  Runnable runnable = new Runnable() {
      @Override
      public void run() {
          // TODO Auto-generated method stub
          System.out.println("子线程执行了。。。。。");
      }
  };
  new Thread(runnable).start();
  ​
  // Lambda 表达式
  Runnable runnable2 = ()-> System.out.println("Lambda子线程执行了。。。。。");
  new Thread(runnable2).start();
          
  // 再简化 Lambda
  new Thread(()-> System.out.println("Lambda3子线程执行了。。。。。")).start();

• // 匿名内部类实现比较器
  Comparator<String> com = new Comparator<String>() {
  ​
      @Override
      public int compare(String o1, String o2) {
          // TODO Auto-generated method stub
          return o1.length() - o2.length();
      }
  ​
  };
  ​
  TreeSet<String> treeSet = new TreeSet<String>(com);
  ​
  // Lambda表达式简化
  Comparator<String> com2 = (String o1, String o2) -> {
      return o1.length() - o2.length();
  };
  TreeSet<String> treeSet2 = new TreeSet<String>(com2);
  ​
  // Lambda 再简化
  Comparator<String> com3 = (o1, o2) -> o1.length() - o2.length();
  //Lambda里面不需要保留return
  TreeSet<String> treeSet2 = new TreeSet<String>(com3);

• 基本语法：

  • <函数式接口><变量名> = (参数1, 参数2...) -> {
        //方法体
    }

• Lambda 引入了新的操作符：->(箭头操作符)，->将表达式分成两部分

  • 左侧：(参数1，参数2...)表示参数列表

  • 右侧：{}内部是方法体

• 注意事项

  • 形参列表的数据类型会自动推断

  • 如果形参列表为空，只需保留()

  • 如果形参只有1个，()可以省略，只需要参数的名称即可

  • 如果执行语句只有一句，且无返回值，{}可以省略，若有返回值，则若想省去{}，则必须同时省略return，且执行语句也保证只有一句

  • Lambda 不会生成一个单独的内部类文件

 

函数式接口

• 如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。

 

• @FunctionnalInterface 注解检测是接口是否符合函数式接口

 

常见函数式接口

函数式接口	参数类型	返回类型	方法说明
Consumer<T>消费型接口	T	void	void accept(T t); 对类型为T的对象应用操作
Supplier<T>供给型接口	无	T	T get(); 返回类型为T的对象
Function<T，R>函数型接口	T	R	R apply(T t); 对类型为T的对象应用操作，并返回类型为R类型的对象。
Predicate<T>断言型接口	T	boolean	boolean test(T t); 确定类型为T的对象是否满足条件，并返回boolean类型。

 

方法引用

• 方法引用是 Lambda 表达式的一种简写形式。如果 Lambda 表达式方法体中只是调用一个特定的已经存在的方法，则可以使用方法引用。

• 常见形式：

  • 对象 ：：实例方法

  • 类 ：：静态方法

  • 类 ：：实例方法

  • 类 ：：new

 

Stream API

什么是Stream

• 流（Stream）中保存对集合或数组数据的操作。和集合类似，但集合中保存的是数据。

 

Stream特点

• Stream 自己不会存储元素。

• Stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream。

• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

 

Stream使用步骤

• 创建

  • 新建一个流

• 中间操作

  • 在一个或多个步骤中，将初始Stream转化到另一个Stream的中间操作

• 终止操作

  • 使用一个终止操作来产生一个结果。该操作会强制它之前的延迟操作立即执行。在这之后，该Stream就不能使用了。

 

创建Stream

• 通过 Collection 对象的 stream() 【串行流，单线程的】 或 parallelStream() 【并行流，多线程】方法

• 通过 Arrays 类的 stream() 方法

• 通过 Stream 接口的 of()、iterate()、generate() 方法

• 通过 IntStream、LongStream、DoubleStream 接口中的 of、range、rangeClosed 方法

• // 1.- 通过 Collection 对象的 stream() 【串行流，单线程的】 或 parallelStream() 【并行流，多线程】方法
          ArrayList<String> arrayList = new ArrayList<String>();
          arrayList.add("Apple");
          arrayList.add("Xiaomi");
          arrayList.add("Huawei");
          Stream<String> stream =  arrayList.stream();
          //Stream<String> stream2 = arrayList.parallelStream();
          
          // 遍历
          //stream.forEach(s->System.out.println(s));
          stream.forEach(System.out::println);
          System.out.println("--------------------------");
          //stream2.forEach(System.out::println);
          
          
          //2. 通过 Arrays 类的 stream() 方法
          String[] arr = {"aaa","bbb","ccc","ddd"};
          Stream<String> stream2 =  Arrays.stream(arr);
          stream2.forEach(System.out::println);
          System.out.println("--------------------------");
          
          
          //3. 通过 Stream 接口的 of()、iterate()、generate() 方法
          Stream<Integer> stream3 = Stream.of(10,20,30,40,50);
          stream3.forEach(System.out::println);
          // 迭代流
          System.out.println("---------迭代流----------");
          Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
          iterate.limit(10).forEach(System.out::println);
          //生成流
          System.out.println("---------生成流----------");
          Stream<Integer> generate = Stream.generate(()->new Random().nextInt(100));
          generate.limit(10).forEach(System.out::println);
          
          System.out.println("--------------------------");
          
          
          // 4. 通过 IntStream、LongStream、DoubleStream 接口中的 of、range、rangeClosed 方法
          IntStream stream4 = IntStream.of(100, 200, 300);
          stream4.forEach(System.out::println);
          IntStream stream5 = IntStream.range(0, 100);//不闭合，留头不留尾
          stream5.forEach(System.out::println);
          IntStream stream6 = IntStream.rangeClosed(0, 100);//闭合，留头也留尾
          stream6.forEach(System.out::println);

   

 

 

中间操作、终止操作

• 中间操作

  • filter、limit、skip、distinct【去重】、sorted

    • list.stream().filter(e->e.getMoney>10000).forEach(System.out::println);
      filter(****)[参数：断言式]

    • distinct() 判断依据：hashcode ，equals()

  • map: 把当前数据映射成另外一组数据

    • 参数：Function<> 函数接口；

  • parallel：获得一个多线程的并行流

• 终止操作

  • forEach、min、max、count【统计个数】

  • reduce【归约，将所有选择数据进行统一操作】、collect

 

新时间API

• 之前时间API存在问题：线程安全问题、设计混乱。

• 本地化日期时间 API

  • LocalDate

  • LocalTime

  • LocalDateTime

• Instant：时间戳，【1970：00：00 到现在的毫秒数】

• ZoneId：时区

• Date、Instant、LocalDateTime的转换

• DateTimeFormatter：格式化类

 

总结

• Lambda表达式：

  • 允许把函数作为一个方法的参数传递。

• 函数式接口：

  • Consumer

  • Supplier

  • Function

  • Predicate

• Stream API

  • 把对数据的操作封装成一个流

  • 步骤：创建、中间操作、终止操作【调用终止操作，才执行流】

• 新时间API