java8新特性

• default拓展方法

java8为接口声明添加非抽象方法的实现，也成为拓展方法。

public interface Formula {    void doSomething();    default void before() {        System.out.println("我是拓展方法");    }}public class FormulaService implements Formula {    @Override    public void doSomething() {        before();        System.out.println("我是override方法");    }}

• Lambda表达式

java8引入函数式编程，Lambda则是函数式编程的基础。

List<String> list = Arrays.asList("a", "b", "c");// java8之前Collections.sort(list, new Comparator<String>(){    @Override    public int compare(String o1, String o2) {        return o1.compareTo(o2);    }});// lambdaCollections.sort(list, (String o1, String o2) -> {            return o2.compareTo(o1);});// 简洁lambdaCollections.sort(list, (String o1, String o2) ->  o2.compareTo(o1));// 更简洁lambdaCollections.sort(list, (o1, o2) ->  o2.compareTo(o1));

• 函数式接口

一个函数式接口有且只能有一个抽象方法申明，其中该注意的是 @FunctionalInterface 注解，此时如果在接口中定义了第二个抽象方法，编译器将会抛出异常。当然如果不加该注解也不是不行，如果接口中有多个抽象方法，而你又使用了lambda表达式，则在调用处会抛出异常。

@FunctionalInterfacepublic interface Formula<F,T>{    T convert(F var1);}Formula<String,Integer> function = (var1 -> Integer.valueOf(var1));Integer var2 = function.convert("1000"); 

• 方法和构造函数引用

方法引用的标准语法是 类名:方法名

类型示例引用静态方法targetClass :: staticMethodName引用某个对象的实例方法targetClass :: instanceMethodName引用某个类型的任意对象的实例方法targetType :: methodName引用构造方法className :: new

引用静态方法

Formula<String,Integer> function = (Integer::valueOf);Integer var2 = function.convert("1000");

引用某个类型的任意对象的实例方法

public static void main(String[] args) {   String[] array = {"贱明", "学友"};   Arrays.sort(array, String::compareTo);}

引用构造方法

// 定义工厂interface PersonFactory<P extends Person>{    P create(String name);}// Person类的构造方法public Person(String name) {    this.name = name;}// 创建PersonFactory<Person> factory = Person::new;factory.create("贱明");

• Lambda的范围

lambda可以访问局部对应的外部区域的局部final变量，以及成员变量和静态变量。

访问成员变量

public void doSomething(){    final String p1 = "贱明";    final String p2 = "学友";    Formula function = (person1, person2) -> p1.compareTo(p2);}

与java8以下版本不同的是，p1 p2你可以不修饰成final 也不会报错，但是如果你想修改他们，编译器则会告诉你这是不被允许的。

访问成员变量和静态变量

public void doSomething(){;   Formula function = (person1, person2) ->{       dehua = "贱明";       xueyou="学友";       return dehua.compareTo(xueyou);   };}

• 内置函数式接口

java8 api中提供了很多内置函数式接口，而且有些接口其实在Google Guava中已经实现了，很大程度的降低了程序员的工作负担。

Predicates
Predicate是一个布尔类型的函数，该函数只有一个输入参数，他包含了多种默认实现。

public static void main(String[] args) {   Predicate<String> predicate = (s) -> s.contains("贱明");   String var1 = "牛贱明";   predicate.test(var1);              // true   predicate.negate().test(var1);     // false   Predicate<Boolean> nonNull = Objects::nonNull;   Predicate<Boolean> isNull = Objects::isNull;   Predicate<String> isEmpty = String::isEmpty;   Predicate<String> isNotEmpty = isEmpty.negate();   isNotEmpty.and(isEmpty).test(var1);}

Functions

Function接口接收一个参数，并返回单一的结果。默认方法可以将多个函数串在一起

public static void main(String[] args) {   Function<String, Integer> toInteger = Integer::valueOf;   Function<String, String> backToString = toInteger.andThen(String::valueOf);   System.out.println(toInteger.apply("123"));   System.out.println(backToString.apply("123"));}

Suppliers

Supplier接口产生一个给定类型的结果。与Function不同的是，Supplier没有输入参数。

Supplier<Person> personSupplier = Person::new;Person p = personSupplier.get();   // new Person

Consumers

Consumer代表了在一个输入参数上需要进行的操作。

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.getName());greeter.accept(new Person("贱明"));

Comparators

Comparator接口在早期的Java版本中非常著名。Java 8 为这个接口添加了不同的默认方法。

Comparator<Person> comparator = (p1, p2) -> p1.getName().compareTo(p2.getName());Person p1 = new Person("贱明");Person p2 = new Person("学友");System.out.println(comparator.compare(p1, p2));             // > 1105System.out.println(comparator.reversed().compare(p1, p2));  // < -1105

Optionals

Optional不是一个函数式接口，而是一个精巧的工具接口，用来防止NullPointerException产生。
Optional是一个简单的值容器，这个值可以是null，也可以是non-null。考虑到一个方法可能会返回一个non-null的值，也可能返回一个空值。为了不直接返回null，我们在Java 8中就返回一个Optional。

Optional<String> optional = Optional.of("贱明");System.out.println(optional.isPresent()); // true      System.out.println(optional.get()); // 贱明   System.out.println(optional.orElse("学友")); // 贱明        optional.ifPresent((s) -> System.out.println(s.charAt(0)));