Java-8-Function
interface Function<T, R>
源码:
@FunctionalInterface
public interface Function<T, R> {
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，在Function中，T代表输入参数，R代表返回的结果,Function 就是一个函数，其作用类似于数学中函数的定义 ，（x,y）跟<T,R>的作用几乎一致
就像:
y = f(x)
Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式
小例子:
public static void main(String[] args) {
Function<Integer,Integer> function1 = integer ->
integer + integer;
System.out.println(function1.apply(100));
}
在函数式编程之前我们定义一组操作首先想到的是定义一个方法，然后指定传入参数，返回我们需要的结果。函数式编程的思想是先不去考虑具体的行为，而是先去考虑参数，具体的方法我们可以后续再设置
简单例子
public class M1 {
public static void main(String[] args) {
Function<Integer,Integer> function1 = integer ->
integer + integer;
System.out.println(function1.apply(100));
System.out.println("-----------------");
Function<Integer,String> function2 = integer ->
{
return integer + "号";
};
System.out.println(calculate(function2,100));
System.out.println("-----------------");
Function<Integer,String> function3 = integer ->
{
if (integer >= 100) {
return " >= 100";
} else {
return " < 100 ";
}
};
System.out.println(calculate(function3,1000));
}
//通过传入不同的Function，实现了在同一个方法中实现不同的操作。在实际开发中这样可以大大减少很多重复的代码
public static String calculate(Function<Integer,String> function,
Integer integer) {
return function.apply(integer);
}
}
compose和andThen
compose接收一个Function参数，返回时先用传入的逻辑执行apply，然后使用当前Function的apply
andThen跟compose正相反，先执行当前的逻辑，再执行传入的逻辑
例子:
public class M2 {
public static void main(String[] args) {
Function<Integer,Integer> function1 = integer ->
integer + 100;
Function<Integer,Integer> function2 = integer ->
integer * 100;
// 先执行传入的 function2 也就是 * 100
// 在执行 function1 + 100
System.out.println(function1.compose(function2).apply(1));
System.out.println("-------------------------------");
Function<String,String> function3 = s ->
s.toUpperCase();
Function<String,String> function4 = s ->
s + "---" +s.length();
System.out.println(function3.compose(function4).apply("abc"));
System.out.println("-------------------------------");
Function<Integer,Integer> function5 = integer ->
integer * 200;
Function<Integer,Integer> function6 = integer ->
integer - 200;
// 先执行 function5 再执行 function6
System.out.println(function5.andThen(function6).apply(100));
}
}
identity()
Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式
例子:
public class M3 {
public static void main(String[] args) {
Function<String,String> function = Function.identity();
String s = function.apply("lol");
System.out.println(s);
System.out.println("--------------");
Stream<String> stream = Stream.of("I", "love", "you", "too");
Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length));
System.out.println(map);
}
}
把一个对象转换成另一个对象
public class Shanghai_People {
private String name;
private int age;
public Shanghai_People(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Shanghai_People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class M4 {
public static void main(String[] args) {
Function<Person,Shanghai_People> function = person ->
{
if (person.getOrigin().equals("Shanghai")){
return new Shanghai_People(person.getName(),person.getAge());
} else {
return null;
}
};
List<Person> personList = Create_Data.supply_Persons();
for (Person person : personList){
if (function.apply(person) != null) {
System.out.println(person);
}
}
}
}
针对特定类型
DoubleFunction<R> IntFunction<R> LongFunction<R>
public class M1 {
public static void main(String[] args) {
DoubleFunction<String> doubleFunction = d ->
String.valueOf(d);
System.out.println(doubleFunction.apply(12.36));
System.out.println("-------------------");
IntFunction<String> intFunction = i ->
i + "号";
for (int i = 0; i < 10; i++) {
System.out.println(intFunction.apply(i));
}
System.out.println("-------------------");
LongFunction<String> longFunction = l ->
String.valueOf(l);
System.out.println(longFunction.apply(11L));
}
}
DoubleToIntFunction DoubleToLongFunction
public class M2 {
public static void main(String[] args) {
DoubleToLongFunction doubleToLongFunction = (d)->
(long) d;
System.out.println(doubleToLongFunction.applyAsLong(12.36));
System.out.println("------------");
DoubleToIntFunction doubleToIntFunction = d ->
(int) (d+100);
System.out.println(doubleToIntFunction.applyAsInt(125.369));
}
}
IntToDoubleFunction IntToLongFunction
参照上面
LongToDoubleFunction LongToIntFunction
参照上面
多参数
BiFunction<T, U, R>
源码:
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply(T t, U u);
default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t, U u) -> after.apply(apply(t, u));
}
}
BiFunction的apply方法，接收两个参数，返回一个值
简单例子
public class M3 {
public static void main(String[] args) {
BiFunction<Integer,Integer,String> f1 = (x,y) ->
String.valueOf(x+y);
System.out.println(f1.apply(100,250));
System.out.println("-----------------------");
BiFunction<String,String,String> f2 = (s1,s2) ->
s1.toUpperCase() + s2.toLowerCase();
System.out.println(f2.apply("ABCsjhdhdh","POOPjsdhdhd"));
System.out.println("-----------------------");
System.out.println(compute3(2, 3, (v1, v2) -> v1 + v2));
System.out.println("-----------------------");
System.out.println(compute3(2, 3, (v1, v2) -> v1 - v2));
System.out.println("-----------------------");
System.out.println(compute3(2, 3, (v1, v2) -> v1 * v2));
System.out.println("-----------------------");
//首先执行(v1, v2) -> v1 + v2，然后执行 v1 -> v1 * v1
System.out.println(compute4(2, 3, (v1, v2) -> v1 + v2, v1 -> v1 * v1));
}
public static int compute3(int a, int b, BiFunction<Integer, Integer, Integer> biFunction) {
return biFunction.apply(a, b);
}
public static int compute4(int a, int b, BiFunction<Integer, Integer, Integer> biFunction, Function<Integer, Integer> function) {
return biFunction.andThen(function).apply(a, b);
}
}
ToDoubleBiFunction<T,U> ToIntBiFunction<T,U> ToLongBiFunction<T,U>
public class M4 {
public static void main(String[] args) {
ToDoubleBiFunction<Integer,Integer> f1 = (i1,i2) ->
(i1+i2) * 100;
System.out.println(f1.applyAsDouble(1000,250));
System.out.println("--------------------");
ToIntBiFunction<String,String> f2 = (s1,s2) ->
s1.length() + s2.length() ;
System.out.println(f2.applyAsInt("abv","123456"));
System.out.println("--------------------");
ToLongBiFunction<Integer,Integer> f3 = (i1,i2) ->
i1 + i2;
System.out.println(f3.applyAsLong(123,115));
}
}
网友评论