JavaSE的JDK8新特性

不爱编程的小方

已于 2024-07-04 10:01:37 修改

阅读量791

点赞数 23

分类专栏： javaSE 文章标签： java

于 2024-05-31 15:46:44 首次发布

本文链接：https://blog.csdn.net/qq_38053677/article/details/139354619

版权

javaSE 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

函数式接口

有且仅有一个抽象方法的接口

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface {
	void myMethod();
}

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

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

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

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class DemoFunctionalInterface {
    // 使用自定义的函数式接口作为方法参数
    private static void doSomething(MyFunctionalInterface inter) {
    	inter.myMethod(); // 调用自定义的函数式接口方法
	}
    public static void main(String[] args) {
        // 调用使用函数式接口的方法
        doSomething(() -> System.out.println("Lambda执行啦！"));
        
        // 等同于 传了一个 匿名内部类
        doSomething(new MyFunctionalInterface(){
         	   @Override
                void myMethod(){
                    System.out.println("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 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费

如何解决这种性能浪费问题呢？

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

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(1, () ‐> msgA + msgB + msgC );
	}

}

类似于JavaScript中的回调函数

将 lambda表达式作为参数传递给函数式接口

// Runnable接口，满足函数式接口的要求
public class DemoRunnable {
    private static void startThread(Runnable task) {
    	new Thread(task).start();
    }
    public static void main(String[] args) {
    	startThread(() ‐> System.out.println("线程任务执行！"));
    }
}

将lambda表达式作为函数的返回值

public class DemoComparator {
    public Comparator<String> newComparator() {
        return (a, b) -> b.length() - a.length();
    }

    public void test(String[] args) {
        String[] array = { "abc", "ab", "abcd" };
        System.out.println(Arrays.toString(array));
        Arrays.sort(array, newComparator()); // 很像JavaScript中的回调函数
        System.out.println(Arrays.toString(array));
    }
}

常用的函数式接口

Supplier接口

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

Consumer接口

public class DemoConsumer {
    private void consumeString(Consumer<String> function) {
        function.accept("Hello");
    }
    public void test() {
        consumeString(s -> System.out.println(s));
    }
}

默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：

default Consumer<T> andThen(Consumer<? super T> after) {
	Objects.requireNonNull(after);
	return (T t) ‐> { accept(t); after.accept(t); };
}

备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出 NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦

public class Demo10ConsumerAndThen {
    private static void consumeString(Consumer<String> one, Consumer<String> two) {
    	C.addThen(three).accept("Hello");
    }
    public static void main(String[] args) {
        consumeString(
        s ‐> System.out.println(s.toUpperCase()),
        s ‐> System.out.println(s.toLowerCase()),
        s ‐> System.out.println(s.toUpperCase()));
    }
}

运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的组合

Predicate接口

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

抽象方法：test

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

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为：

default Predicate<T> and(Predicate<? super T> other) {
	Objects.requireNonNull(other);
	return (t) ‐> test(t) && other.test(t);
}

如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：

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

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。JDK源码为：

default Predicate<T> or(Predicate<? super T> other) {
	Objects.requireNonNull(other);
	return (t) ‐> test(t) || other.test(t);
}

如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“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

“与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法 negate 的JDK源代码为：

default Predicate<T> negate() {
	return (t) ‐> !test(t);
}

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样：

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 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件

抽象方法：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

Function 接口中有一个默认的 andThen 方法，用来进行组合操作。JDK源代码如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
	Objects.requireNonNull(after);
	return (T t) ‐> after.apply(apply(t));
}

该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：

import java.util.function.Function;
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);
    }
}

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起

请注意，Function的前置条件泛型和后置条件泛型可以相同。

Stream流

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

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);
        }
	}
}

那，Lambda的衍生物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);
     }
 }

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中

获取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）

获取一个流非常简单，有以下几种常用的方式：

所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

根据Collection获取流

首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流

public class Demo04GetStream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // ...
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        // ...
        Stream<String> stream2 = set.stream();
        Vector<String> vector = new Vector<>();
        // ...
        Stream<String> stream3 = vector.stream();
    }
}

根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况：

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();
    }
}

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法 of ，使用很简单：

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

备注： of 方法的参数其实是一个可变参数，所以支持数组

常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法

备注：本小节之外的更多方法，请自行参考API文档。

逐一处理：forEach

void forEach(Consumer<? super T> action)

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理

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

过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

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

映射：map

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

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

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count()

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

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

limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

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

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n)

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

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

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

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);
    }
}

方法引用

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

public class DemoPrintSimple {
    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);
	}
}

对比下面两种写法，完全等效：

Lambda表达式写法： s -> System.out.println(s);
方法引用写法： System.out::println

通过对象名引用成员方法

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

函数式接口仍然定义为：

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

那么当需要使用这个 printUpperCase 成员方法来替代 Printable 接口的Lambda的时候，已经具有了 MethodRefObject 类的对象实例，则可以通过对象名引用成员方法，代码为：

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();
}

然后是父类 Human 的内容：

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

最后是子类 Man 的内容，其中使用了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());
    }
}

但是如果使用方法引用来调用父类中的 sayHello 方法会更好，例如另一个子类 Woman ：

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();
}

下面是一个丈夫 Husband 类：

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

开心方法 beHappy 调用了结婚方法 marry ，后者的参数为函数式接口 Richable ，所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对 Husband 丈夫类进行修改：

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

如果希望取消掉Lambda表达式，用方法引用进行替换，则更好的写法为：

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

类的构造器引用

由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用类名称::new 的格式表示。首先是一个简单的 Person 类：

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;
    }
}

然后是用来创建 Person 对象的函数式接口：

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);
    }
}

数组的构造器引用

数组也是 Object 的子类对象，所以同样具有构造器，只是语法稍有不同。如果对应到Lambda的使用场景中时，需要一个函数式接口：

@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);
	}
}

在这个例子中，下面两种写法是等效的：

Lambda表达式： length -> new int[length]
方法引用： int[]::new

不爱编程的小方

关注

23
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
JavaSE的JDK8新特性

有且仅有一个抽象方法的接口与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface。一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。
复制链接

扫一扫