JAVA8新特性(二)——通用函数接口
java.util.function包中是通用性函数接口，它满足一下几种基本的使用。
函数型T ->R，完成参数类型T向结果类型R的转换。核心函数接口Function、operater
判断型T->boolean，核心函数接口Predicate
消费型T->void，核心函数接口Consumer
供给型void->T，核心函数接口Supplier
同时也有单参数和双参数之分，前缀加”bi”是双参数，前缀不加或加”Unary”的是单参数。
使用function保重的通用函数接口，在业务中基本可以不用再创建函数接口了。Function中的函数接口如下
类别 | 小类别 | 介绍 | 接口 |
|---|---|---|---|
function | function | 有参数，有返回值，参数和返回值类型自定，可不同 | Function BiFunction DoubleFunction DoubleToIntFunction DoubleToLongFunction IntFunction IntToDoubleFunction IntToLongFunction LongFunction LongToDoubleFunction LongToIntFunction ToDoubleBiFunction ToDoubleFunction ToIntBiFunction ToIntFunction ToLongBiFunction ToLongFunction |
operator | 继承function，为参数、返回值类型都相同的function | BinaryOperator DoubleBinaryOperator DoubleUnaryOperator IntBinaryOperator IntUnaryOperator LongBinaryOperator LongUnaryOperator UnaryOperator | |
Perdicate | 返回boolean值，判断 | Predicate BiPredicate DoublePredicate IntPredicate LongPredicate | |
Supplier | 生产者，不带任何参数 | Supplier BooleanSupplier DoubleSupplier IntSupplier LongSupplier | |
Consumer | 消费者，没有任何返回值 | Consumer BiConsumer DoubleConsumer IntConsumer LongConsumer ObjDoubleConsumer ObjIntConsumer ObjLongConsumer |
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;
}
}