Cinco de las seis nuevas características de la operación de tipo Stream Java8 Clase Stream

Stream es un nuevo miembro de javaAPI, que le permite procesar colecciones de datos de forma declarativa. También se puede procesar de forma transparente en paralelo, no es necesario escribir ningún código de subprocesos múltiples.

Enciclopedia de métodos y tipos de operaciones específicos:

 

La adquisición y operación de flujo de clase de colección más comúnmente utilizada:

import java.util.*;
import java.util.stream.Stream;

public class StreamOperateTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaaa");
        list.add("bbbb");
        list.stream().forEach(System.out::println);

        Set<Integer> set = new HashSet<>();
        set.add(111);set.add(222);
        set.stream().forEach(System.out::println);

        Map<String, Integer> map = new HashMap();
        map.put("Allen",19);
        map.put("Bill",18);
        map.keySet().stream().forEach(System.out::println);
        map.values().stream().forEach(System.out::println);

        String[] array = {"array1", "array2", "array3"};
        Stream.of(array).forEach(System.out::println);
    }
}

Resultados de:

aaaa
bbbb
222
111
Bill
Allen
18
19
array1
array2
array3

Process finished with exit code 0

 

El método de filtro está definido para recibir una interfaz funcional Predicate, por lo que solo necesita implementar su prueba de método abstracto.

Filtro Stream <T> (predicado predicado <? Super T>);
prueba booleana (T t);

El método foreach está definido para recibir una interfaz funcional de consumidor, por lo que aquí solo se implementa el método abstracto accetp.

void forEach (acción del consumidor <? super T>);
anular aceptar (T t);

import java.util.ArrayList;
import java.util.List;

public class StreamFilterForeachTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaaa");
        list.add("bbbb");
        list.add("aabb");
        list.add("aabbcc");
        //用非stream流得方式进行遍历
        for (String str:list){
            if (str.contains("ab")&&str.length()==4){
                System.out.println("got "+ str);
            }
        }
        //用stream流进行遍历
        list.stream()
                .filter(str->str.contains("ab"))
                .filter(str->str.length()==4)
//                .forEach(str-> System.out.println("got"+str));
                .forEach(System.out::println);
    }
}

Resultados de:

got aabb
aabb

Process finished with exit code 0

El mapa método se define para recibir una función de interfaz funcional, por lo que aquí sólo el método abstracto se aplica se implementa .

<R> Corriente <R> mapa (Función <? Super T,? Extiende R> mapeador)
R aplicar (T t);

Entonces, la función del mapa es convertir un tipo de flujo en otro tipo de flujo

Por ejemplo, una secuencia está llena de int, use map para convertirlos a String

Los ejemplos son los siguientes:

eam.of("111","222","333").map(Integer::parseInt).forEach(x-> System.out.println("map - "+ (++x)));

resultado de la operación:

map - 112
map - 223
map - 334

La función del límite es tomar los primeros n elementos en la secuencia y generar la siguiente secuencia, que puede entenderse como el encabezado en el comando de linux

ejemplo:

Stream.of("111","222","333").limit(2).forEach(x-> System.out.println("limit - "+ x));

Resultados de:

limit - 111
limit - 222

La función de saltar es tomar los últimos elementos de tamaño n de vapor y generar la siguiente secuencia

Stream.of("111","222","333").skip(1).forEach(x->System.out.println("skip - "+ x));

Resultados de:

skip - 222
skip - 333

concat fusiona los elementos en los dos flujos y genera un nuevo flujo

Stream.concat(Stream.of("111","222"),Stream.of("333","444")).forEach(x->System.out.println("concat - "+ x));

Resultados de:

concat - 111
concat - 222
concat - 333
concat - 444

recopilar la operación de recopilación, convertir la secuencia en recopilación

List <String> list = Stream.of(111,222,333).map(x->x+"-").collect(Collectors.toList());

La operación de reducción consiste en sumar los elementos de la secuencia y tomar los valores máximo y mínimo. . .

int a = Stream.of(111,222,333).reduce(0,(x,y)->x+y);
System.out.println(a);

Resultados de:

666

procesamiento paralelo paralelo, el flujo admite el procesamiento paralelo para mejorar la eficiencia de ejecución

LongStream.range(0,50).forEach(System.out::print);
Long sumVal= LongStream.range(0,100000000L).parallel().reduce(0,Long::sum);
System.out.println("sumVal" + sumVal);

Stream.of(1,2,3,4,5,6,7,8,9).parallel().forEach(System.out::print);
Stream.of(1,2,3,4,5,6,7,8,9).sequential().forEach(System.out::print);

Efecto de ejecución:

012345678910111213141516171819202122232425262728293031323334353637383940414243444546474849sumVal4999999950000000
658973412123456789
Proceso terminado con código de salida 0