La razón para escribir esta sección se originó en el código siguiente:
Optional<KeywordRouter> optional = getAllKeywordRouter().stream().filter(predicate -> predicate.getOriginKeyword().equals(originKeyword)).findFirst();
List<RfaPublicBean> rfaPublicResponseBeans = rfaPublicBeanPagedList.getList().parallelStream().map(this::converter).collect(Collectors.toList());
Blanco mirar en el código cuando son mareos. . Al pensar sobre sí mismos con el fin de escribir este código. .
Análisis:
Este código utiliza el método corriente de clase de colección Lista () para obtener un objeto de flujo; a continuación, llamar filtro () y se filtró para dar el objeto deseado; seguido por Opcional objetos; proceso de filtrado usando la expresión lambda.
Relacionado con el punto: [nuevas características] JAVA8
- No implementar el método predeterminado de la interfaz abstracta
- interfaz Collection corriente () método y parallelStream () método
- Diversos métodos de la corriente de interfaz
- filtro () en la interfaz
- clase opcional ( ver específicamente texto )
- expresión lambda y el colon uso doble
El método predeterminado de la interfaz abstracta
Colección de la interfaz tiene una pluralidad de implementación por defecto del método , donde el método corriente () e implementos método parallelStream () hablan de esta interfaz por defecto con este método.
public interface Collection<E> extends Iterable<E> {
//...
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
// ...
}
Estos dos métodos Qué diferencia hace? Mira el siguiente código:
public static void main(String[] args){
List<Integer> i=Arrays.asList(1,2,3,4,5,6,7);
i.stream().forEach(System.out :: println);//固定结果 1234567
i.parallelStream().forEach(System.out :: println);//每次的结果都不同
i.parallelStream().forEachOrdered(System.out :: println);//结果同stream.forEach
}
parallelStream () es una operación en paralelo, los datos se divide en una pluralidad de segmentos, cada uno de los cuales se procesa en un hilo diferente, y luego da salida a los resultados juntos. parallelStream eficiencia que los tradicionales de bucle y corriente mucho más rápido
Por eso, cuando a utilizar arroyo o parallelStream ella? Puede empezar a considerar los siguientes tres puntos
- La necesidad de paralelo?
- Si es independiente de cada tarea? Si causará ningún condiciones de carrera?
- Los resultados dependen de si la secuencia de llamada de tareas?
Interfaz de corriente
Stream no es una colección de elementos, no es una estructura de datos de los datos no se guarda, se trata de algoritmos y cálculos, es más como una versión avanzada del iterador. La versión original del iterador, un usuario puede explícitamente a través de los elementos y realizar una cierta operación; avanzada versiones Stream, siempre que las necesidades de los usuarios para realizar cualquier operación dada de sus elementos contenidos, tales como "filtro cabo longitud mayor que 10 cadena "" Obtener la primera letra de cada cadena "e, implícitamente corriente atravesado internamente convertir los datos en consecuencia.
Stream como un iterador (el iterador), unidireccional, no alternativo, los datos sólo pueden ser atravesados una vez atravesado una vez después de agotada, como el agua fluye desde la parte delantera, se ha ido.
Y mientras que el iterador es diferente y, en funcionamiento corriente paralela, sólo iteradores imperativo, la operación de serialización. Como su nombre sugiere, cuando un modo en serie a través, y luego leer cada artículo para leer el siguiente artículo. Cuando se utiliza para atravesar los datos en paralelo se divide en una pluralidad de segmentos, cada uno de los cuales se procesa en un hilo diferente, y luego da salida a los resultados juntos. paralelismo depende tenedor corriente introducida en Java7 / Join marco (JSR166y) para acelerar la tarea de proceso y de división.
Se enumeran los siguientes métodos comunes:
public interface Stream<T> extends BaseStream<T, Stream<T>> {
// 过滤流
Stream<T> filter(Predicate<? super T> predicate);
// 找到流中最小的
Optional<T> min(Comparator<? super T> comparator);
// 找到流中最大的
Optional<T> max(Comparator<? super T> comparator);
// 流中是否有满足条件的
boolean anyMatch(Predicate<? super T> predicate);
// 流中是否都满足条件
boolean allMatch(Predicate<? super T> predicate);
// 流中是否都不匹配
boolean noneMatch(Predicate<? super T> predicate);
// 流中找到第一个
Optional<T> findFirst();
// 流中找到任意一个
Optional<T> findAny();
// 这个方法传入一个Function的函数式接口，这个接口，接收一个泛型T，返回泛型R
// map函数的定义，返回的流，表示的泛型是R对象，这个表示，调用这个函数后，可以改变返回的类型
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
void forEach(Consumer<? super T> action);
// ...
}
Corriente <T> filtro (predicado <? Super T> predicado) para filtrar la corriente de entrada de acuerdo a la expresión lamada. Importante método mapa de diferencias y el método es para devolver el valor del filtro, con el mapa de salida se pueden asignar a diferentes tipos de parámetros, sino simplemente un filtrado filtrar el flujo original. Función predicado y una interfaz de función.
Interfaz funcional
JDK 1.8 API incluye muchos interfaz integrada de funciones, común a la interfaz Ejecutable como Comparador de edad o Java, estas interfaces se pueden utilizar para aumentar el comentario @FunctionalInterface en lambda.
| nombre | tipo | descripción |
|---|---|---|
| Consumidor | Consumidor <T> | Recibir el objeto T, no devuelve valor |
| Predicado | Predicado <T> | Recibir el objeto y devuelve un T boolean |
| Función | Función <T, R> | T objeto receptor, y devuelve el objeto R |
| Proveedor | Proveedor <T> | Proporcionar un objeto T (por ejemplo, plantas) no recibe un valor |
| UnaryOperator | UnaryOperator | T objeto receptor, y devuelve el objeto T |
| BinaryOperator | BinaryOperator | T recibe dos objetos, el objeto vuelve T |
interfaz FunctionalInterface marcada se llama una interfaz de la función, la interfaz puede tener un método personalizado, pero puede incluir métodos heredados de la clase de objeto se deriva. Si un método es sólo una interfaz, el compilador piensa que esto es una interfaz de función. Si se trata de una interfaz de función, es necesario prestar atención a los siguientes puntos:
- La única marca de comentario "una y sólo unamétodo abstracto"En la interfaz.
- JDK8 métodos estáticos de interfaz y el método por defecto, no se consideran métodos abstractos.
- predeterminado de la interfaz hereda java.lang.Object, por lo que si la interfaz muestra una declaración sobre los métodos de objeto, métodos de manera no demasiado abstractos.
- No se requiere el comentario, si se define una interfaz coincidente "interfaz de la función", luego hizo que las notas no se ven afectados. Además de las notas a mejor permiten al compilador para ser revisado. Si la escritura no es la interfaz funcional, pero @FunctionInterface añadido, entonces el compilador se quejará.
- Dos métodos definidos en una interfaz personalizada, producirá anotación no válido '@FunctionalInterface'; FunctionalInterfaceTest no es un funcionales errores de interfaz.
Interfaz predicado
Funciones de predicado función principal es proporcionar un método de ensayo de la interfaz, basado en la expresión lambda entrante determinado, acepta un parámetro devuelve un tipo booleano, algún predicado determina cuando el api corriente muy común.
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
//...
}
Además, predicado también proporciona tres método por defecto adicional y dos métodos estáticos ( JAVA8 nuevas características ).
- y un método de recepción de tipo predicado, es entrante a las condiciones actuales y las condiciones y los datos de relaciones filtrada.
- o un método de recibir el mismo tipo de predicados, las condiciones actuales entrantes y filtrando condiciones a los datos o relación.
- niega la condición actual es negado. Vistazo a usos específicos
A continuación nos fijamos en tres formas importantes de predicados implementación predeterminada de AND, OR, y negar los tres conexión correspondiente de símbolos && java, y || !.
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
@SuppressWarnings("unchecked")
static <T> Predicate<T> not(Predicate<? super T> target) {
Objects.requireNonNull(target);
return (Predicate<T>)target.negate();
}
}
prueba:
int[] numbers= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
List<Integer> list=new ArrayList<>();
for(int i:numbers) {
list.add(i);
}
Predicate<Integer> p1=i->i>5;
Predicate<Integer> p2=i->i<20;
Predicate<Integer> p3=i->i%2==0;
List test=list.stream().filter(p1.and(p2).and(p3)).collect(Collectors.toList());
System.out.println(test.toString());
/** print:[6, 8, 10, 12, 14]*/
interfaz para funciones
Fuente parte:
@FunctionalInterface
public interface Function<T, R> {
// 将Function对象应用到输入的参数上，然后返回计算结果
R apply(T t);
// 返回一个先执行before函数对象apply方法再执行当前函数对象apply方法的函数对象
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
// 返回一个先执行当前函数对象apply方法再执行after函数对象apply方法的函数对象。
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
/**
* Returns a function that always returns its input argument.
*/
static <T> Function<T, T> identity() {
return t -> t;
}
}
Salvo que lo componen y la función andthen para ejecutar una orden diferente. la función de composición ejecutado primer parámetro, y luego ejecutar la persona que llama, pero la persona que llama andthen ejecuta en primer lugar, y después realice parámetro.
el uso de dos puntos dobles
Doble de colon es el formato de método Java referencias operador, referencias de métodos:: nombre de la clase nombre del método.
Aquí es el nombre del método, seguido por el nombre del método sin paréntesis "()". --------> Esta fórmula no representa la voluntad llamar a este método. Esta fórmula se utiliza generalmente como una de las expresiones lambda, lambda llamada carga diferida, los soportes no dicen, mirada a la situación llamando al método.
Por ejemplo:
la expresión:
persona -> person.getAge ();
Puede ser reemplazado con:
Persona :: getAge
expresiones:
() -> lo nuevo HashMap <> ();
Puede ser sustituido
HashMap :: nueva
Este método de referencia o un operador de dos puntos dobles correspondiente al tipo de parámetro esFunción <T, R>, T representa el tipo de entrada, R representa el tipo de retorno. Expresiones tales persona -> person.getAge (); parámetro de entrada es persona, el valor de retorno es peron.getAge (), entonces la referencias de métodos correspondientes a persona :: getAge Funciton <persona, Integer> tipo.
Código de ejemplo: Dentro de la lista de todos los tapones de cadena y devuelve un nuevo ArrayList, en el ejemplo anterior se escribe.
List<String> collected = new ArrayList<>();
collected.add("alpha");
collected.add("beta");
collected = collected.stream().map(string -> string.toUpperCase()).collect(Collectors.toList());
System.out.println(collected);
Después de programar el siguiente operador de colon doble forma:
List<String> collected = new ArrayList<>();
collected.add("alpha");
collected.add("beta");
collected = collected.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println(collected);
Enlaces de referencia: https://segmentfault.com/a/1190000012256677?utm_source=tag-newest
Enlaces de referencia: https://blog.csdn.net/huo065000/article/details/78964382
Enlaces de referencia: https: //www.cnblogs .com / Hengzhou / p / 9550250.html
