JAVA8新特性(二)——通用函数接口

待我称王封你为后i 2022-06-08 03:44 162阅读 0赞

java.util.function包中是通用性函数接口，它满足一下几种基本的使用。

函数型T ->R，完成参数类型T向结果类型R的转换。核心函数接口Function、operater

判断型T->boolean，核心函数接口Predicate

消费型T->void，核心函数接口Consumer

供给型void->T，核心函数接口Supplier

同时也有单参数和双参数之分，前缀加”bi”是双参数，前缀不加或加”Unary”的是单参数。

使用function保重的通用函数接口，在业务中基本可以不用再创建函数接口了。Function中的函数接口如下

<table> 
 <tbody> 
 <tr> 
 <td> 类别 </td> 
 <td> 小类别 </td> 
 <td> 介绍 </td> 
 <td> 接口 </td> 
 </tr> 
 <tr> 
 <td> function </td> 
 <td> function </td> 
 <td> 有参数，有返回值，参数和返回值类型自定，可不同 </td> 
 <td> Function BiFunction DoubleFunction DoubleToIntFunction DoubleToLongFunction IntFunction IntToDoubleFunction IntToLongFunction LongFunction LongToDoubleFunction LongToIntFunction ToDoubleBiFunction ToDoubleFunction ToIntBiFunction ToIntFunction ToLongBiFunction ToLongFunction </td> 
 </tr> 
 <tr> 
 <td> operator </td> 
 <td> 继承function，为参数、返回值类型都相同的function </td> 
 <td> BinaryOperator DoubleBinaryOperator DoubleUnaryOperator IntBinaryOperator IntUnaryOperator LongBinaryOperator LongUnaryOperator UnaryOperator </td> 
 </tr> 
 <tr> 
 <td> Perdicate </td> 
 <td> &nbsp; </td> 
 <td> 返回boolean值，判断 </td> 
 <td> Predicate BiPredicate DoublePredicate IntPredicate LongPredicate </td> 
 </tr> 
 <tr> 
 <td> Supplier </td> 
 <td> &nbsp; </td> 
 <td> 生产者，不带任何参数 </td> 
 <td> Supplier BooleanSupplier DoubleSupplier IntSupplier LongSupplier </td> 
 </tr> 
 <tr> 
 <td> Consumer </td> 
 <td> &nbsp; </td> 
 <td> 消费者，没有任何返回值 </td> 
 <td> Consumer BiConsumer DoubleConsumer IntConsumer LongConsumer ObjDoubleConsumer ObjIntConsumer ObjLongConsumer </td> 
 </tr> 
 </tbody> 
</table>

Function的通用函数接口满足的大部分的需求，直接实现通用函数接口就好。下面是函数接口的示例。这些示例包含了Predicate、BiConsumer、BiFunction、BinaryOperator、DoubleFunction、DoubleUnaryOperator、DoubleConsumer、DoubleSupplier。

public class FunctionPackageTest {
 
 @Test
 public void evenNumTest() {
 List<Integer> numlist = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
 printEvenNum(numlist, (Integer a) -> {
 return a % 2 == 0;
 });
 }
 
 /**
 * Predicate实现求偶数
 */
 public void printEvenNum(List<Integer> numlist, Predicate<Integer> evenNumPredicate) {
 for (Integer num : numlist) {
 if (evenNumPredicate.test(num)) {
 System.out.println(num);
 }
 }
 }
 
 @Test
 public void stringAddIntegerTest() {
 Integer in = 3;
 String us = "5";
 printStringAddInteger(in, us, (String u, Integer i) -> {
 System.out.println("i+u=" + (i + Integer.valueOf(u)));
 });
 }
 
 /**
 * Consumer实现加法运算
 */
 public void printStringAddInteger(int i, String u, BiConsumer<String, Integer> biConsumer) {
 biConsumer.accept(u, i);
 }
 
 @Test
 public void returnStringAddIntTest() {
 Integer result = returnStringAddInt(3, "5", (String st, Integer in) -> {
 return in + Integer.valueOf(st);
 });
 System.out.println("result:" + result);
 }
 
 /**
 * Function实现带返回值的加法运算
 */
 public Integer returnStringAddInt(int i, String u, BiFunction<String, Integer, Integer> biConsumer) {
 return biConsumer.apply(u, i);
 }
 
 @Test
 public void returnStringAddTest() {
 System.out.println("result:" + returnStringAdd("1", "2", (a, b) -> {
 return String.valueOf(Integer.valueOf(a) + Integer.valueOf(b));
 }));
 }
 
 /**
 * Operator实现两个参数、返回值类型相同的加法运算
 */
 public String returnStringAdd(String a, String b, BinaryOperator<String> binaryOperator) {
 return binaryOperator.apply(a, b);
 }
 
 @Test
 public void returnDateStringTest() {
 returnDateString(() -> {
 return new Random().nextInt(10);
 });
 }
 
 /**
 * supplier模拟抽奖系统
 */
 public void returnDateString(Supplier<Integer> supplier) {
 Integer caipiao = 5;
 Integer kaijiancaipiao = supplier.get();
 System.out.println("开奖数字：" + kaijiancaipiao);
 switch (Math.abs(caipiao - kaijiancaipiao)) {
 case 0:
 System.out.println("一等奖");
 break;
 case 1:
 System.out.println("二等奖");
 break;
 case 2:
 System.out.println("三等奖");
 break;
 default:
 System.out.println("没有中奖");
 }
 }
 
 @Test
 public void doubleFunctionTest() {
 String result = doubleFunction(3.0, (double a) -> {
 return a + "xxx";
 });
 }
 
 //DoubleFunction的案例
 public String doubleFunction(Double param, DoubleFunction<String> doubleFunction) {
 String result = doubleFunction.apply(param);
 return result;
 }
 
 @Test
 public void toDoubleBiFunctionTest() {
 Double result = toDoubleBiFunction("12", (byte) '1', (s, b) -> {
 return Double.valueOf(Integer.valueOf(s) - Integer.valueOf(b));
 });
 System.out.println("result:" + result);
 }
 
 //ToDoubleBiFunction的案例
 public Double toDoubleBiFunction(String ss, Byte bb, ToDoubleBiFunction<String, Byte> toDoubleBiFunction) {
 Double result = toDoubleBiFunction.applyAsDouble(ss, bb);
 return result;
 }
 
 @Test
 public void doubleUnaryOperatorTest() {
 Double result = doubleUnaryOperator(3.9, (a) -> {
 return a + 1;
 });
 System.out.println("result:" + result);
 }
 
 //DoubleUnaryOperator的案例
 public Double doubleUnaryOperator(double s, DoubleUnaryOperator doubleUnaryOperator) {
 Double result = doubleUnaryOperator.applyAsDouble(s);
 return result;
 }
 
 @Test
 public void doubleConsumerTest() {
 doubleConsumer(3.4, (d) -> {
 System.out.println(d + 1.0);
 });
 }
 
 //DoubleConsumer的案例
 public void doubleConsumer(Double d, DoubleConsumer doubleConsumer) {
 doubleConsumer.accept(d);
 }
 
 @Test
 public void doubleSupplierTest() {
 Double result = doubleSupplier(()->{
 return 2.4;
 });
 System.out.println("result:" + result);
 }
 
 //DoubleSupplier的案例
 public Double doubleSupplier(DoubleSupplier doubleSupplier) {
 Double result = doubleSupplier.getAsDouble();
 return result;
 }
 }