Introducción a las interfaces funcionales
Solo puede haber un método abstracto en una interfaz funcional, también puede haber métodos predeterminados y métodos estáticos, y se debe anotar @FunctionalInterface .
En Java, las expresiones lambda requieren funciones para llevar interfaces, de lo contrario no se pueden implementar.
A continuación, se muestra un ejemplo de cómo personalizar una interfaz funcional:
Definir la interfaz funcional TestFunInterface
@FunctionalInterface
public interface TestFunInterface{
public void test(); //可以有唯一一个抽象方法
default String getName() { return "Allen"; } //可以有默认方法
static String getGender() { return "Male"; } //可以有静态方法
}
Utilice la interfaz funcional TestFunInterface
class TestFunInterfaceImpl implements TestFunInterface {
@Override
public void test() {
System.out.println( "test:" + getName());
}
}
public class FuncInterfaceTest {
public static void test(TestFunInterface tester){
tester.test();
}
public static void main(String[] args) {
// 1. 传入实例
TestFunInterfaceImpl tester = new TestFunInterfaceImpl();
test(tester);
// 2. 传入内部类
test(new TestFunInterface(){
@Override
public void test() {
System.out.println( "test:" + getName());
}
});
//3. Lamadba表达式代替内部类
test(()->System.out.println( "test:"));
}
}
El contenido correspondiente a @FunctionalInterface está en el paquete java.lang.util.function
Interfaces funcionales comunes en el paquete de funciones
Interfaz funcional para consumo de mensajes-Consumidor
El único método abstracto es:
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
Ejemplos de uso del consumidor:
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
consumer(something->{
System.out.println(something + "welcome, ");
},"hello message ");
doubleConsumer(
something-> System.out.println(something + "hello, "),
something-> System.out.println(something + "welcome, "),
"hello message ");
}
public static void consumer(Consumer<String> something, String message){
something.accept(message);
}
public static void doubleConsumer(Consumer<String> something1, Consumer<String> something2, String message){
something1.andThen(something2).accept(message);
}
}
Resultados de:
hello message welcome,
hello message hello,
hello message welcome,
Process finished with exit code 0
La interfaz funcional proporcionada por el proveedor de mensajes
Devuelve el tipo que se pasa
El único método abstracto es:
/**
* Gets a result.
*
* @return a result
*/
T get();
Caso de uso:
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
int [] array = {1,3,11,6,2,10};
int a = getMax(()->{
int m=0;
for (int i =0;i<array.length;i++) {
if (i==0) m = array[0];
if (array[i] > m) m= array[i];
}
return m;
});
System.out.println("the max value of array is: "+ a);
System.out.println(getNewString(()->"hello"));
}
public static Integer getMax(Supplier <Integer> array){
return array.get();
}
public static String getNewString(Supplier <String> string){
return string.get() + " world!";
}
}
Resultados de:
the max value of array is: 11
hello world!
Process finished with exit code 0
La función para juzgar la condición es la interfaz-Predicater
El único método abstracto es:
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);
Caso de uso:
import java.util.function.Predicate;
public class PredicateTest {
public static void main(String[] args) {
String hasA = "a";
String hasB = "b";
boolean t1 = predicate("hello java",something-> something.contains(hasA));
boolean t2 = negPredicate("hello java",something-> something.contains(hasA));
boolean t3 =andPredicate("hello java",something-> something.contains(hasA),something-> something.contains(hasB));
boolean t4 =orPredicate("hello java",something-> something.contains(hasA),something-> something.contains(hasB));
System.out.println("t1 : " + t1);
System.out.println("t2 : " + t2);
System.out.println("t3 : " + t3);
System.out.println("t4 : " + t4);
}
public static boolean predicate(String message, Predicate <String> something){
return something.test(message);
}
public static boolean negPredicate(String message, Predicate <String> something){
return something.negate().test(message);
}
public static boolean andPredicate(String message, Predicate <String> something1, Predicate <String> something2){
return something1.and(something2).test(message);
}
public static boolean orPredicate(String message, Predicate <String> something1, Predicate <String> something2){
return something1.or(something2).test(message);
}
}
Resultados de:
t1 : true
t2 : false
t3 : false
t4 : true
Process finished with exit code 0
Función de conversión de tipo interfaz-función
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
Ejemplo de función:
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
int i = function("1000",something->Integer.parseInt(something));
System.out.println(i);
i = andFunction("1000",something->Integer.parseInt(something),something->something/100);
System.out.println(i);
}
public static Integer function(String message, Function<String,Integer> something){
return something.apply(message);
}
public static Integer andFunction(String message, Function<String,Integer> something1, Function<Integer,Integer> something2){
return something1.andThen(something2).apply(message);
}
}
Resultados de:
1000
10
Process finished with exit code 0