Interfaz funcional JDK1.8 para programación funcional
1. Información general
- Concepto:
una interfaz con un solo método abstracto - Cómo detectar si una interfaz es una interfaz funcional La interfaz
@FunctionalInterface
se coloca encima de la definición de la interfaz: si la interfaz es una interfaz funcional, la compilación pasa; si no, la compilación falla - Resumen:
Adecuado para lambda, una interfaz que se centra en hacer una cosa.
2. Interfaces de uso común↓↓↓
Después de la aparición de interfaces funcionales y expresiones Lambda, Java nos proporciona oficialmente algunas interfaces funcionales simples para completar algunas operaciones (que admiten operaciones de Stream). Usaremos estas interfaces en las operaciones de Stream, así que aprenda a usarlas. La interfaz es un requisito previo Para nuestro estudio posterior de Stream, también lo mencionaremos más adelante en el estudio de Stream.
3.Interfaz del proveedor
- describir
Proveedor: Proveedor
Lo llamo interfaz de proveedor y su método funcional es T get() .
La instancia se construye y se devuelve en la implementación de la interfaz.
- Código: T get()
public class Supplier_Practice {
public static void main(String[] args) {
String str = getString(() -> {
return "supplier interface";
});
System.out.println(str);
}
private static String getString(Supplier<String> stringSupplier) {
return stringSupplier.get();
}
}
4.Interfaz del consumidor
- describir
Consumidor: Consumidor,
lo llamo interfaz de usuario y su método funcional es void aceptar(objeto) .
Pase un parámetro, opere sobre él y no devuelva ningún valor.
- Código: aceptación nula (objeto)
public class Consumer_Practice {
public static void main(String[] args) {
String str = "chenfeilin";
consumerString((String s) -> {
System.out.println(s.toUpperCase());
}, str);
}
private static void consumerString(Consumer<String> stringConsumer, String str) {
stringConsumer.accept(str);
}
}
- Código: andThen(Consumer <? super T> after)
devuelve un Consumer compuesto, realiza esta operación en secuencia y luego realiza la operación posterior.
// 一个简单的实体类
public class Student {
private String name;
private int age;
private String address;
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
public class Consumer_Practice {
public static void main(String[] args) {
Student student = new Student();
consumerTwo((Student s1) -> {
s1.setName("chenfeilin");
}, (Student s2) -> {
s2.setAddress("雷克雅未克");
s2.setAge(777);
}, student);
System.out.println(student);
}
private static void consumerTwo(Consumer<Student> stringConsumer1,
Consumer<Student> stringConsumer2, Student student) {
// 依次消费
stringConsumer1.andThen(stringConsumer2).accept(student);
}
}
Salida de consola:
Estudiante{nombre='chenfeilin', edad=777, dirección='Reykjavik'}
- Nota :
Para el tipo String, el resultado de este consumidor no se reflejará en el valor de la referencia original, veamos el código de ejemplo.
public class Consumer_Practice {
public static void main(String[] args) {
String str = "chenfeilin";
consumerString((String s) -> {
s = s.toUpperCase();
System.out.println(s);
}, str);
System.out.println(str);
}
private static void consumerString(Consumer<String> stringConsumer, String str) {
stringConsumer.accept(str);
}
}
Salida de consola:
CHENFEILIN
chenfeilin
El valor del objeto String str no ha cambiado.
5.Interfaz de predicado
- describir
Predicado: Afirmación.
Lo llamo interfaz de juez y su método funcional es **prueba booleana (Objeto)**.
Pase un valor de parámetro y devuelva un resultado de juicio.
- Código: prueba booleana (Objeto)
public class Predicate_Practice {
public static void main(String[] args) {
String str = "chenfeilin";
checkString((String s) -> {
return s.length() > 3;
}, str);
}
private static void checkString(Predicate<String> stringPredicate, String str) {
boolean test = stringPredicate.test(str);
if (test) {
System.out.println("OK");
} else {
System.out.println("NG");
}
}
}
输出结果为：OK
-
Suplemento : como afirmación, sus condiciones de juicio deben estar en forma combinada, como && || etc.
-
Código :
public class Predicate_Practice {
public static void main(String[] args) {
String str = "chenfeilin";
moreCheck((String s1) -> {
return s1.length() > 5;
}, (String s2) -> {
return s2.startsWith("ccc");
}, str);
}
private static void moreCheck(Predicate<String> stringPredicate1,
Predicate<String> stringPredicate2, String str) {
boolean test1 = stringPredicate1.and(stringPredicate2).test(str);
boolean test2 = stringPredicate1.or(stringPredicate2).test(str);
boolean test3 = stringPredicate1.negate().test(str);
System.out.println(test1);
System.out.println(test2);
System.out.println(test3);
}
}
输出结果：
false
true
false
6.Interfaz de funciones
- describir
Función: Función.
La llamo interfaz del procesador y su método de función es ** aplicar (Objeto) **.
Pase un parámetro (tipo T) y devuelva un valor (tipo R).
- Código: aplicar (Objeto)
public class Function_Practice {
public static void main(String[] args) {
int count = 33;
function((Integer a) -> {
return String.valueOf(a + 100);
}, count);
}
private static void function(Function<Integer, String> integerStringFunction, int a) {
String result = integerStringFunction.apply(a);
System.out.println(result);
}
}
输出结果为：133
- Suplemento de código: andThen(Función <? super R,? extiende V> después)
Por ejemplo, el tipo de entrada de la Función1 es A, el tipo de salida es B y el tipo de parámetro de entrada de otra Función2 es exactamente B, entonces puede Forme un enlace, utilice el valor de retorno de la Función1 como valor de entrada de la Función2 y realice múltiples "procesamientos".
public class Function_Practice {
public static void main(String[] args) {
int count = 33;
moreFunction((Integer a) -> {
return String.valueOf(a + 100);
}, (String str) -> {
return str.length() > 2;
}, count);
}
private static void moreFunction(Function<Integer, String> function1,
Function<String, Boolean> function2, int a) {
Boolean aBoolean = function1.andThen(function2).apply(a);
System.out.println(aBoolean);
}
}