Nueva característica de la interfaz funcional java8
Interfaz de función: una interfaz y un método abstracto constituyen una interfaz funcional, que se puede anotar @FunctionalInterface
Especifique la restricción de que la interfaz es una interfaz funcional; una interfaz funcional solo puede tener un método abstracto propio
Fácil de usar:
Interfaz de función personalizada: se definen tres interfaces de función
package com.xiaodu.java8.methodcite;
import java.util.function.Supplier;
/**
* 定义函数接口
* @author 84287
*
*/
public interface FunctionInterface {
/*
* 获取类的实例
*/
@FunctionalInterface
interface function01<T>{
T getObject();
}
//函数接口是主要是给Lambda使用 java8中已经有好多函数接口，很多不用自己定义
//本人自己定义的function01<t> 其实和 java.util.function中的Supplier<T>一样的
}
Utilice la interfaz de función:
public static void main(String[] args) {
function01<String> f01 = () -> "xiaoming";
String string = f01.getObject();
System.out.println(string.length()); // 8
}Lista completa de interfaces de funciones incluidas en java 8:
Interfaces funcionales que existían antes de JDK 1.8:
· Java.lang.Runnable
· Java.util.concurrent.Callable
· Java.security.PrivilegedAction
· Java.util.Comparator
Java.io.FileFilter
Java.nio.file.PathMatcher
· Java.lang.reflect.InvocationHandler
· Java.beans.PropertyChangeListener
· Java.awt.event.ActionListener
· Javax.swing.event.ChangeListener
---------------------
Interfaz de función en java.util.function. *
| Número de serie | Nombre de interfaz && método abstracto | Observaciones |
|---|---|---|
| 1 | BiConsumidor <T, U> ； anular aceptar (T t, U u); |
Representa una operación que acepta dos parámetros de entrada y no devuelve ningún resultado. |
| 2 | BiFunción <T, U, R> ； R se aplica (T t, U u); |
Representa un método que acepta dos parámetros de entrada y devuelve un resultado. |
| 3 | Operador binario <T> ； 继承 BiFunción <T, U, R> ； |
Representa una operación que actúa sobre dos operadores del mismo tipo y devuelve el resultado del mismo tipo de operador. |
| 4 | BiPredicate <T, U> ； prueba booleana (T t, U u); |
Representa un método de valor booleano de retorno de dos parámetros |
| 5 | BooleanSupplier | Representa el proveedor del resultado del valor booleano |
| 6 |
Consumidor <T> ； anular aceptar (T t); |
Representa una operación que acepta un parámetro de entrada y no devuelve |
| 7 | DoubleBinaryOperator ； double applyAsDouble (doble izquierda, doble derecha); |
Representa la operación de dos operadores de valor doble y devuelve un resultado de valor doble |
| 8 | DoubleConsumer ； aceptar vacío (valor doble); |
Representa una operación que acepta un parámetro de valor doble y no devuelve un resultado. |
| 9 | Función doble <R> ； Aplicar R (valor doble); |
Representa un método que acepta un parámetro de valor doble y devuelve el resultado. |
| 10 | DoublePredicate ； prueba booleana (valor doble); |
Representa un método de retorno booleano con un parámetro de valor doble |
| 11 | DoubleSupplier ； doble getAsDouble (); |
Representa un método que devuelve un valor doble sin parámetros |
| 12 | DoubleToIntFunction ； int applyAsInt (valor doble); |
Acepte una entrada de tipo doble y devuelva un resultado de tipo int |
| 13 | DoubleToLongFunction ； long applyAsLong (valor doble); |
Acepte una entrada de tipo doble y devuelva un resultado de tipo largo |
| 14 | DoubleUnaryOperator ； double applyAsDouble (operando doble); |
Acepta un parámetro del mismo tipo double y el tipo de valor de retorno también es double. |
| 15 | Function<T,R>； R apply(T t); |
接受一个输入参数，返回一个结果 |
| 16 | IntBinaryOperator； int applyAsInt(int left, int right); |
接受两个参数同为类型int,返回值类型也为int |
| 17 | IntConsumer； void accept(int value); |
接受一个int类型的输入参数，无返回值 |
| 18 | IntFunction<R>； R apply(int value); |
接受一个int类型输入参数，返回一个结果 |
| 19 | IntPredicate； boolean test(int value); |
接受一个int输入参数，返回一个布尔值的结果 |
| 20 | IntSupplier； int getAsInt(); |
无参数，返回一个int类型结果 |
| 21 | IntToDoubleFunction； double applyAsDouble(int value); |
接受一个int类型输入，返回一个double类型结果 |
| 22 | IntToLongFunction； long applyAsLong(int value); |
接受一个int类型输入，返回一个long类型结果 |
| 23 | IntUnaryOperator； int applyAsInt(int operand); |
接受一个参数同为类型int,返回值类型也为int |
| 24 | LongBinaryOperator； long applyAsLong(long left, long right); |
接受两个参数同为类型long,返回值类型也为long |
| 25 | LongConsumer； void accept(long value); |
接受一个long类型的输入参数，无返回值 |
| 26 | LongFunction<R>； void accept(long value); |
接受一个long类型输入参数，返回一个结果 |
| 27 | LongPredicate； boolean test(long value); |
接受一个long输入参数，返回一个布尔值类型结果 |
| 28 | LongSupplier； long getAsLong(); |
无参数，返回一个结果long类型的值 |
| 29 | LongToDoubleFunction； double applyAsDouble(long value); |
接受一个long类型输入，返回一个double类型结果 |
| 30 | LongToIntFunction； int applyAsInt(long value); |
接受一个long类型输入，返回一个int类型结果 |
| 31 | LongUnaryOperator； long applyAsLong(long operand); |
接受一个参数同为类型long,返回值类型也为long |
| 32 | ObjDoubleConsumer<T>； void accept(T t, double value); |
接受一个object类型和一个double类型的输入参数，无返回值 |
| 33 | ObjIntConsumer<T>； void accept(T t, int value); |
接受一个object类型和一个int类型的输入参数，无返回值 |
| 34 | ObjLongConsumer<T>； void accept(T t, long value); |
接受一个object类型和一个long类型的输入参数，无返回值 |
| 35 | Predicate<T>； boolean test(T t); |
接受一个输入参数，返回一个布尔值结果 |
| 36 | Supplier<T>； T get(); |
无参数，返回一个结果 |
| 37 | ToDoubleBiFunction<T,U>； double applyAsDouble(T t, U u); |
接受两个输入参数，返回一个double类型结果 |
| 38 | ToDoubleFunction<T>； double applyAsDouble(T value); |
接受一个输入参数，返回一个double类型结果 |
| 39 | ToIntBiFunction <T, U> ； int applyAsInt (T t, U u); |
Acepta dos parámetros de entrada y devuelve un resultado de tipo int |
| 40 | ToIntFunction <T> ； int applyAsInt (valor T); |
Acepta un parámetro de entrada y devuelve un resultado de tipo int |
| 41 | ToLongBiFunction <T, U> ； long applyAsLong (T t, U u); |
Acepta dos parámetros de entrada y devuelve un resultado de tipo largo. |
| 42 | ToLongFunction <T> ； long applyAsLong (valor T); |
Acepta un parámetro de entrada y devuelve un resultado de tipo largo |
| 43 | UnaryOperator <T> ； 继承 ： extiende la función <T, T> ； R se aplica (T t); |
Acepta un parámetro de tipo T, y el tipo de valor de retorno también es T |
| 44 | Lo anterior es la interfaz funcional después de java8 |
|
Simplemente use la interfaz de funciones que viene con java8
El código refleja:
Utilice la interfaz de funciones que viene con java8
public static void main(String[] args) {
String string = MethodCiteFunction.supplier(() -> "接受一个空参，返回一个String对象");
System.out.println(string);
// 空参，返回一个person对象
Person person = MethodCiteFunction.supplier(() -> new Person());
// 方法引用，空参返回一个person对象
Person person2 = MethodCiteFunction.supplier(Person::new);
}
/**
* Supplier<T> 无参，返回一个泛型类型的对象
* @param supplier
* @return
*/
public static <T>T supplier(Supplier<T> supplier) {
return supplier.get();
}