JDK8集合的便捷操作

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）操作。

　　   　　

stream还有很多操作

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

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

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