除了定义全局常量和抽象方法之外，还可以定义静态方法，默认方法
Wu's Blog
//静态方法
public static void demo(){
}
//默认方法，public可以省略
public default void show() {
}
（1）接口中定义的静态方法，只能用接口来调用
（2）接口中定义的默认方法可通过接口的实现类调用
（3）如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法 --> 类优先原则
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
//常规写法
Comparator<Integer> comparable = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
//Lambda表达式
Comparator<Integer> comparable = (o1, o2) -> Integer.compare(o1,o2);
举例：(o1, o2) -> Integer.compare(o1,o2);
-> ：lambda操作符或箭头操作符
->左边：lambda形参列表（其实就是接口中抽象方法的形参列表）
->右边：lambda体（其实就是重写的抽象方法的方法体）
Lambda表达式的本质：作为函数式接口的实例（若一个接口中只声明一个抽象方法，则此接口为函数式接口）
//常规写法
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("hei");
}
};
//lambda表达式
Runnable runnable = () -> {System.out.println("hei");};
//常规写法
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
//Lambda表达式
Consumer<String> consumer = （String s) -> {System.out.println(s);};
//语法格式二
Consumer<String> consumer = （String s) -> {System.out.println(s);};
//类型推断，省略了数据类型
Consumer<String> consumer = (s) -> {System.out.println(s);};
//语法格式三
Consumer<String> consumer = （String s) -> {System.out.println(s);};
//若只要一个参数时，参数的小括号可以省略
Consumer<String> consumer = s -> {System.out.println(s);};
//常规写法
Comparator<Integer> comparable = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("begin");
return Integer.compare(o1,o2);
}
};
//多个参数时括号不可省略，方法体多条执行语句
Comparator<Integer> comparable = (o1, o2) -> {
System.out.println("begin");
return Integer.compare(o1,o2);
};
//常规写法
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
//Lambda表达式，return和大括号均省略
Comparator<Integer> comparator = (o1, o2) -> o1.compareTo(o2);
总结：
（1）->左边：lambda形参列表的参数类型可以省略（类型推断）；如果形参列表只有一个参数，其一对小括号可以省略
（2）->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），那么可以省略这一对{}和return关键字
只包含一个抽象方法的接口，称为函数式接口
可通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常（即非运行时异常），那么该异常需要在目标接口的抽象方法上声明）
可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是函数式接口
在java.util.function包定义了Java8的丰富的函数式接口
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
方法引用可以看做是Lambda表达式的深层是的表达。换句话说，方法引用就是Lambda的表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
格式：使用操作符“::”将类（或者对象）与方法名分隔开来
如下三种主要使用情况：
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("hei");
//改写
PrintStream printStream = System.out;
Consumer<String> con = printStream::println;
con.accept("hei");
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1, T t2)
Comparator<Integer> comparator = (o1, o2) -> Integer.compare(o1,o2);
//改写
Comparator<Integer> comparator1 = Integer::compare;
//Comparator中的int compare(T t1,T t2)
//String中的int t1.compareTo(t2)
Comparator<String> comparator = (o1, o2) -> o1.compareTo(o2);
//改写：当参数1 o1作为方法的调用者出现时可以使用
Comparator<String> comparator1 = String::compareTo;
和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致
抽象方法的返回值类型即为构造器所属的类的类型
BiFunction<Integer,String, Person> biFunction = (integer, s) -> new Person();
//构造器引用
BiFunction<Integer,String, Person> biFunction = Person::new;
可以把数组看做是一个特殊的类，则写法与构造器引用一致
Function<Integer,String[]> function = length -> new String[length];
Function<Integer,String[]> function = String[]:: new;
Stream是数据取到，用于操作数据源（集合、数组）所生成的元素序列
“集合讲的是数据，Stream讲的是计算”
注意：
（1）Stream自己不会存储元素
（2）Stream不会改变源对象。相反，它们会返回一个持有结果的新Stream
（3）Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
1.创建Stream
一个数据源（如：集合、数组），获取一个流
2.中间操作
一个中间操作链，对数组的数据进行处理
3.终止操作
一旦执行终止操作，就执行中间操作链，并产生结果。之后不会再被使用
default Stream
default Stream
List<Integer> list = Arrays.asList(3,1,2);
Stream<Integer> stream = list.stream();
Stream<Integer> integerStream = list.parallelStream();
Java8中的Arrays的静态方法stream()可以获得数组流
static
重载形式，能够处理对应基本类型的数组
public static IntStream stream(int[] array)
public static LongStream stram(long[] array)
public static DoubleStream stream(double[] array)
IntStream stream = Arrays.stream(new int[]{2, 1, 3});
可以调用Stream类的静态方法of()，通过显示值创建一个流。ta 可以接收任意数量的参数
public static
Stream<Integer> integerStream = Stream.of(3, 1, 2);
可以使用静态方法Stream.iterate()和Stram.generate()，创建无限流
public static
public static
//遍历前10个偶数
Stream.iterate(0, i -> i+2).limit(10).forEach(System.out::println);
//获得10个随机数
Stream.generate(Math::random).limit(10).forEach(System.out::println);
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
1.筛选与切片
（1）filter(Predicate p)：接收Lambda，从流中排除某些元素
List<Person> list = new ArrayList<>();
list.add(new Person(18,"wu"));
list.add(new Person(20,"ruo"));
list.add(new Person(35,"h"));
list.add(new Person(45,"u"));
Stream<Person> stream = list.stream();
//查询年龄小于35的person
stream.filter( person -> person.getAge() <35).forEach(System.out::println);
（2）distinct()：筛选，通过流所生成的hashcode()和equals()去除重复元素
list.add(new Person(45,"u"));
list.stream().distinct().forEach(System.out::println);
（3）limit(long maxSize)：截断流，使其元素不超过给定值
list.stream().limit(3).forEach(System.out::println);
（4）skip(long n)：跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
//跳过前3个
list.stream().skip(3).forEach(System.out::println);
2.映射
（1）map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并映射成一个新的元素
//将list中的字母转换为大写
List<String> stringList = Arrays.asList("aa", "bb", "cc");
stringList.stream().map(s -> s.toUpperCase()).forEach(System.out::println);
//获取名字长度大于1的person的名字
list.stream().map(Person::getName).filter(name -> name.length() > 1).forEach(System.out::println);
（2）map ToDouble(ToDoubleFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
（3）map ToInt(ToIntFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
（4）map ToLong(ToLongFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
（5）flatMap(Function f)：接收一个函数作为参数，将流中的每个值替换成另一个流，然后将所有的流连接成一个流
public class StreamTest {
public static void main(String[] args) {
List<String> stringList = Arrays.asList("aa", "bb", "cc");
Stream<Stream<Character>> streamStream = stringList.stream().map(StreamTest::fromStringToStream);
streamStream.forEach(s -> {
s.forEach(System.out::println);
});
//采用flatMap() ->该方法与list中的addAll()类似
stringList.stream().flatMap(StreamTest::fromStringToStream).forEach(System.out::println);
}
public static Stream<Character> fromStringToStream(String str) {
List<Character> list = new ArrayList<>();
for (Character s : str.toCharArray()) {
list.add(s);
}
return list.stream();
}
}
3.排序
（1）sorted()：产生一个新流，其中按自然顺序排序
List<Integer> integerList = Arrays.asList(2,4,5,-1,23,44,33);
integerList.stream().sorted().forEach(System.out::println);
（2）sorted(Comparator com)：产生一个新流，其中按比较器顺序排序
List<Person> list = new ArrayList<>();
list.add(new Person(18, "wu"));
list.add(new Person(20, "ruo"));
list.add(new Person(35, "h"));
list.add(new Person(45, "u"));
list.stream().sorted((p1,p2) -> Integer.compare(p1.getAge(),p2.getAge())).forEach(System.out::println);
//方法引用，Person中有compareTo()方法
list.stream().sorted(Person::compareTo).forEach(System.out::println);
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void
流进行了终止操作后，不能再次使用
1.匹配与查找
（1）allMatch(Predicate p)：检查是否匹配所有元素
//是否所有的person年龄都大于25
boolean allMatch = list.stream().allMatch(person -> person.getAge() > 25);
System.out.println(allMatch);
（2）anyMatch(Predicate p)：检查是否至少匹配一个元素
//至少有一个person的年龄大于25
boolean anyMatch = list.stream().anyMatch(person -> person.getAge() > 25);
System.out.println(anyMatch);
（3）noneMatch(Predicate p)：检查是否没有匹配所有元素
//不存在员工名字长度大于4
boolean noneMatch = list.stream().noneMatch(person -> person.getName().length() > 4);
System.out.println(noneMatch);
（4）findFirst()：返回第一个元素
Optional<Person> first = list.stream().findFirst();
System.out.println(first);
（5）findAny()：返回当前流中的任意元素
Optional<Person> any = list.parallelStream().findAny();
System.out.println(any);
（6）count()：返回流中元素的总个数
long count = list.stream().count();
System.out.println(count);
（7）max(Comparaotr c)：返回流中最大值
//返回最高年龄
Stream<Integer> integerStream = list.stream().map(person -> person.getAge());
Optional<Integer> max = integerStream.max(Integer::compare);
System.out.println(max);
（8）min(Cimparator c)：返回流中最小值
//返回年龄最小的person
Optional<Person> min = list.stream().min(Person::compareTo);
System.out.println(min);
（9）forEach(Consumer c)：内部迭代
list.stream().forEach(System.out::println);
2.归约
（1）reduce(T identity, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值，返回T
//计算1到5的和
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Integer reduce = integerList.stream().reduce(0, Integer::sum);
System.out.println(reduce);
（2）reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值，返回Optional
//返回年龄总和
Stream<Integer> integerStream = list.stream().map(Person::getAge);
Optional<Integer> sumAge = integerStream.reduce(Integer::sum);
System.out.println(sumAge);
3.收集
collect(Collector c)：将流转换为其他形式，接收一个Collector接口的实现，用于给stream中元素做汇总的方法
Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List、Set、Map）
另外，Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，如下：
//获取年龄大于35的person并且转化为list
List<Person> personList = list.stream().filter(person -> person.getAge() > 35).collect(Collectors.toList());
System.out.println(personList);
到目前为止，臭名昭著的空指针异常时导致Java应用程序失败的最常见原因。以前为了解决空指针异常，Google公司著名的Guava项目引进了Optional类，Guava通过检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为了Java8的一部分。
Optional
Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在，则isParent()方法会返回true，调用get()方法会返回该对象。
1.创建Optional类对象的方法
（1）Optional.of(T t)：创建一个Optinal实例，t必须为非空
//of(T t)：保证t不为空
Person person = new Person(10, "wu");
Optional<Person> personOptional = Optional.of(person);
System.out.println(personOptional);
（2）Optional.empty()：创建一个空的Optional实例
（3）Optional.ofNullable(T t)：t可以为null
public class OptionalTest {
public static void main(String[] args) {
Person person = new Person(10, "wu");
System.out.println(getAnimalName(person));
}
public static String getAnimalName(Person person) {
Optional<Person> personOptional = Optional.ofNullable(person);
Person p = personOptional.orElse(new Person(new Animal("cat")));
Animal animal = p.getAnimal();
Optional<Animal> animalOptional = Optional.ofNullable(animal);
Animal a = animalOptional.orElse(new Animal("dog"));
return a.getName();
}
}
2.判断Optional容器中是否包含对象：
（1）boolean isParent()：判断是否包含对象
（2）void ifPresent(Cinsumer<? super T> consumer)：如果有值，就执行Comsumer
3.获得Optional容器的对象
（1）T get()：如果对象包含值，则返回该值，否则抛异常
（2）T orElse(T other)：如果有值则将其返回，否则返回指定的other对象
（3）T orElseGet(Supplier<? extends T> other)：如果有值则将其返回，否则返回由Supplier接口实现提供的对象
（4）T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值，则将其返回，否则抛出由Supplier接口实现提供的异常