Java8新特性解析

一.Java8新特性的主要内容点

• Lambda表达式
• 函数式接口
• 方法引用与构造器引用
• Stream API
• 接口中的默认方法与静态方法
• 新时间日期API
• 其他新特性

二.Java8新特性简介

• 速度更快
• 代码更少(增加了新的语法Lambda表达式)
• 强大的Stream API
• 便于并行
• 最大化减少空指针异常 Optional

其中最为核心的是Lambda表达式与Stream API

1.Lambda表达式

1.1什么是Lambda表达式
Lambda是一个匿名函数,可以把它理解为一段可以传递的代码(将代码像数据一样进行传递).

1.2为什么要使用Lambda表达式
可以写出更简洁灵活的代码,作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升.

1.3从匿名类到Lambda的转换

 		//匿名内部类
        Runnable r1 = new Runnable() {
            public void run() {
                System.out.println("Hello World!");
            }
        };

        //Lambda表达式
        Runnable r2 = () -> System.out.println("Hello World!");

 	    //原来使用匿名内部类作为参数传递
        TreeSet<String> ts1 = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(),o2.length());
            }
        });

        //现在用Lambda表达式作为参数传递
        TreeSet<String> ts2 = new TreeSet<>(
                (o1,o2) -> Integer.compare(o1.length(),o2.length())
        );

1.4Lambda表达式语法
Lambda表达式在Java语言中引入了一个新的语法元素和操作符.这个操作符"->"称为Lambda操作符或箭头操作符,它将Lambda表达式分为两部分:
左侧:指定了Lambda表达式需要的所有参数
右侧:指定了Lambda体,即Lambda表达式要执行的功能
常见的几种语法格式:

 //格式一:无参,无返回值,Lambda体只需一条语句
 Runnable r = () -> System.out.println("Hello Lambda!");

  //格式二:需要一个参数
  Consumer<String> c = (arg) -> System.out.println(arg);
  c.accept("sss"); //sss
  
 //格式三:当只需要一个参数时,参数的小括号可以省略
 Consumer<String> c = arg -> System.out.println(arg);

//格式四:需要两个参数,且有返回值
 BinaryOperator<Long> bo = (x,y) -> {
            System.out.println("实现函数接口方法");
            return Math.addExact(x,y);
        };   

 //格式五:当Lambda体只有一条语句时,return与{}可以省略
  BinaryOperator<Long> bo = (x,y) -> Math.addExact(x,y); 
 
 //格式六:参数可以加上类型
  BinaryOperator<Long> bo = (Long x,Long y) -> Math.addExact(x,y);         

类型推断:
上述Lambda表达式中的参数类型都是由编译期推断得出的.Lambda表达式中无需指定参数类型,程序依然可以编译,这是因为javac根据程序的上下文,在后台推断出了参数类型,即Lambda表达式的参数类型依赖于上下文,是由编译器推断出来的,这就是所谓的类型推断.

2.函数式接口

2.1什么是函数式接口
只包含一个抽象方法的接口.(注意:这里限制的是只能有一个抽象方法,但可以有default方法和static方法,如java.util.function.BinaryOperator )

2.2与Lambda表达式的结合
可以通过Lambda表达式创建函数式接口的实例(若Lambda抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明).

2.3用@FunctionalInterface自定义函数式接口
可以用@FunctionalInterface标识一个函数式接口,这样javac会包含一条声明,说明这是一个函数式接口.

@FunctionalInterface
public interface MyFunc<T> {
    T getValue(T t);
}

 public static String toUpperString(MyFunc<String> mf,String str){
        return mf.getValue(str);
    }
  	
  String newStr = toUpperString(str -> str.toUpperCase(),"abcd");
  System.out.println(newStr);

注:为了将Lambda表达式作为参数传递,接收Lambda表达式的参数类型必须是与该Lambda表达式兼容的函数式接口的类型.

2.4Java内置四大核心函数式接口

其他函数式接口:

3.方法引用与构造器引用

3.1方法引用
当要传递给Lambda体的操作已经有实现的方法了,可以使用方法引用.
(实现抽象方法的参数列表必须与方法引用方法的参数列表保持一致)
方法引用:使用操作符"::"将方法名与对象或类的名字分隔开来.
有如下三种主要使用情况:

• 对象::实例方法
• 类::静态方法
• 类::实例方法

//(x) -> System.out.println(x)等同于System.out::println
Runnable r3 = System.out::println;
//(x,y) -> Math.addExact(x,y)等同于Math::addExact
BinaryOperator<Long> bo = Math::addExact;

注:当需要引用方法的第一个参数是调用对象,并且第二个参数是需要引用方法的第二个参数(或无参数)时,ClassName::methodName

3.2构造器引用
格式:ClassName::new
与函数式接口相结合,自动与函数式接口中的方法兼容,可以把构造器引用赋值给定义的方法,构造器参数列表要与接口中抽象方法的参数列表一致.

 Function<Integer,MyClass> fun = (n) -> new MyClass(n);
 //等价于下面
 Function<Integer,MyClass> fun1 = MyClass::new;

3.2数组引用
格式: type[]::new

   Function<Integer,Integer[]> func2 = n -> new Integer[n];
   //等价于下面
   Function<Integer,Integer[]> func3 = Integer[]::new;

4.强大的Stream API

4.1什么是Stream(流)?
Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream:是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的是数据，流讲的是计算！ ”
注意：
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

4.2Stream操作的三个步骤

• 创建 Stream

一个数据源（如： 集合、数组）， 获取一个流

• 中间操作

一个中间操作链，对数据源的数据进行处理

• 终止操作(终端操作)

一个终止操作，执行中间操作链，并产生结果

• 创建Stream
  1.Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
  default Stream<E> stream() : 返回一个顺序流
  default Stream<E> parallelStream() : 返回一个并行流
  2.由数组创建流
  Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
  static <T> Stream<T> stream(T[] array): 返回一个流
  重载形式，能够处理对应基本类型的数组：
  public static IntStream stream(int[] array)
  public static LongStream stream(long[] array)
  public static DoubleStream stream(double[] array)
  3.由值创建流
  可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。
  public static <T> Stream <T> of(T… values) : 返回一个流
  4.由函数创建流：创建无限流
  可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。
  迭代 public static <T> Stream <T> iterate(final T seed, final UnaryOperator <T> f)
  生成 public static <T> Stream<T> generate(Supplier<T> s) :

• Stream 的中间操作
  多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值” ,也称为Stream的延迟特性。
  
  

• Stream 的终止操作
  终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如： List、 Integer，甚至是 void 。
  
  
  备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。
  
  Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、 Set、 Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例， 具体方法与实例如下表：
  
  

• 并行流与串行流
  并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。Fork/Join 框架： 就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.

• Stream API使用示例

1.查出所有用户,取出所有用户id的集合

 List<CircleUserVO> allUser = circleMemberInfoMapper.selectByListUserIdAndName(null, null);
 List<String> allUserIds = allUser.stream().map(user -> user.getUserId()).collect(Collectors.toList());

2.查出所有的用户,构造一个Map<k,v> userMap,其中k=userId,v=user.

 Map<String, CircleUserVO> userMap = allUser.stream().collect(Collectors.toMap(user -> user.getUserId(), user -> user));
 或者:Map<String, CircleUserVO> userMap2 = allUser.stream().collect(Collectors.toMap(CircleUserVO::getUserId, user -> user));
 或者:Map<String, CircleUserVO> userMap3 = allUser.stream().collect(Collectors.toMap(CircleUserVO::getUserId, Function.identity())); //java.util.function.Function

3.List转Map的方法总结
常用方式

public Map<Long, String> getIdNameMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsername));
}

收集成实体本身map

public Map<Long, Account> getIdAccountMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getId, account -> account));
}

account -> account是一个返回本身的lambda表达式，其实还可以使用Function接口中的一个默认方法代替，使整个方法更简洁优雅：

public Map<Long, Account> getIdAccountMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getId, Function.identity()));
}

重复key的情况

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity()));
}

这个方法可能报错（java.lang.IllegalStateException: Duplicate key），因为name是有可能重复的。toMap有个重载方法，可以传入一个合并的函数来解决key冲突问题：

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2));
}

这里只是简单的使用后者覆盖前者来解决key重复问题。

指定具体收集的map
toMap还有另一个重载方法，可以指定一个Map的具体实现，来收集数据：

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2, LinkedHashMap::new));
}

参考:https://zacard.net/2016/03/17/java8-list-to-map/

5.Fork/Join 框架

5.1 Fork/Join 框架
就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.

5.2 Fork/Join 框架与传统线程池的区别
采用 “工作窃取”模式（ work-stealing）：当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能.

6.新时间日期 API

6.1 使用LocalDate、 LocalTime、 LocalDateTime
LocalDate、 LocalTime、 LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。
注： ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法

6.2 Instant 时间戳
用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算

6.3 Duration 和 Period
Duration:用于计算两个“时间”间隔
Period:用于计算两个“日期”间隔

6.4 日期的操纵
TemporalAdjuster : 时间校正器。有时我们可能需要获取 例如：将日期调整到“下个周日”等操作。
TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
例如获取下个周日：

LocalDate nextSunday = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.SUNDAY));

6.5 解析与格式化
java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：
预定义的标准格式
语言环境相关的格式
自定义的格式

6.6 时区的处理
Java8 中加入了对时区的支持，带时区的时间为分别为：ZonedDate、 ZonedTime、 ZonedDateTime.其中每个时区都对应着 ID，地区ID都为 “ {区域}/{城市}”的格式.
例如 ： Asia/Shanghai 等
ZoneId：该类中包含了所有的时区信息
getAvailableZoneIds() : 可以获取所有时区时区信息
of(id) : 用指定的时区信息获取 ZoneId 对象.

与传统日期处理的转换

7.接口中的默认方法与静态方法

7.1 接口中的默认方法
Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。

public interface MyFunc<T> {
    T getValue(T t);

    default String getString(){
        return "Hello World!";
    }
}

接口默认方法的” 类优先” 原则
若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时:

• 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
• 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突.

7.2 接口中的静态方法
Java8 中，接口中允许添加静态方法。

public interface MyFunc<T> {
    T getValue(T t);

    default String getString(){
        return "Hello World!";
    }

    static void show(){
        System.out.println("Hello Lambda!");
    }
}

8.其他新特性

8.1 Optional 类
Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
常用方法：
Optional.of(T t) : 创建一个 Optional 实例
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
isPresent() : 判断是否包含值
orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function mapper):与 map 类似，要求返回值必须是Optional

8.2 重复注解与类型注解
Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。