一.接口内允许添加默认实现的方法
在原来的定义中接口中只能有方法声明，不能有方法体。在Java8中，接口也可以有自己带有实现的方法啦。具体来说是要用default来修饰的方法，其可以像类中的方法一样有执行语句。在实现接口时，可以不实现其default方法，并且实现类对象可以调用其接口的default方法。当然也可以在实现类中覆盖default方法。
public class InterfaceDemo {
public static void main(String[] args) {
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return a + 1;
}
// @Override
// public double sqrt(int a) {
// return a;
// }
};
System.out.println(formula.calculate(100));
System.out.println(formula.sqrt(100));
}
}
interface Formula {
//计算
double calculate(int a);
//求平方根
default double sqrt(int a) {
return Math.sqrt(a);
}
}
二.Lambda表达式
Lambda简化了匿名内部类的写法。Java8中可以通过类型推断来判断出用户的意图，不必将类型等信息写全。特别是方法实现体中只有一句语句的实现类，更能加大简化力度。
Lambda解决了将一个方法作为参数传值的问题。解决了一个函数是否可以独立存在的问题。是Java向函数式编程的一种靠拢。
一般在某个方法只使用一次的地方使用Lambda表达式；如果方法没有入参，则只写一个()->{语句}；当只有一个参数，且类型可推断时，()可省略；如果方法体中只有一条语句花括号可以省略；
public class LambdaDemo {
public static void func1() {
System.out.println("not use Lambda");
List<String> strs = Arrays.asList("hello","word","apple","people","sea","book","school","computer");
//old way
Collections.sort(strs,new Comparator<String>() {
@Override
public int compare(String a,String b) {
return b.compareTo(a);
}
});
System.out.println(strs);
}
public static void func2() {
System.out.println("use Lambda");
List<String> strs = Arrays.asList("hello","word","apple","people","sea","book","school","computer");
//way 1
Collections.sort(strs,(String a,String b) -> {
return a.compareTo(b);
});
//way 2 : only one statement
Collections.sort(strs,(String a,String b) -> a.compareTo(b));
//way 3 : omit class
Collections.sort(strs,(a,b) -> a.compareTo(b));
System.out.println(strs);
}
}
三.函数式接口Functional Interface
学习了上述Lambda的内容肯定会有一些疑问：如果接口有多个需要实现的方法 呢，还能使用Lambda？如果可以的话Lambda是如何做推断的。
答案是，使用Lambda时要求接口中只能有一个抽象方法（通过default修饰的带有方法体的接口中的方法不是抽象方法）。
如果一个接口被注解@FunctionalInterface修饰，则该接口只能有一个抽象方法，否则会报错。
四.引用类的构造器及方法
在Lambda中若是直接调用了一个方法，且调用方法的形参和要实现的接口抽象方法形参一致，则可以进一步简写。举例如下：
接口定义：
@FunctionalInterface
interface Converter<F,T> {
T convert(F form);
}
Lambda表达式
//旧的写法
Converter<String,Integer> convert1 = (from) -> Integer.valueOf(from);
//新的写法
Converter<String,Integer> convert2 = Integer::valueOf;
System.out.println(convert1.convert("1234"));
引用其他类型的方法
- 例子中的方法是Integer类的静态方法，如果是某个类的实例方法，则应该使用一个对象加::来引用。如，obj::func;
- 如果要调用的一个构造方法（抽象方法返回的是一个对象），则应该这样使用：Integer::new。用new代替构造方法名字。
五.Lambda访问外部变量及接口默认方法
访问局部变量
- 可以访问局部的final变量，但不能修改。
- 与匿名内部类不同的是，外部变量不需要显示地声明为final，但却要有final的特点，不能被修改，在Lambda之后被修改也不行。
访问成员变量和静态变量
可以任意读写，举例如下：
public class FunctionInterface {
String str = "init";
static Integer num = 0;
public void testScope() {
Converter<String,Integer> convert = (from) -> {
//在这里可访问成员变量和静态变量
str = from;
num = Integer.valueOf(from);
return num;
};
System.out.println(convert.convert("3453"));
System.out.println(convert.convert("5678"));
}
}
访问接口的默认方法
在匿名类中可以访问接口定义的默认方法，在Lambda中不可以访问。
六.内置函数式接口
Java8中内置了许多函数式接口，包括Comparator和Runnable等，它们被添加了@FunctionalInterface注解，以用来支持Lambda表达式。
6.1Predicate断言
查看源码，这个函数式接口中要实现的方法为：boolean test(T t); 即一个判断传入值真假的方法，当然判断的规则由你自己定义。
如定义一个判断字符串长度是否大于10的Predicate:
import java.util.function.Predicate;
public class PredicateDemo {
public static void main(String[] args) {
Predicate<String> predicate = s -> s.length() > 10;
System.out.println(predicate.test("hello"));
System.out.println(predicate.test("hello,world!"));
}
}
6.2 Function
查其源码，需要实现一个R apply(T t)的方法。这个接口提供链式调用、组合的功能。
6.3 Supplier
Supplier<Person> personSupplier = Person::new;
personSupplier.get();
6.4 Consumer
??
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
6.5 Optional
七.Stream流
什么是Stream流？
参考资料
Stream流提供了一种对集合Collection的方便的操作。分为“中间操作”和“终端操作”两种。中间操作的结果还是返回一个Stream，可以继续操作；而终端操作会返回一个结构不能继续流操作了。
要使用Sream首先要通过Collection的Stream方法获取一个Stream对象。
7.1 Filter过滤 中间操作
筛选出集合中满足一定条件的元素。Stream有一个filter方法，入参是一个Predicate，筛选结果是Predicate.test为true的集合的Stream。下面来看一个筛选出String集合中以"s"开头的String的程序：
List<String> list = Arrays.asList("hello","world","apple","people","sea",
"watch","table","book","school","help");
list
.stream() //获取stream
.filter(s -> s.startsWith("s")) //设置filter。中间操作
.forEach(System.out::println); //打印出流中的元素。终端操作
7.2 Sorted排序 中间操作
可以给sorted()方法传入一个Comparator用来自定义排序，否则将使用默认排序规则。
list
.stream()
.sorted((a,b) -> b.compareTo(a))
.forEach(System.out::println);
7.3 Map
map方法入参为一个Function函数式接口。调用map方法将对集合中的每一个元素执行一下Function中的apply方法，并返回由其返回值组成的集合的流。
举例：将表示数字的字符串集合全部转换为数字再加一后输出。
List<String> list = Arrays.asList("10","100","1000");
System.out.println("---- test map ----");
list
.stream()
.map(Integer::valueOf) //转换为整数
.map(a -> a + 1) //执行加一操作
.forEach(System.out::println);
7.4Match匹配
是种终端操作，结果不是stream对象，而是boolean值
根据Predicate指定的规则判断集合中是否有匹配的，有的话返回true。
有三种形式，anyMatch：有一个匹配就返回true。allMatch：全部匹配返回true。noneMatch：全部不匹配返回true。
boolean anyMatch(Predicate<? super T> predicate);
boolean allMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);
7.5 Count计数
终端操作，统计stream中元素的个数。
long count =
list
.stream() //获取stream
.filter(s -> s.startsWith("s")) //设置filter。中间操作
.count();
7.6 Reduce
list[0]和list[1]执行操作，得到的结果为result。result再和list[2]执行操作，得到的结果result。依次进行，对所有元素执行一遍。
根据上述描述也可以看出，这里的“操作”必须满足两个入参、返回值是同一类型的。
reduce方法的入参是：BinaryOperator<T> 这里的T就是集合的元素类型。
举例：求Integer集合中所有元素的和。
List<Integer> list = Arrays.asList(1,2,3,4,5);
System.out.println("---- test reduce ----");
Optional<Integer> sum =
list
.stream()
.reduce((a,b) -> a + b);
sum.ifPresent(System.out::println);
注意：reduce的返回值为Optional<T>。
