【Java10】JDK8新特性

01 函数式接口

1.1 相关介绍

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

小贴士：因为接口中有且仅有一个抽象方法，所以该抽象方法的 public abstract 是可以省略的。

@FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一

个新的注解： @FunctionalInterface 。该注 解可用于一个接口的定义上：

@FunctionalInterface public interface MyFunctionalInterface { 
    void myMethod(); 
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

如：

public class Demo01Logger { 
    private static void log(int level, String msg) { 
        if (level == 1) { 
            System.out.println(msg); 
        } 
    }
    
    public static void main(String[] args) { 
        String msgA = "Hello"; 
        String msgB = "World"; 
        String msgC = "Java"; 
        log(1, msgA + msgB + msgC); 
    } 
}

这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方 法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

Lambda的更优写法:

使用Lambda必然需要一个函数式接口：

@FunctionalInterface 
public interface MessageBuilder { 
    String buildMessage(); 
}

然后对 log 方法进行改造：

public class Demo02LoggerLambda { 
    private static void log(int level, MessageBuilder builder) { 
        if (level == 1) { 
            System.out.println(builder.buildMessage()); 
        } 
    }
    
    public static void main(String[] args) { 
        String msgA = "Hello"; 
        String msgB = "World"; 
        String msgC = "Java"; 
        //log(2, () ‐> msgA + msgB + msgC );
        //在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。
        log(2, () ‐> { 
            System.out.println("Lambda执行！"); 
            return msgA + msgB + msgC; 
        });
    } 
}

这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接；否则三个字符串将不会进行拼接。

1.2 常用函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。下面是最简单的几个接口及使用示例。

Supplier接口

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对 象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象 数据。

public class Demo08Supplier { 
    private static String getString(Supplier<String> function) { 
        return function.get(); 
    }
    
    public static void main(String[] args) { 
        String msgA = "Hello"; 
        String msgB = "World"; 
        System.out.println(getString(() ‐> msgA + msgB)); 
    } 
}

Consumer接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

public class Demo09Consumer { 
    private static void consumeString(Consumer<String> function) { 
        function.accept("Hello"); 
    }
    
    public static void main(String[] args) { 
        consumeString(s ‐> System.out.println(s)); 
    } 
}

默认方法：andThen

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组 合的情况：

public class DemoConsumer { 
    public static void main(String[] args) { 
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" }; 
        printInfo(s ‐> System.out.print("姓名：" + s.split(",")[0]), s ‐> System.out.println("。性别：" + s.split(",")[1] + "。"), array); 
    }
    
    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) { 
        for (String info : array) { 
        	one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。 
        } 
    } 
}

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate<T> 接口。

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：

public class Demo15PredicateTest { 
    private static void method(Predicate<String> predicate) { 
        boolean veryLong = predicate.test("HelloWorld"); 
        System.out.println("字符串很长吗：" + veryLong); 
    }
    
    public static void main(String[] args) { 
        method(s ‐> s.length() > 5); 
    } 
}

默认方法：and

import java.util.function.Predicate; public class Demo16PredicateAnd { 
    private static void method(Predicate<String> one, Predicate<String> two) { 
        boolean isValid = one.and(two).test("Helloworld"); 
        System.out.println("字符串符合要求吗：" + isValid); }
    
    public static void main(String[] args) { 
        method(s ‐> s.contains("H"), s ‐> s.contains("W")); 
    } 
}

默认方法：or

public class Demo16PredicateAnd { 
    private static void method(Predicate<String> one, Predicate<String> two) { 
        boolean isValid = one.or(two).test("Helloworld"); 
        System.out.println("字符串符合要求吗：" + isValid); }
    
    public static void main(String[] args) { 
        method(s ‐> s.contains("H"), s ‐> s.contains("W")); 
    } 
}

默认方法：negate

“与”、“或”已经了解了，剩下的“非”（取反）也会简单。

public class Demo17PredicateNegate { 
    private static void method(Predicate<String> predicate) { 
        boolean veryLong = predicate.negate().test("HelloWorld"); 
        System.out.println("字符串很长吗：" + veryLong); 
    }
    
    public static void main(String[] args) { 
        method(s ‐> s.length() < 5); 
    } 
}

Function接口

java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。

抽象方法：apply

Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。

使用的场景例如：将 String 类型转换为 Integer 类型。

public class Demo11FunctionApply { 
    private static void method(Function<String, Integer> function) { 
        int num = function.apply("10"); 
        System.out.println(num + 20); 
    }
    
    public static void main(String[] args) { 
        method(s ‐> Integer.parseInt(s));
    } 
}

默认方法：andThen

public class Demo12FunctionAndThen { 
    private static void method(Function<String, Integer> one, Function<Integer, Integer> two) { 
        int num = one.andThen(two).apply("10"); 
        System.out.println(num + 20); 
    }
    
    public static void main(String[] args) { 
        method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10); 
    } 
}

02 Stream流、方法引用

2.1 Stream流

说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带 来的函数式编程，引入了一个全新Stream概念，用于解决已有集合类库既有的弊端。

例如，集合的一系列操作，在Java 8之前的做法可能为：

public class Demo02NormalFilter { 
    public static void main(String[] args) { 
        List<String> list = new ArrayList<>(); 
        list.add("张无忌"); 
        list.add("周芷若"); 
        list.add("赵敏"); 
        list.add("张强"); 
        list.add("张三丰"); 
        List<String> zhangList = new ArrayList<>();
        for (String name : list) { 
            if (name.startsWith("张")) { 
                zhangList.add(name); 
            } 
        }
        
        List<String> shortList = new ArrayList<>(); 
        for (String name : zhangList) { 
            if (name.length() == 3) { 
                shortList.add(name); 
            } 
        }for (String name : shortList) { 
            System.out.println(name); 
        } 
    } 
}

Stream改进：

public class Demo03StreamFilter { 
    public static void main(String[] args) { 
        List<String> list = new ArrayList<>(); 
        list.add("张无忌"); 
        list.add("周芷若"); 
        list.add("赵敏"); 
        list.add("张强"); 
        list.add("张三丰"); 
        list.stream() .filter(s ‐> s.startsWith("张")) .filter(s ‐> s.length() == 3) .forEach(System.out::println); 
    } 
}

小贴士：当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结 果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以 像链条一样排列，变成一个管道。

获取流的方式

根据Collection获取流

根据Map获取流

public class Demo05GetStream { 
    public static void main(String[] args) { 
        Map<String, String> map = new HashMap<>(); 
        // ... 
        Stream<String> keyStream = map.keySet().stream(); 
        Stream<String> valueStream = map.values().stream(); 
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream(); 
    } 
}

根据数组获取流 (静态方法of)

public class Demo06GetStream { 
    public static void main(String[] args) { 
        String[] array = { "张无忌", "张翠山", "张三丰", "张一元" }; 
        Stream<String> stream = Stream.of(array); 
    } 
}

常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种： 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方 法均为延迟方法。） 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调 用。本小节中，终结方法包括 count 和 forEach 方法。

逐一处理：forEach

public class Demo12StreamForEach { 
	public static void main(String[] args) { 
		Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若"); 
		stream.forEach(name‐> System.out.println(name)); 
		} 
}

过滤：filter

public class Demo07StreamFilter { 
    public static void main(String[] args) { 
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
        Stream<String> result = original.filter(s ‐> s.startsWith("张")); 
    } 
}

映射：map

public class Demo08StreamMap { 
    public static void main(String[] args) { 
        Stream<String> original = Stream.of("10", "12", "18"); 
        Stream<Integer> result = original.map(str‐>Integer.parseInt(str)); 
    } 
}

统计个数：count

public class Demo09StreamCount { 
    public static void main(String[] args) { 
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
        Stream<String> result = original.filter(s ‐> s.startsWith("张")); 
        System.out.println(result.count()); // 2 
    } 
}

取用前几个：limit

public class Demo10StreamLimit { 
    public static void main(String[] args) { 
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
        Stream<String> result = original.limit(2); 
        System.out.println(result.count()); // 2 
    } 
}

跳过前几个：skip

public class Demo11StreamSkip { 
    public static void main(String[] args) { 
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
        Stream<String> result = original.skip(2); System.out.println(result.count()); // 1 
    } 
}

组合：concat

public class Demo12StreamConcat { 
    public static void main(String[] args) { 
        Stream<String> streamA = Stream.of("张无忌"); 
        Stream<String> streamB = Stream.of("张翠山"); 
        Stream<String> result = Stream.concat(streamA, streamB); 
    } 
}

2.2 方法引用

冗余Lambda场景

@FunctionalInterface 
public interface Printable {
    void print(String str); 
}

public class Demo01PrintSimple { 
    private static void printString(Printable data) { 
        data.print("Hello, World!"); 
    }
    
    public static void main(String[] args) { 
        printString(s ‐> System.out.println(s)); 
    } 
}

方法引用改进:

public class Demo02PrintRef { 
    private static void printString(Printable data) { 
        data.print("Hello, World!"); 
    }
    
    public static void main(String[] args) { 
        printString(System.out::println);                     
    } 
}

通过对象名引用成员方法

public class MethodRefObject { 
    public void printUpperCase(String str) { 
        System.out.println(str.toUpperCase()); 
    } 
}

@FunctionalInterface public interface Printable { 
    void print(String str); 
}

public class Demo04MethodRef { 
    private static void printString(Printable lambda) { 
        lambda.print("Hello"); 
    }
    
    public static void main(String[] args) { 
        MethodRefObject obj = new MethodRefObject(); 
        printString(obj::printUpperCase); 
    } 
}

通过类名称引用静态方法

@FunctionalInterface public interface Calcable { 
    int calc(int num); 
}

Lambda:

public class Demo05Lambda { 
    private static void method(int num, Calcable lambda) { 
        System.out.println(lambda.calc(num)); 
    }
    
    public static void main(String[] args) { 
        method(‐10, n ‐> Math.abs(n)); 
    } 
}

方法引用:

public class Demo06MethodRef { 
    private static void method(int num, Calcable lambda) { 
        System.out.println(lambda.calc(num)); 
    }
    
    public static void main(String[] args) { 
        method(‐10, Math::abs); 
    } 
}

通过super引用成员方法

@FunctionalInterface 
public interface Greetable { 
    void greet(); 
}

public class Human { 
    public void sayHello() { 
        System.out.println("Hello!"); 
    } 
}

Lambda:

public class Man extends Human { 
    @Override 
    public void sayHello() { 
        System.out.println("大家好,我是Man!"); 
    }
    
    //定义方法method,参数传递Greetable接口 
    public void method(Greetable g){ 
        g.greet(); 
    }
    
    public void show(){ 
        //调用method方法,使用Lambda表达式 
        method(()‐>{ 
            //创建Human对象,调用sayHello方法 
            new Human().sayHello(); 
        }); 
        //简化Lambda 
        method(()‐>new Human().sayHello()); 
        //使用super关键字代替父类对象 
        method(()‐>super.sayHello());
    } 
}

方法引用:

public class Man extends Human { 
    @Override 
    public void sayHello() { 
        System.out.println("大家好,我是Man!"); 
    }
    
    //定义方法method,参数传递Greetable接口 
    public void method(Greetable g){ 
        g.greet(); 
    }
    
    public void show(){ 
        method(super::sayHello); 
    } 
}

通过this引用成员方法

@FunctionalInterface 
public interface Richable { 
    void buy(); 
}

public class Husband { 
    private void marry(Richable lambda) { 
        lambda.buy(); 
    }
    
    public void beHappy() { 
        marry(() ‐> System.out.println("买套房子")); 
    } 
}

Lambda:

public class Husband { 
    private void buyHouse() { 
        System.out.println("买套房子");
    }
    
    private void marry(Richable lambda) { 
        lambda.buy(); 
    }
    
    public void beHappy() { 
        marry(() ‐> this.buyHouse()); 
    } 
}

方法引用：

public class Husband { 
    private void buyHouse() { 
        System.out.println("买套房子"); 
    }
    
    private void marry(Richable lambda) { 
        lambda.buy(); 
    }
    
    public void beHappy() { 
        marry(this::buyHouse); 
    } 
}

类的构造器引用

public class Person { 
    private String name; 
    
    public Person(String name) { 
        this.name = name; 
    }
    
    public String getName() { 
        return name; 
    }
    
    public void setName(String name) { 
        this.name = name; 
    } 
}

public interface PersonBuilder { 
    Person buildPerson(String name); 
}

Lambda:

public class Demo09Lambda { 
    public static void printName(String name, PersonBuilder builder) { System.out.println(builder.buildPerson(name).getName());                 }
    
    public static void main(String[] args) { 
        printName("赵四", name ‐> new Person(name)); 
    }
}

方法引用：

public class Demo10ConstructorRef { 
    public static void printName(String name, PersonBuilder builder) { System.out.println(builder.buildPerson(name).getName()); 
                                                                     }
    
    public static void main(String[] args) { 
        printName("赵四", Person::new); 
    } 
}

数组的构造器引用

@FunctionalInterface 
public interface ArrayBuilder { 
    int[] buildArray(int length); 
}

Lambda:

public class Demo11ArrayInitRef { 
    private static int[] initArray(int length, ArrayBuilder builder) { 
        return builder.buildArray(length); 
    }
    
    public static void main(String[] args) { 
        int[] array = initArray(10, length ‐> new int[length]); 
    } 
}

方法引用：

public class Demo12ArrayInitRef { 
    private static int[] initArray(int length, ArrayBuilder builder) { 
        return builder.buildArray(length); 
    }
    
    public static void main(String[] args) { 
        int[] array = initArray(10, int[]::new); 
    } 
}