Spring函数式编程的理解（简单）_spring 函数式编程_Mhx

常用语法

简单的函数式编程 常见的为：（）—> {}
1.（）部分：参数列表 不需要写参数的类型
（1）参数可以为空
（2）需要传几个参数就写几个参数
2.箭头部分 箭头函数
3.方法体 （1）如果只有一行就可以省略花括号 如果没有就不能省略
（2）只有一行的话 可以省略return 不是一行就不能省略

常用接口

一、Supplier接口
java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对 象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象 数据 。

import java.util.function.Supplier;
public class Demo08Supplier {
 private static String getString(Supplier<String> function) { 
 return function.get(); }
public static void main(String[] args) { 
String msgA = "Hello"; 
String msgB = "World"; 
System.out.println(getString(() -> msgA + msgB)); }
} 

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

抽象方法：accept

import java.util.function.Consumer;
public class Demo09Consumer { 
private static void consumeString(Consumer<String> function) { 
function.accept("Hello"); }
public static void main(String[] args) { 
consumeString(s -> System.out.println(s)); 
  }
}

默认方法：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 的语义正是“一步接一步”操作。例如两个步骤组 合的情况

import java.util.function.Consumer;
public class Demo10ConsumerAndThen { 
private static void consumeString(Consumer<String> one, Consumer<String> two) { one.andThen(two).accept("Hello"); }
public static void main(String[] args) { 
consumeString( s -> System.out.println(s.toUpperCase()), 
s -> System.out.println(s.toLowerCase())); }
}

三、Predicate接口
抽象方法：test

import java.util.function.Predicate;
public class Demo15PredicateTest { 
private static void method(Predicate<String> predicate) { 
boolean veryLong = predicate.test("HelloWorld"); 
System.out.println("字符串很长吗：" + veryLong); }
public static void main(String[] args) { 
method(s -> s.length() > 5); }
}

默认方法：and

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

默认方法：or

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

默认方法：negate

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

四、 Function接口
java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件
抽象方法：apply
Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。
使用的场景例如：将 String 类型转换为 Integer 类型

import java.util.function.Function;
public class Demo11FunctionApply {
 private static void method(Function<String, Integer> function) { 
 int num = function.apply("10"); System.out.println(num + 20);
  }
  public static void main(String[] args) { 
  method(s -> Integer.parseInt(s)); }
}

默认方法：andThen

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { 
Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); 
}