逐步走向响应式编程-常见函数式接口- Function<T, R>
Posted 浦江之猿
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了逐步走向响应式编程-常见函数式接口- Function<T, R>相关的知识,希望对你有一定的参考价值。
前面介绍了函数式接口Predicate和Consumer,本文继续介绍另一函数式接口Function<T, R>,此接口同样也位于 java.util.function包中,它的作用可以看作是消费者和生产者的结合,即消费某种原材料然后生产出某种产品,继续先分析一下源码。
源码解析
package java.util.function;
import java.util.Objects;
/**
* Represents a function that accepts one argument and produces a result.
* 此接口中的方法接收一个参数并输出一个结果
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is @link #apply(Object).
*
* @param <T> the type of the input to the function
* @param <R> the type of the result of the function
*
* @since 1.8
*/
@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);
/**
* Returns a composed function that first applies the @code before
* function to its input, and then applies this function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
* 此方法将两个function进行组合,得到一个新的function,组合的过程中如果有一个function出现了异常,异常由调用者来处理。组合逻辑是,将其中一个function以参数的形式传入(before),在compose内部获取before的结果,并传给第二个function组成一个新的function并返回
* @param <V> the type of input to the @code before function, and to the
* composed function
* @param before the function to apply before this function is applied
* 这句话好难理解,简单来就说就是将一个function当作一个参数
* @return a composed function that first applies the @code before
* function and then applies this function
* 将before function的结果传给当前function,并返回。
* @throws NullPointerException if before is null
*
* @see #andThen(Function)
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before)
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
/**
* Returns a composed function that first applies this function to
* its input, and then applies the @code after function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*此函数和compose函数有点类似,但顺序不同。此函数是先执行调用者,再执行andThen的参数,即将调用者的结果传给参数中的function使用,并返回一个function.
* @param <V> the type of output of the @code after function, and of the
* composed function
* @param after the function to apply after this function is applied
* @return a composed function that first applies this function and then
* applies the @code after function
* @throws NullPointerException if after is null
*
* @see #compose(Function)
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after)
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
/**
* Returns a function that always returns its input argument.
*将apply的参数当着结果返回出来
* @param <T> the type of the input and output objects to the function
* @return a function that always returns its input argument
*/
static <T> Function<T, T> identity()
return t -> t;
案例分析
通过处理User案例来分析每个方法的使用。提供了两个类User 和 UserEntity:
User
public class User
private int age;
private String name;
/**
* @return the age
*/
public int getAge()
return age;
/**
* @param age
* @param name
*/
public User(int age, String name)
this.age = age;
this.name = name;
/**
* @param age the age to set
*/
public void setAge(int age)
this.age = age;
/**
* @return the name
*/
public String getName()
return name;
/**
* @param name the name to set
*/
public void setName(String name)
this.name = name;
UserEntity
public class UserEntity
private int age;
private String name;
private int type;
/**
* @param age
* @param name
* @param type
*/
public UserEntity(int age, String name, int type)
this.age = age;
this.name = name;
this.type = type;
/**
* @return the age
*/
public int getAge()
return age;
/**
* @param age the age to set
*/
public void setAge(int age)
this.age = age;
/**
* @return the name
*/
public String getName()
return name;
/**
* @param name the name to set
*/
public void setName(String name)
this.name = name;
/**
* @return the type
*/
public int getType()
return type;
/**
* @param type the type to set
*/
public void setType(int type)
this.type = type;
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString()
return "UserEntity age=" + age + ", name=" + name + ", type=" + type + "";
apply
将一组User转换成一组User Entity, 根据User的年龄来定义用户级别(普通用户,vip,svip),其中用户级别是User Entity的一个字段,所以输入参数是List,返回结果是List 。
构造数据
User user1 = new User(10, "张三");
User user2 = new User(15, "李四");
User user3 = new User(16, "王五");
User user4 = new User(20, "赵六");
User user5 = new User(25, "田七");
List<User> users = new ArrayList<>();
users.add(user1);
users.add(user2);
users.add(user3);
users.add(user4);
users.add(user5);
定义转换逻辑
/**
* Convert users to user entities
* age<=15:GENERAL
* 15<age<=20:VIP
* 20<age:SVIP
* @param Function<List<User>,List<UserEntity>>
*/
static Function<List<User>,List<UserEntity>> multiUsersToEntities(List<User> users)
Function<List<User>,List<UserEntity>> function = t->
List<UserEntity> userEntities = new ArrayList<>();
int age;
String name;
UserEntity userEntity;
for(User user:t)
age = user.getAge();
name = user.getName();
if( age<=15)
userEntity = new UserEntity(age, name, Type.GENERAL.getCode());
else if (age > 15 && age <=20)
userEntity = new UserEntity(age, name, Type.VIP.getCode());
else
userEntity = new UserEntity(age, name, Type.SVIP.getCode());
userEntities.add(userEntity);
return userEntities;
;
return function;
开始转换
Function<List<User>,List<UserEntity>> function = multiUsersToEntities(users);
List<UserEntity> uEntities = function.apply(users);
转换结果
uEntities.stream().forEach(u->System.out.println(u.toString()));
转换成功后的结果如下
UserEntity age=10, name=张三, type=3
UserEntity age=15, name=李四, type=3
UserEntity age=16, name=王五, type=1
UserEntity age=20, name=赵六, type=1
UserEntity age=25, name=田七, type=2
compose
根据注释中的理解感觉一脸蒙逼,这里简单来说就是将两个函数进行组合,先执行compose里面的函数再执行外面的函数,为了便于理解脱离上面的例子。
定义两个函数如下:
//对输入的值进行两倍处理
Function<Integer,Integer> function2 = t-> t*2;
//对输入的值进行平方处理
Function<Integer,Integer> function3 = t-> t*t;
System.out.println("compose result :"+function2.compose(function3).apply(3));
结果为:compose result :18
andThen
同compose类似,也是将两个函数组合起来使用,但是顺序不一样,这里先执行andThen外面的函数,再执行andThen里面的函数。继续以上面的两个函数为例
System.out.println("andThen result :"+function2.andThen(function3).apply(3));
结果为:andThen result :36
identity
identiy个人没用过,这里举个例子吧,以后深入了解之后继续更新。
Function<Integer,Integer> function4 = Function.identity();
System.out.println("identity result :"+function4.apply(3));
结果为:identity result :3
总结
内容很简单,在java8的Stream中,Function使用很广泛,后续的博文中会一一介绍。最后希望本文能帮助大家,祝大家在IT之路上少走弯路,一路绿灯不堵车,测试一性通过,bug秒解!
源码下载
以上是关于逐步走向响应式编程-常见函数式接口- Function<T, R>的主要内容,如果未能解决你的问题,请参考以下文章
逐步走向响应式编程-常见函数式接口- Function<T, R>
逐步走向响应式编程-常见函数式接口- Function<T, R>
逐步走向响应式编程-常见函数式接口- Consumer<T>