Java8新特性

Lambda表达式

Java 8是Java自Java 5（发布于2004年）之后的最重要的版本。这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。

Lambda是一个匿名函数，可以理解为将代码像数据一样传递，使用它可以使代码跟加简洁，灵活。Lambda的实质是借口的实例，也就
是说要使用Lambda必须要是接口，并且接口里面只有一个抽象方法。

Lambda表达式的格式：箭头操作符（lambda操作符）是 ‘->’ ，操作符的左边是形参列表，右边是lambda体（是重写的抽象方法的方法体），例如：

1	(i,j) -> Integer.compare(i,j);

使用的情况分为6种：
1.无参，无返回值 ()->{System.out.println(“123”);}
2.有参，无返回值 (String s)->{System.out.println(“123”);}
3.参数类型可省略，编译器可以自行推断 (s)->{System.out.println(“123”);}
4.若参数只有一个，小括号可以省略 s->{System.out.println(“123”);}
5.参数多个且有多条执行语句 (i,j)->{System.out.println(“123”);System.out.println(“456”);}
6.若执行语句只有一条，返回值和大括号可以省略 s->System.out.println(“123”);

函数式接口

只包含一个抽象方法的接口叫函数式接口，可以通过Lambda表达式来创建接口对象,@FunctionalInterface无论加不加上，都是函数式接口，只是加了注解后
提供了校验的作用，并且javadoc会包含声明。

@FunctionalInterface
public interface MyDemo{
    void test();
}

java8提供的四种重要函数式接口：
1.供给型
2.消费型
3.函数型
4.断言型

Supplier<T>     返回T类型对象
    T get();

Consumer<T>     接收一个 T 类型
    void accept(T t);

Function<T, R>  由T类型对象转成R类型对象
    R apply(T t);

Predicate<T>    条件判断
    boolean test(T t);

方法引用

方法引用是lambda表达式的一种特殊形式，如果正好有某个方法满足一个lambda表达式的形式，那就可以将这个lambda表达式用方法引用的方式表示，但是如果这个
lambda表达式的比较复杂就不能用方法引用进行替换。实际上方法引用是lambda表达式的一种语法糖。

方法引用共分为四类：
1.类名::静态方法名
2.对象::实例方法名
3.类名::实例方法名
4.类名::new

第四种又被叫做构造器引用，下面是实际用例：

//这是一个jdk1.8新添加的函数式接口
@FunctionalInterface
public interface Supplier<T> {
    T get();
}

//只是自己定义的一个类
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());
    }
}

final List< Car > cars = Arrays.asList( car );

1.cars.forEach( Car::collide );

2.Car car = new Car();
  cars.forEach( car::repair );

3.cars.forEach( Car::repair );

4.Car car = Car.create( Car::new );

stream api

stream 和 collection 集合的区划是：后者是一种静态的内存数据结构，而前者是有关计算的，主要是面向cpu，通过CPU计算。

stream是数据渠道，用来操作数据源的元素序列，但是它不会自己存储元素，也不会改变源对象，会返回一个新结果的stream，并且操作延迟的。

stram的操作流程是：首先stream实例化，然后进行中间操作，最后终止操作。操作延迟的意思也就是要终止操作后才会进行中间操作。并且终止
后不能再次使用，必须要重新创建。

实例化的四种方式：

//集合实例化Stream
Stream<T> stram1 = new ArrayList().stream();  //顺序流
Stream<T> stram1 = new ArrayList().parallelStream();   //并行流 

//数组实例化Stream
int[] arr = new int[]{1,2,3,5,4,8,9}
IntStream stream = Arrays.stream(arr);   //不同的参数返回不同的对象

//Stream类实例化
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

//Stream类无限流
Stream.iterate(0,t -> t+2);    //迭代
Stream.generate(Math::random);    //生成

Stream可以分为串行与并行两种，串行流和并行流差别就是单线程和多线程的执行。

中间操作：
1.筛选和切片：
filter-过滤，接收Lambda，从流中排除某些元素
limit-截断流，使其元素不超过给定数量
skip(n)-跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补、
distinct-筛选，通过流所生成元素的hashCode()和equals()去除重复元素
2.映射
map——接收lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap-接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流。
3.排序
sorted()-自然排序(Comparable)
sorted(Comparator com)-定制排序(Comparator)

终止操作：
1.匹配和查找：
allMatch 是否匹配所有
anyMatch 是否匹配一个
noneMatch 是否没有匹配一个
findFirst 返回第一个
count 返回总数
max 返回最大
min 返回最小
forEach 内部迭代
2.归约
reduce 归约将元素连续操作得到结果
3.收集
collect 收集将流转换成其他的形式(其他集合)，接收Collector接口用于Stream中元素各种汇总特例 Collectors.joining()拼接字符串

Optional类

Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException） —— 每个 Java 程序员都非常了解的异常。
本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。

Optional.of(T t) 创建Optional类实例,t非空
Optional.empty() 创建空的Optional实例
Optional.ofNullable(T t) 创建Optional类实例,t可以空

1 2	//创建Optional类实例 Optional<User> emptyOpt = Optional.empty();

isPresent 检查一个Optional对象中是否有值，只有值非空才返回true。
orElse 检索Optional对象中的值，它被传入一个“默认参数‘。如果对象中存在一个值，则返回它，否则返回传入的“默认参数”
orElseGet 与orElsel类似，但是这个函数不接收一个“默认参数”，而是一个函数接口
orElseThrow orElseThrow当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常
get 使用get() API 也可以返回被包裹着的值。但是必须是值存在时，当值不存在时，它会抛出一个NoSuchElementException异常