1 parametrizarse conductual
conducta un comportamiento se puede parametrizar (un código) encapsulado y se utiliza en la creación y transmisión por el método paramétrico comportamiento comportamiento.
comportamiento paramétrico, es un método de recibir una pluralidad de diferentes comportamientos como un parámetro, y los utilizan internamente, la capacidad de comportamiento completo diferente.
el comportamiento parametrizado puede hacer que el código mejor se adapten a las nuevas necesidades, para reducir la carga de trabajo futuro.
El comportamiento puede ser parametrizado tipos son: clase, clase anónima, lambda
Publicado primera pieza de prueba de código:
package cn.com.trying.test.util;
import com.google.common.collect.Lists;
import java.io.File;
import java.io.FileFilter;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class LambdaTest {
public static void main(String args[]) {
//查找隐藏文件的两种写法
File[] hiddenFiles = new File(".").listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.isHidden();
}
});
File[] hFiles = new File(".").listFiles(File::isHidden);
Arrays.sort(hFiles,(File a, File b) ->{return a.compareTo(b);});
//---------------------------------------------------------------------------------
List<Apple> list = Lists.newArrayList();
Apple apple = new Apple();
apple.setColor("green");
apple.setWeight(100);
list.add(apple);
Apple apple1 = new Apple();
apple1.setColor("green");
apple1.setWeight(200);
list.add(apple1);
List<Apple> greenList = filterApples(list,LambdaTest::isGreenApple);
List<Apple> heavyList = filterApples(list,LambdaTest::isHeavyApple);
List<Apple> greenList1 = filterApples(list,(Apple a) -> "green".equals(a.getColor()));
List<Apple> heavyList1 = filterApples(list,(Apple a) -> a.getWeight() > 150 && "green".equals(a.getColor()));
List<Apple> heavyList3 = (List<Apple>)filter(list,(Apple a) -> a.getWeight() > 100);
List<Apple> list4 = list.stream().filter((Apple a)-> a.getWeight() > 100).collect(Collectors.toList());
long count = list.stream().filter((Apple a)-> a.getWeight() > 100).count();
long count1 = list.parallelStream().filter((Apple a)-> a.getWeight() > 100).count();
System.out.println(stringOp(LambdaTest::getStr,"ddddd"));
//方法引用 lambda表达式 流 默认方法 行为参数化
}
public static String stringOp(LambdaFunc sf, String s) {
return sf.stringFunc(s);
}
private static String getStr(String str){
int count = str.length();
System.out.println(count);
return count+"";
}
public static boolean isGreenApple(Apple apple){
return "green".equals(apple.getColor());
}
public static boolean isHeavyApple(Apple apple){
return apple.getWeight() > 150;
}
static List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> predicate){
List<Apple> list = Lists.newArrayList();
for( Apple apple : inventory){
if(predicate.test(apple)){
list.add(apple);
}
}
return list;
}
static <T> Collection<T> filter(Collection<T> c, Predicate<T> p){
Collection<T> collection = Lists.newArrayList();
for(T t : c){
if(p.test(t)){
collection.add(t);
}
}
return collection;
}
}
2 Lambda Expresiones
ejemplos de expresión 2.1 lambda:
(String s) -> s.length()
(Apple a) -> a.getWeight() > 150
(int x, int y) -> {
System.out.println("Result:");
System.out.println(x+y);
}
() -> 42
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())
escena uso 2.2 lambda
1. Las expresiones lambda utilizados en la función de interfaz.
2. La función de interfaz es solamente un método abstracto definido interfaz
3.Lambda que permite a la expresión directa de la forma abstracta ligada dentro de la aplicación funcional del método de interfaz, y toda la expresión como un ejemplo de una función de la interfaz.
2.3 función de descriptor de
método de interfaz abstracta firma es básicamente una función de la firma la expresión Lambda. Llamamos a esta función se llama método de descriptores abstractos
@FunctionalInterface este indicador se utiliza para indicar que la interfaz está diseñada para ser una interfaz de función. Si se define una interfaz con @FunctionalInterface, pero no es la interfaz de la función, el compilador devolverá un error sugerir la causa.
el modo de ejecución Surround: 2.4 Lambda Práctica
- Los parámetros de comportamiento de código de operación tacticidad diferenciada a cabo, actúa como los parámetros de transmisión,
- Interfaz para funciones definidas para el comportamiento de transferencia.
/**
* 函数式接口
*/
public interface LambdaFunc {
/**
* @Title:
* @Description: 字符串处理
* @param
* @return
* @author huxx
* @date 2020/3/16 上午10:34
* @update
*/
String handleString(String n);
}
- comportamiento de ejecución, el código de ejecución Lambda representado en vivo. Las expresiones lambda se ejecutan directamente inline métodos proporcionan una implementación para una interfaz funcional abstracto, y toda la expresión como un ejemplo de la función de interfaz.
public static String stringOp(LambdaFunc sf, String s) {
return sf.handleString(s);
}
- Transmitiendo Lambda, Lambda expresiones mediante el paso de una implementación diferente implementar la lógica de negocio diferentes.
System.out.println(stringOp((String str) -> str.length()+"---"+str.trim(),"ddddd"));
2.5 varias funciones predefinidas interfaz
. 1, el predicado
interfaz abstracta java.util.function.Predicate define un método denominado prueba, que acepta T objeto genérico y devuelve un valor booleano. Este es precisamente el mismo que creó anteriormente, ahora se puede utilizar directamente. Es necesario para representar una expresión booleana que involucra tipo T de tiempo, puede utilizar esta interfaz.
2, Consumer
java.util.function.Consumer define un objeto llamado aceptar métodos abstractos, que acepta devuelve t genéricos no (void). Si necesita acceder a un objeto de tipo T, y llevar a cabo determinadas acciones, puede utilizar esta interfaz. Por ejemplo, se puede usar para crear un método forEach, acepta una lista de números enteros, y donde cada elemento de realizar la operación.
. 3, función
java.util.function.Function <T, R> define la interfaz de aplicar un método conocido, que acepta un
objetivo T es genérico, y devuelve un objeto de R. genérico Si necesita definir un Lambda, mapeo objeto de entrada de información
a la salida, puede utilizar esta interfaz (tales como extracto de manzana en peso, o una cadena asignada a su longitud).
public static String handleStr(Function<String,String> f, String s){
return f.apply(s);
}
System.out.println(handleStr((String str) -> str.length()+"---"+str.trim(),"ddddd"));
2.6 tipos Laid primitivos de
las tres funciones de la interfaz anterior genéricos: predicado, de consumo y función <T, R>. Algunos interfaz de la función diseñada específicamente para ciertos tipos de
tipo java es o bien un tipo de referencia (tales como Byte, Integer, de objetos, List) , ya sea un tipo primitivo (como int, double, byte, char) . Pero los genéricos (tales como T Consumidor en) se pueden unir a un tipo de referencia. Esto es causado por la aplicación de la genérica interna.
Habrá un tipo primitivo en un tipo de mecanismo de referencias en Java correspondiente. Este mecanismo se llama el boxeo (boxeo) . operación inversa, es decir, los tipos de referencia correspondientes a primitiva, llamados desembalaje (Unboxing) . Java también tiene un mecanismo de autoboxing a los programadores de ayuda para realizar esta tarea: las operaciones de boxeo y unboxing se realizan automáticamente.
Boxeo y unboxing en el rendimiento tiene un precio. El esencial después de que el embalaje es envolver el tipo original, y se almacena en un montón. Por lo tanto, el valor después del embalaje requiere más memoria y requiere la búsqueda de memoria adicional para obtener el valor original envueltos.
Parámetros de entrada para la función específica del tipo de fórmula debe añadirse el nombre original de la interfaz correspondiente al prefijo de tipo, como DoublePredicate, IntConsumer, LongBinaryOperator, IntFunction similares. Función de interfaz, así como para la salida de tipo de parámetro de variantes: ToIntFunction, IntToDoubleFunction y así sucesivamente.
IntPredicate evenNumbers = (int i) -> i % 2 == 0;
evenNumbers.test(1000); //不需要装箱
Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;
oddNumbers.test(1000);// 需要装箱
2.7 función de interfaz común
| Interfaz funcional | descriptor de funciones | tipo primitivo especialización |
|---|---|---|
| Predicado | T-> booleano | IntPredicate, LongPredicate, DoublePredicate |
| Consumidor | T-> vacío | IntConsumer, LongConsumer, DoubleConsumer |
| Función <T, R> | T> R | IntFunction, IntToDoubleFunction, IntToLongFunction, LongFunction, LongToDoubleFunction, LongToIntFunction, DoubleFunction, ToIntFunction, ToDoubleFunction, ToLongFunction |
| Proveedor | () -> T | BooleanSupplier, IntSupplier, LongSupplier, DoubleSupplier |
| UnaryOperator | T> T | IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator |
| BinaryOperator | (T, T) -> T | IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator |
| BiPredicate <L, R> | (L, R) -> boolean | |
| BiConsumer <T, U> | (T, U)> vacío | IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator |
| BiFunction <T, U, R> | (T, U) -> R | ToIntBiFunction <T, U>, ToLongBiFunction <T, U>, ToDoubleBiFunction <T, U> |
2.8 Uso de variables locales
expresiones lambda también se les permite usar variable libre (no es un parámetro, pero la definición de la variable alcance exterior), como la clase anónima. Se les llama Lambda capturado
sobre lo que puede hacer por estas variables tienen algunas limitaciones. Lambda puede ser capturado sin limitación (referencia es decir, en su cuerpo) variables de instancia y variables estáticas. Sin embargo, las variables locales deben ser declaradas explícitamente como final o, de hecho, son finales. En otras palabras, expresiones lambda sólo pueden capturar las variables locales asignados a ellos una vez.
String testVar = "i am a variable";
System.out.println(handleStr((String str) -> str.length()+"---"+testVar,"ddddd"));
¿Por qué son variables locales con estas restricciones. En primer lugar, la realización de las variables de instancia y variables locales detrás hay una diferencia clave. Las variables de instancia se almacenan en la pila, las variables locales se almacenan en la pila. Si Lambda puede acceder directamente a las variables locales, y Lambda se utiliza en un hilo, se utiliza un hilo Lambda, el hilo puede ser asignado después de la variable esta variable se recuperará, para acceder a la variable. Por lo tanto, Java cuando se accede a la variable local libre está en el acceso hecho una copia de la misma, en lugar de acceder a la variable original. Si la variable local se asigna solo una vez no es diferente - así que no había esta restricción.
Método 3 Referencia
3.1 Método de referencia describe
métodos pueden ser vistos como una referencia rápida escrito Lambda solamente invocar un método particular. La idea básica es que si un representante de Lambda única "llamada directa este método", es mejor llamarlo por su nombre, en lugar de describir cómo invocar la misma.
//Lambda表达式写法
System.out.println(stringOp((String str) -> str.length()+"---"+str.trim(),"ddddd"));
//方法引用写法
System.out.println(handleStr(LambdaTest::test,"ddddd"));
public static String test(String str){
return str.length()+"---"+str.trim();
}
Puede verse como un método de referencia para el azúcar sintáctica Lambda implica sólo un único método, porque cuando se escribe menos código que expresa la misma cosa.
3.2 Método citó tres maneras
1. Un punto de referencia para el método estático (tal como el método de enteros parseInt de escribir Entero :: parseInt).
2. método de instancia Point de cualquier método de referencia (por ejemplo, un método de longitud de cadena, la escritura string :: longitud).
3. Punto a una instancia de un método de referencia objeto existente (suponiendo que tiene una expensiveTransaction variable local se utiliza para almacenar objetos de tipo de transacción que soporta un método de instancia getValue, entonces se puede escribir expensiveTransaction :: getValue).
