Java8六大新特性之五流式式操作Stream类

流是javaAPI得新成员，它允许你以声明性方式处理数据集合。它还可以透明得并行处理，你无需写任何多线程代码。

流的具体方法操作类型大全：

最常用的集合类的流获取及操作：

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);
    }
}

执行结果：

aaaa
bbbb
222
111
Bill
Allen
18
19
array1
array2
array3

Process finished with exit code 0

filter 方法定义的是接收一个Predicate函数式接口，所有只用实现其抽象方法test就行了。

Stream<T> filter(Predicate<? super T> predicate);
boolean test(T t);

foreach 方法定义的是接收一个Consumer函数式接口，所以这里只有实现其抽象方法accetp。

void forEach(Consumer<? super T> action);
void accept(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);
    }
}

执行结果：

got aabb
aabb

Process finished with exit code 0

map 方法定义的是接收一个Function函数式接口，所以这里只有实现其抽象方法apply。

<R> Stream<R> map(Function<? super T, ? extends R> mapper)
R apply(T t);

所以map的作用就是把一个类型的流转换为另一个类型的流

比如一个流里面全是int，用map可以把他们类型转换为String

例子如下：

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

运行结果：

map - 112
map - 223
map - 334

limit 作用是取stream里面的前n个元素，并生成下一个流，可以理解为linux命令中的head

例子：

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

执行结果：

limit - 111
limit - 222

skip 作用是取steam的后size-n个元素，并生成下一个流

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

执行结果：

skip - 222
skip - 333

concat 将2个流中的元素合并，并生成一个新流

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

执行结果：

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

collect 收集操作，将流转换为collection

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

reduce 归约操作，将流中元素进行求和，取最大值，最小值。。。

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

执行结果：

666

parallel 并行处理，stream支持并行处理提高执行效率

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);

执行效果：

012345678910111213141516171819202122232425262728293031323334353637383940414243444546474849sumVal4999999950000000
658973412123456789
Process finished with exit code 0