JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景,它们主要在java.util.function包中被提供,下面是最简单的几个接口及使用示例。
一:自定义函数式接口:
对于刚刚定义好的MyFunctionalInterface函数式接口,典型使用场景就是作为方法的参数:
public class FunctionalInterface {
// 使用自定义的函数式接口作为方法参数
private static void doSomething(MyFunctionalInterface inter) {
inter.myMethod(); // 调用自定义的函数式接口方法
}
public static void main(String[] args) {
// 调用使用函数式接口的方法
doSomething(() -> System.out.println("Lambda执行啦!"));
}
}
与@Override注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解:@FunctionalInterface。该注解可用于一个接口的定义上:
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
二:Supplier接口:
java.util.function.Supplier接口,它意味着"供给" , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
1>抽象方法 get
java.util。funtion.Supplier<>接口仅包含一个无参的方法:T get()。用来获取一个泛型参数指定类型的对象数据。它意味着"供给" , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
/*
Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据
*/
public class Demo01Supplier {
//定义一个方法,方法的参数传递Supplier<T>接口,泛型执行String,get方法就会返回一个String
public static String getString(Supplier<String> sup){
return sup.get();
// 不要被sup.get()所迷惑,你试试return "hello world",也是可以的,不过我们要想拿到生产型接口的返回值,自然而然就是sup.get()了,
}
public static void main(String[] args) {
//调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
String s = getString(()->{
//生产一个字符串,并返回
return "不磨";
});
System.out.println(s);
//优化Lambda表达式
String s2 = getString(()->"不磨");
System.out.println(s2);
}
}
输出:
不磨
实现:使用Supplier生产型,接口实现数组元素最大值
public static int getMax(Supplier<Integer>sup){
return sup.get();
}
public static void main(String[] args) {
//定义一个int 类型的数组,并赋值
int[]arr={10,25,645,4,854,55,46,0,56};
//调用getMax方法,方法参数Supplier是一个函数式接口,所以可以转换为lambda表达式
int maxValue=getMax(()->{
//获取最大值
//定义一个变量,
int max=arr[0];
for (int i : arr) {
//使用其他的元素和最大值比较
if(i>max) {
//如果i大于max,则替换max作为最大值
max = i;
} }
//返回最大值
return max;
});
System.out.println("数组中元素的最大值是:"+maxValue);
}
}
输出结果:
数组中元素的最大值是:854
二:Consumer接口:
Consumer接口与Supplier接口则正好相反,他不生产一个数据,而是消费一个数据,其数据类型由泛型确定。
1:抽象方法:accept
普通写法
public class ConsumerDemo {
public static void main(String[] args) {
//将指定数据进行消费,将传递过来的参数进行大写转换
method(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s.toUpperCase());
}
}, "asc");
}
private static void method(Consumer<String> consumer, String str) {
consumer.accept(str);
}
lambda表达式写法:
method("avb",s -> System.out.println(s.toUpperCase());
默认方法:andThen
如果一个方法的参数和返回值全都是Consumer类型,那么就可以实现效果:消费一个数据的时候,首先做一个操作,然后再做一个操作,实现组合。而这个方法就是Consumer接口中的default方法andThen。下面是JDK的源代码:
default Consumer<T> andThen(Co0nsumer<? 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 Demo10ConsumerAndThen {
private static void consumeString(Consumer<String> one, Consumer<String> two,String str) {
one.andThen(two).accept(str);
}
public static void main(String[] args) {
consumeString(
s -> System.out.println(s.toUpperCase()),
s -> System.out.println(s.toLowerCase()),
"HeLLo");
}
}
运行结果将会首先打印完全大写的HELLO,然后打印完全小写的hello。当然,通过链式写法可以实现更多步骤的组合。
三:Function接口
java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据,前者称为前置条件,后者称为后置条件。有进有出,所以称为“函数Function”。
1>抽象方法:apply
Function接口中最主要的抽象方法为:R apply(T t),根据类型T的参数获取类型R的结果。使用的场景例如:将String类型转换为Integer类型。
public class Demo11FunctionApply {
private static void method(Function<String, Integer> function, Str str) {
int num = function.apply(str);
System.out.println(num + 20);
}
public static void main(String[] args) {
method(s -> Integer.parseInt(s) , "10");
}
}
2>默认方法: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 Demo12FunctionAndThen {
private static void method(Function<String, Integer> one, Function<Integer, Integer> two, String str) {
int num = one.andThen(two).apply(str);
System.out.println(num + 20);
}
public static void main(String[] args) {
method(s -> Integer.parseInt(s), i -> i *= 10, "10");
}
}
第一个操作是将字符串解析成为int数字,第二个操作是乘以10。两个操作通过andThen按照前后顺序组合到了一起。
请注意,Function的前置条件泛型和后置条件泛型可以相同。
四:Predicate接口
有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate接口。
一:抽象方法:test
Predicate接口中包含一个抽象方法:boolean test(T t)。用于条件判断的场景:
public class Demo15PredicateTest {
private static void method(Predicate<String> predicate,String str) {
boolean veryLong = predicate.test(str);
System.out.println("字符串很长吗:" + veryLong);
}
public static void main(String[] args) {
method(s -> s.length() > 5, "HelloWorld");
}
}
条件判断的标准是传入的Lambda表达式逻辑,只要字符串长度大于5则认为很长。
2>默认方法: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,String str) {
boolean isValid = one.and(two).test(str);
System.out.println("字符串符合要求吗:" + isValid);
}
public static void main(String[] args) {
method(s -> s.contains("H"), s -> s.contains("W"),"Helloworld");
}
}
3>默认方法: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,String str) {
boolean isValid = one.or(two).test(str);
System.out.println("字符串符合要求吗:" + isValid);
}
public static void main(String[] args) {
method(s -> s.contains("H"), s -> s.contains("W"),"Helloworld");
}
}
4>默认方法:negate
“与”、“或”已经了解了,剩下的“非”(取反)也会简单。默认方法negate的JDK源代码为:
default Predicate<T> negate() {
return (t) -> !test(t);
}
从实现中很容易看出,它是执行了test方法之后,对结果boolean值进行“!”取反而已。一定要在test方法调用之前调用negate方法,正如and和or方法一样:
import java.util.function.Predicate;
public class Demo17PredicateNegate {
private static void method(Predicate<String> predicate,String str) {
boolean veryLong = predicate.negate().test(str);
System.out.println("字符串很长吗:" + veryLong);
}
public static void main(String[] args) {
method(s -> s.length() < 5, "Helloworld");
}
}