开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 10 JDK8新特性 -> 正文阅读

[Java知识库]10 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); 
    } 
}