JDK中有许多函数式接口,也会有许多方法会使用函数式接口作为参数,同时在各种源码中也大量使用了这些方法,那么我们在实际工作中应该如何使用!我们就来盘一盘,这样也有助于写出优雅的代码,使我们在阅读源码时事半功倍。
1 JDK中常见的Lamada表达式
Java中可以使用Lamada表达式的接口都有@FunctionalInterface注解。
先来看看util.function包下面含有FunctionalInterface注解的接口。一屏显示不全,可见功能非常齐全。
鉴于常用的一些函数式接口有Function/Consumer/Supplier/Predicate以及Runnable等。本篇介绍这几类接口。
1.1 Runnable
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
Runnable 使用Lamada方式书写时,无参数,无返回值。最终执行的是run方法
使用Demo
new Thread(() - > {
System.out.println("JavaNorth Runnable");
}).start();
1.2 Function
Function 表示接受一个参数并产生结果的函数。
@FunctionalInterface
public interface Function< T, R > {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
default < V > Function< V, R > compose(Function< ? super V, ? extends T > before) {
Objects.requireNonNull(before);
return (V v) - > apply(before.apply(v));
}
default < V > Function< T, V > andThen(Function< ? super R, ? extends V > after) {
Objects.requireNonNull(after);
return (T t) - > after.apply(apply(t));
}
static < T > Function< T, T > identity() {
return t - > t;
}
}
Function接受一个参数T,并且有返回值 R, 其实现也主要是实现此方法 R apply(T t);
Function 的一个示例:
List< String > list = new ArrayList< String >();
List< String > collect = list.stream().map((x) - > {
return "Java North Function" + x;
}).collect(Collectors.toList());
上述示例中是一个stream的map方法。其中x为输入参数,『"Java North and" + x』为输出。
1.3 Consumer
Consumer表示接受一个参数,没有返回值的操作,主要方法为 void accept(T t);
@FunctionalInterface
public interface Consumer< T > {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
default Consumer< T > andThen(Consumer< ? super T > after) {
Objects.requireNonNull(after);
return (T t) - > { accept(t); after.accept(t); };
}
}
1.3.1 Consumer 在Java中的应用
常见的有List的forEach等。
list.forEach(x - > System.out.println( "Java North Consumer test " + x));
x为参数,输出语句直接执行。
下面的map的forEach参数为BiConsumer,其入参有两个。
Map< String,String > map = new HashMap< >();
map.forEach((K,V) - > {
System.out.println("Java North Big Consumer MAP key : " +K + " value: "+V );
});
1.3.2 自定义带有Consumer的方法
public class ConsumerBiConsumerDemo {
public static void main(String[] args) {
Consumer< String > conString = (x) - > System.out.println(x.toUpperCase());
conString.accept("i love java north ");
BiConsumer< String, String > biCon = (x,y) - > System.out.println (x + y);
biCon.accept("i love ","java");
List< Person > plist = Arrays.asList(new Person("Java"),new Person("North"));
acceptAllEmployee(plist,p - > System.out.println(p.name));
acceptAllEmployee(plist,person - > {person.name = "unknow";});
acceptAllEmployee(plist,person - > System.out.println(person.name));
}
public static void acceptAllEmployee(List< Person > plist, Consumer< Person > con){
plist.forEach(person - > {con.accept(person);});
}
}
class Person{
public String name;
public Person (String name){
this.name = name;
}
}
1.4 Supplier
Supplier没有参数,有一个返回值。
@FunctionalInterface
public interface Supplier< T > {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
Supplier 示例如下:
public class SupplierDemo {
public static void main(String[] args) {
SupplierDemo sdemo = new SupplierDemo();
Supplier< LocalDateTime > s = () - > LocalDateTime.now();
LocalDateTime localDateTime = s.get();
System.out.println(s.get());
Supplier< List > listSupplier = sdemo.listSupplier();
List list = listSupplier.get();
Person person = personFactory(Person::new);
System.out.println(person);
Person javaNorth = personFactory(() - > new Person("JavaNorth"));
System.out.println(javaNorth);
}
public Supplier< List > listSupplier(){
return ArrayList::new;
}
public static Person personFactory(Supplier< ? extends Person > s){
Person person = s.get();
if(person.getName() == null) person.setName("default");
person.setAge(18);
return person;
}
static class Person {
String name;
int age;
public Person() { }
public Person(String name) {
this.name = name;
}
。。。
}
}
1.5 Predicate
主要方法为test,其主要是传入一个参数,返回一个boolean类型的值。
@FunctionalInterface
public interface Predicate< T > {
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);
default Predicate< T > and(Predicate< ? super T > other) {
Objects.requireNonNull(other);
return (t) - > test(t) && other.test(t);
}
default Predicate< T > negate() {
return (t) - > !test(t);
}
default Predicate< T > or(Predicate< ? super T > other) {
Objects.requireNonNull(other);
return (t) - > test(t) || other.test(t);
}
......
}
Predicate简单示例:
public class PredicateDemo {
public static void main(String[] args) {
Predicate< Integer > predicate = (s) - > s > 5;
Predicate< Integer > predicate2 = (s) - > s > 8;
System.out.println(" 3 大于5 ? " + predicate.test(3));
System.out.println(" 6 大于5 ? " + predicate.test(6));
System.out.println("7 大于5 and 大于8 " + predicate.and(predicate2).test(7));
System.out.println("7 大于5 or 大于8 " + predicate.or(predicate2).test(7));
List< Integer > list = Arrays.asList(3,5,6,2,8,4,7,9);
List< Integer > collect = list.stream().filter(predicate).collect(Collectors.toList());
System.out.println(list);
System.out.println(collect);
}
}
上述代码运行结果
3 大于5 ? false
6 大于5 ? true
7 大于5 and 大于8 false
7 大于5 or 大于8 true
[3, 5, 6, 2, 8, 4, 7, 9]
[6, 8, 7, 9]
2 常用的Lamada参数特征
Lamada 的一些表达式将方法的一些执行逻辑放到了参数中,使得方法的返回值根据传入的参数的逻辑而变化。从而实现了在一定的方法不变的情况下,使代码执行传入参数相关的逻辑。
常用的一些Lamada使用如下:
Runnable 无入参,无返回值 。
() - > { System.out.println(strF.apply("javaNorth Runnable"));}
Function 有入参,有返回值
Function strF = (s) - > { return s + "javaNorth Function"; };
System.out.println(strF.apply("TEST "));
Consumer有入参,无返回值。
Consumer< String > srtC = (s) - > {System.out.println(s + "javaNorth TEST ");};
srtC.accept("Hello World");
Supplier 无入参,有返回值。
Supplier< String > srtP = () - > {return "I love avaNorth ";};
System.out.println(srtP.get());
Predicate 有入参,返回一个boolean类型的值
Predicate< Integer > predicate = (s) - > s > 5;
System.out.println(" 3 大于5 ? " + predicate.test(3));
3 自定义Lamada函数式接口
结合之前的常用Lamada函数的介绍,下面我们自定义一个简单的函数式接口。
@FunctionalInterface
public interface MyFunction< T > {
public void print(T t);
}
public class MyFunctionDemo {
public static void printString(String str , MyFunction< String > myF){
myF.print(str);
}
public static void main(String[] args) {
printString("I love " , (str) - > {System.out.println(str + "Java North");});
}
}
其实很简单,就是展示了一下自定义函数式接口的应用实例而已。
总结
函数式接口的使用可以简化我们的代码,很大程度上提高代码的可读性。在程序执行上可能性能稍微有所降低,但对开发带来的便捷与好处是大于其性能上的微弱损失的。除了介绍的几种常见的函数式编程以外,还有许多其他的函数式接口等着我们去利用。听完这些话之后,软软猿妹也对常用的函数式接口有所了解,接下来下定决心要好好学一学函数式接口了。
-
接口
+关注
关注
33文章
8488浏览量
150809 -
函数
+关注
关注
3文章
4304浏览量
62412 -
JDK
+关注
关注
0文章
81浏览量
16576
发布评论请先 登录
相关推荐
评论