算法设计者

这个屌丝很懒，什么也没留下！

热门标签

JDK 8 新特性之接口详解_jdk8 supplier

作者：算法设计者 | 2024-02-01 10:20:49

踩

jdk8 supplier

一：接口新增的两个方法

JDK 8以前的接口：


interface 接口名 {
静态常量;
抽象方法;
}

JDK 8 对接口的增强，接口还可以有 默认方法 和 静态方法

JDK 8的接口：


interface 接口名 {
静态常量;
抽象方法;
默认方法;
静态方法;
}

接口引入默认方法的背景

在 JDK 8 以前接口中只能有抽象方法。存在以下问题：

如果给接口新增抽象方法，所有实现类都必须重写这个抽象方法。不利于接口的扩展。


interface A {
public abstract void test1();
// 接口新增抽象方法,所有实现类都需要去重写这个方法,非常不利于接口的扩展
public abstract void test2();
}
class B implements A {
@Override
public void test1() {
System.out.println("BB test1");
}
// 接口新增抽象方法,所有实现类都需要去重写这个方法
@Override
public void test2() {
System.out.println("BB test2");
}
}
class C implements A {
@Override
public void test1() {
System.out.println("CC test1");
}
// 接口新增抽象方法,所有实现类都需要去重写这个方法
@Override
public void test2() {
System.out.println("CC test2");
}
}

例如， JDK 8 时在 Map 接口中增加了 forEach 方法：


public interface Map<K, V> {
...
abstract void forEach(BiConsumer<? super K, ? super V> action);
}

通过 API 可以查询到 Map 接口的实现类如：


Interface Map<K， V>
所有已知实现类：
AbstractMap，ConcurrentSkipListMap，IdentityHashMap，MapPropertyBase，Provider，Rendering Hints，SimpleMapProperty，Attributes，ReadonlyMapProperty，AuthProvider，EnumMapHashMap，
clipboardContent，Hashtable，SimpleBindings，TreeMap，ConcurrentHashMap，MapProperty，
ReadOnlyMapWrapper，Headers.Properties，LinkedHashMap，MultiMap Result，ScriptObjectMirror，
TabularDataSupport，MapBinding，MapExpression，PrinterStateReasons，ReadonlyMapPropertyBase，UIDefaults，WeakHashMap

如果在 Map 接口中增加一个抽象方法，所有的实现类都需要去实现这个方法，那么工程量时巨大的。

因此，在 JDK 8 时为接口新增了默认方法，效果如下：


public interface Map<K, V> {
...
default void forEach(BiConsumer<? super K, ? super V> action) {
...
}
}

接口中的默认方法实现类不必重写，可以直接使用，实现类也可以根据需要重写。这样就方便接口的扩展。

接口默认方法的定义格式


interface 接口名 {
修饰符 default 返回值类型 方法名() {
代码;
}
}

接口默认方法的使用

方式一：实现类直接调用接口默认方法

方式二：实现类重写接口默认方法


public class Demo02UserDefaultFunction {
public static void main(String[] args) {
BB b = new BB();
// 方式一：实现类直接调用接口默认方法
b.test02();
CC c = new CC();
// 调用实现类重写接口默认方法
c.test02();
}
}
interface AA {
public abstract void test1();
public default void test02() {
System.out.println("AA test02");
}
}
class BB implements AA {
@Override
public void test1() {
System.out.println("BB test1");
}
}
class CC implements AA {
@Override
public void test1() {
System.out.println("CC test1");
}
// 方式二：实现类重写接口默认方法
@Override
public void test02() {
System.out.println("CC实现类重写接口默认方法");
}
}

二：接口静态方法

为了方便接口扩展， JDK 8 为接口新增了静态方法。

接口静态方法的定义格式


interface 接口名 {
修饰符 static 返回值类型 方法名() {
代码;
}
}

接口静态方法的使用

直接使用接口名调用即可：接口名. 静态方法名 ();


public class Demo04UseStaticFunction {
public static void main(String[] args) {
// 直接使用接口名调用即可：接口名.静态方法名();
AAA.test01();
}
}
interface AAA {
public static void test01() {
System.out.println("AAA 接口的静态方法");
}
}
class BBB implements AAA {
/* @Override 静态方法不能重写
public static void test01() {
System.out.println("AAA 接口的静态方法");
}*/
}

接口默认方法和静态方法的区别：

1. 默认方法通过实例调用，静态方法通过接口名调用。

2. 默认方法可以被继承，实现类可以直接使用接口默认方法，也可以重写接口默认方法。

3. 静态方法不能被继承，实现类不能重写接口静态方法，只能使用接口名调用。

小结：

接口中新增的两种方法：

默认方法和静态方法

如何选择呢？

如果这个方法需要被实现类继承或重写，使用默认方法，如果接口中的方法不需要被继承就使用静态方法

三：常用内置函数式接口

内置函数式接口来由来

我们知道使用 Lambda 表达式的前提是需要有函数式接口。而 Lambda 使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda 方便， JDK 提供了大量常用的函数式接口。


import java.util.List;
public class Demo01UserFunctionalInterface {
public static void main(String[] args) {
// 调用函数式接口中的方法
method((arr) -> {
int sum = 0;
for (int n : arr) {
sum += n;
}
return sum;
});
}
// 使用自定义的函数式接口作为方法参数
public static void method(Operator op) {
int[] arr = {1, 2, 3, 4};
int sum = op.getSum(arr);
System.out.println("sum = " + sum);
}
}
@FunctionalInterface
interface Operator {
public abstract int getSum(int[] arr);
}

常用内置函数式接口介绍

它们主要在 java.util.function 包中。下面是最常用的几个接口。

1. Supplier 接口


@FunctionalInterface
public interface Supplier<T> {
public abstract T get();
}

2. Consumer 接口


@FunctionalInterface
public interface Consumer<T> {
public abstract void accept(T t);
}

3. Function 接口


@FunctionalInterface
public interface Function<T, R> {
public abstract R apply(T t);
}

4. Predicate 接口


@FunctionalInterface
public interface Predicate<T> {
public abstract boolean test(T t);
}
Predicate接口用于做判断,返回boolean类型的值

四：Supplier接口

java.util.function.Supplier<T> 接口，它意味着 " 供给 " , 对应的 Lambda 表达式需要 “ 对外提供 ” 一个符合泛型类型的对象数据。


@FunctionalInterface
public interface Supplier<T> {
public abstract T get();
}

供给型接口，通过 Supplier 接口中的 get 方法可以得到一个值，无参有返回的接口。

使用 Lambda 表达式返回数组元素最大值

使用 Supplier 接口作为方法参数类型，通过 Lambda 表达式求出 int 数组中的最大值。提示：接口的泛型请使用 java.lang.Integer 类。

代码示例 :


public class Demo05Supplier {
public static void main(String[] args) {
printMax(() -> {
int[] arr = {10, 20, 100, 30, 40, 50};
// 先排序,最后就是最大的
Arrays.sort(arr);
return arr[arr.length - 1]; // 最后就是最大的
});
}
private static void printMax(Supplier<Integer> supplier) {
int max = supplier.get();
System.out.println("max = " + max);
}
}

五：Consumer接口

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


@FunctionalInterface
public interface Consumer<T> {
public abstract void accept(T t);
}

使用 Lambda 表达式将一个字符串转成大写和小写的字符串

Consumer 消费型接口，可以拿到 accept 方法参数传递过来的数据进行处理 , 有参无返回的接口。基本使用如：


import java.util.function.Consumer;
public class Demo06Consumer {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
System.out.println(s.toLowerCase());
});
}
public static void test(Consumer<String> consumer) {
consumer.accept("HelloWorld");
}
}

默认方法： 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 语句和抛出空指针异常的麻烦。

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


public class Demo07ConsumerAndThen {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
System.out.println(s.toLowerCase());
}, (String s) -> {
System.out.println(s.toUpperCase());
});
// Lambda表达式简写
test(s -> System.out.println(s.toLowerCase()), s ->
System.out.println(s.toUpperCase()));
}
public static void test(Consumer<String> c1, Consumer<String > c2) {
String str = "Hello World";
// c1.accept(str); // 转小写
// c2.accept(str); // 转大写
// c1.andThen(c2).accept(str);
c2.andThen(c1).accept(str);
}
}

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

六：Function接口

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


@FunctionalInterface
public interface Function<T, R> {
public abstract R apply(T t);
}

使用 Lambda 表达式将字符串转成数字

Function 转换型接口，对 apply 方法传入的 T 类型数据进行处理，返回 R 类型的结果，有参有返回的接口。使用的场景

例如：将 String 类型转换为 Integer 类型。


public class Demo08Function {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
return Integer.parseInt(s); // 10
});
}
public static void test(Function<String, Integer> function) {
Integer in = function.apply("10");
System.out.println("in: " + (in + 5));
}
}

默认方法： 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 差不多：


public class Demo09FunctionAndThen {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
return Integer.parseInt(s);
}, (Integer i) -> {
return i * 10;
});
}
public static void test(Function<String, Integer> f1, Function<Integer, Integer> f2) {
// Integer in = f1.apply("66"); // 将字符串解析成为int数字
// Integer in2 = f2.apply(in);// 将上一步的int数字乘以10
Integer in3 = f1.andThen(f2).apply("66");
System.out.println("in3: " + in3); // 660
}
}

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

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

七：Predicate接口

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


@FunctionalInterface
public interface Predicate<T> {
public abstract boolean test(T t);
}
Predicate接口用于做判断,返回boolean类型的值

使用 Lambda 判断一个人名如果超过 3 个字就认为是很长的名字

对 test 方法的参数 T 进行判断，返回 boolean 类型的结果。用于条件判断的场景：


public class Demo10Predicate {
public static void main(String[] args) {
test(s -> s.length() > 3, "迪丽热巴");
}
private static void test(Predicate<String> predicate, String str) {
boolean veryLong = predicate.test(str);
System.out.println("名字很长吗：" + veryLong);
}
}

条件判断的标准是传入的 Lambda 表达式逻辑，只要名称长度大于 3 则认为很长。

默认方法： and

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


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

案例：

使用Lambda表达式判断一个字符串中即包含W,也包含H
使用Lambda表达式判断一个字符串中包含W或者包含H
使用Lambda表达式判断一个字符串中即不包含W

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


public class Demo10Predicate_And_Or_Negate {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
return s.contains("H");
}, (String s) -> {
return s.contains("W");
});
}
public static void test(Predicate<String> p1, Predicate<String> p2) {
String str = "HelloWorld";
boolean b1 = p1.test(str); // 判断包含大写“H”
boolean b2 = p2.test(str); // 判断包含大写“W”
// if (b1 && b2) {
// System.out.println("即包含W,也包含H");
// }
boolean bb = p1.and(p2).test(str);
if (bb) {
System.out.println("即包含W,也包含H");
}
}
}

默认方法： or

使用 Lambda 表达式判断一个字符串中包含 W 或者包含 H

与 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 Demo10Predicate_And_Or_Negate {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
return s.contains("H");
}, (String s) -> {
return s.contains("W");
});
}
public static void test(Predicate<String> p1, Predicate<String> p2) {
String str = "HelloWorld";
boolean b1 = p1.test(str); // 判断包含大写“H”
boolean b2 = p2.test(str); // 判断包含大写“W”
// if (b1 || b2) {
// System.out.println("有H,或者W");
// }
boolean bbb = p1.or(p2).test(str);
if (bbb) {
System.out.println("有H,或者W");
}
}
}

默认方法： negate

使用 Lambda 表达式判断一个字符串中即不包含 W

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


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

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


import java.util.function.Predicate;
public class Demo10Predicate_And_Or_Negate {
public static void main(String[] args) {
// Lambda表达式
test((String s) -> {
return s.contains("H");
}, (String s) -> {
return s.contains("W");
});
}
public static void test(Predicate<String> p1, Predicate<String> p2) {
String str = "HelloWorld";
boolean b1 = p1.test(str); // 判断包含大写“H”
boolean b2 = p2.test(str); // 判断包含大写“W”
// 没有H,就打印
// if (!b1) {
// System.out.println("没有H");
// }
boolean test = p1.negate().test(str);
if (test) {
System.out.println("没有H");
}
}
}

小结：

1. Supplier 接口


@FunctionalInterface
public interface Supplier<T> {
public abstract T get();
}

2. Consumer 接口


@FunctionalInterface
public interface Consumer<T> {
public abstract void accept(T t);
}

3. Function 接口


@FunctionalInterface
public interface Function<T, R> {
public abstract R apply(T t);
}

4. Predicate 接口


@FunctionalInterface
public interface Predicate<T> {
public abstract boolean test(T t);
}
Predicate接口用于做判断,返回boolean类型的值

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/53209

JDK 8 新特性之接口详解_jdk8 supplier

一：接口新增的两个方法

接口默认方法的定义格式

接口默认方法的使用

二：接口静态方法

接口默认方法和静态方法的区别：

小结 ：

三：常用内置函数式接口

四：Supplier接口

五：Consumer接口

六：Function接口

七：Predicate接口

案例：

小结：

小结：