JDK8集合的便捷操作

转自：https://www.cnblogs.com/tietazhan/p/7486244.html

JDK8新特性，stream相关操作。把集合转换成stream，再对其进行相关操作，加上lambada表达式。

demo：

List<String> list = Arrays.asList("a","b"); //所有实现了Conllection的类型都可以使用
        String str = list.stream().map(x->{
            try {
                return x+" and "+x;
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return "";
            }
        }).collect(Collectors.joining("\n"));  // collect 收集器，把处理过的元素都手机起来，Collectors.joining("\n") 是用"\n"（换行符） 分开，也可以用别自己需要的

System.out.println(str);

　　执行结果：

a and a
b and b

　　集合元素分组收集，用字符串长度进行分组：

List<String> list = Arrays.asList("abc","bb","cc","a");
Map<Integer, List<String>> collect = list.stream().collect(Collectors.groupingBy(String::length));
System.out.println(collect.toString());

　　执行结果：

{1=[a], 2=[bb, cc], 3=[abc]}

　　集合的forEach：

List<String> list1 = Arrays.asList("abc","bb","cc","a");
        list1.forEach(x->{
            System.out.println(x.length()); //输出每个元素的长度
        });

　　执行结果：

3
2
2
1

max和min函数，返回最值：

List<String> list = Arrays.asList("abc","bb","cc","a");
Optional<String> max = list.stream().max((a,b)->{
    return a.compareTo(b);
});
System.err.println(max.orElse(null));

　　返回的max为list最大值。max可以调用get()函数，但是如果list为空，则max()返回的就是null，那直接使用get就会报错，但是JDK8改动后，orElse(null)，表示如果对象为空，就返回null，不会报错。

平行流，就是把集合的个元素开多线程去处理：

List<String> list = IntStream.iterate(1, i -> i + 1).limit(20).mapToObj(Integer::toString).collect(Collectors.toList()); //limit 限制stream的最多个数
        list.stream().parallel().forEach(x->{
            System.out.println(x+" " +Thread.currentThread());
        });
//可以直接用parallelStream转换平行流，如下
list.parallelStream().forEach(x->{
    System.out.println(x);
});

　　

　　执行结果：

13 Thread[main,5,main]
7 Thread[ForkJoinPool.commonPool-worker-1,5,main]
15 Thread[main,5,main]
6 Thread[ForkJoinPool.commonPool-worker-1,5,main]
9 Thread[ForkJoinPool.commonPool-worker-1,5,main]
10 Thread[ForkJoinPool.commonPool-worker-1,5,main]
8 Thread[ForkJoinPool.commonPool-worker-1,5,main]
2 Thread[ForkJoinPool.commonPool-worker-1,5,main]
1 Thread[ForkJoinPool.commonPool-worker-1,5,main]
5 Thread[ForkJoinPool.commonPool-worker-1,5,main]
4 Thread[ForkJoinPool.commonPool-worker-1,5,main]
18 Thread[ForkJoinPool.commonPool-worker-1,5,main]
20 Thread[ForkJoinPool.commonPool-worker-1,5,main]
19 Thread[ForkJoinPool.commonPool-worker-1,5,main]
17 Thread[ForkJoinPool.commonPool-worker-1,5,main]
16 Thread[ForkJoinPool.commonPool-worker-1,5,main]
12 Thread[ForkJoinPool.commonPool-worker-1,5,main]
11 Thread[ForkJoinPool.commonPool-worker-1,5,main]
14 Thread[main,5,main]
3 Thread[ForkJoinPool.commonPool-worker-3,5,main]

　　parallel执行是使用 ForkJoinPool的线程池，ForkJoinPool的最大线程数是CPU数-1，如果算上当前线程，则会有CPU数量的线程数执行任务。

集合的合并，把多个集合合并成一个集合并进行操作：  

List<String> al = Arrays.asList("a", "b", "c", "d","e","f");
List<String> al2 = Arrays.asList("a1", "b1", "c1", "d1","e1","f1");
//吧al和al2合并后按单线程输出来
Stream.concat(al.stream(), al2.stream()).forEach(System.out::println);
System.out.println("******************");
//把al和al2合并，并按平行流输出
Stream.concat(al.stream(),al2.stream()).parallel().forEach(System.out::println);
System.out.println("------------------");

　　执行结果：

a
b
c
d
e
f
a1
b1
c1
d1
e1
f1
******************
b1
c1
a1
d
f
e
b
c
a
d1
e1
f1
------------------

　　上面一个执行语句是普通流操作，下面一个语句是平行流（parallel）操作。

1

　　   　　

stream还有很多操作

Optional<T> findFirst(); //返回stream的第一个

Optional<T> findAny(); //随机返回一个

Stream<T> of(T... values) ; //传入多个