java 集合Stream操作

Stream相当于我们集合中的迭代器，不同的是这是一个增强的迭代器，可以并行的对数据进行处理，而迭代器只能串行的执行。使用并行去遍历时，数据会被分成多个段，每个段在不同的线程中执行，最后将计算结果进行合并。使用的是jdk7新加的fork/join框架。

分类：

• Intermediate：一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
• Terminal：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect。

还有一种操作被称为 short-circuiting。用以指：

• 对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
• 对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。

当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个 short-circuiting 操作是必要非充分条件。

在对于一个 Stream 进行多次转换操作 (Intermediate 操作)，每次都对 Stream 的每个元素进行转换，而且是执行多次，这样时间复杂度就是 N（转换次数）个 for 循环里把所有操作都做掉的总和吗？其实不是这样的，转换操作都是 lazy 的，多个转换操作只会在 Terminal 操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream 里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在 Terminal 操作的时候循环 Stream 对应的集合，然后对每个元素执行所有的函数。

对集合对的Sream操作分为以下几类：

Intermediate：

map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

Terminal：

forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

Short-circuiting

anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

流的创建：

1、Stream.of

2、Collections.stream

准备工作：

1、创建一个Person来进行数据的存储

public class Person {
    private Integer id;
    private String name;

    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

在实例化一个List实例对象，并向其中添加以下几条数据。

 List<Person> list = new ArrayList();
 list.add(new Person(1, "name1"));
 list.add(new Person(2, "name2"));
 list.add(new Person(3, "name3"));

map：

可以将集合的元素进行转化为另一种元素，比如说在这里，我想获得所有人的姓名，结果为一个List

 System.out.println(list.stream().map(Person::getName).collect(Collectors.toList()));

flatMap:

map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。

Stream<List<Integer>> inputStream = Stream.of(
				 Arrays.asList(1),
				 Arrays.asList(2, 3),
				 Arrays.asList(4, 5, 6)
				 );
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());
System.out.println(outputStream.collect(Collectors.toList()));

flatMap 把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一起，最终 output 的新 Stream 里面已经没有 List 了，都是直接的数字。

filter：

过滤集合中的元素，返回为false，去除元素中的集合。jiguo

System.out.println(list.stream().filter(o->o.getId() > 2).collect(Collectors.toList()));   //去除集合中id >2的元素for

 

foreach:

forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。foreach是terminal操作，执行后，元素就被消费掉了，无法对一个Stream队形俩次terminal操作。而peek可以达到该操作。

 list.stream().forEach(o-> System.out.println(o.getId());

peek:

list.stream().peek(o-> System.out.println(o.getId());

findFirst:

返回Stream中的第一个元素。返回类型为Optional。

System.out.println(list.stream().findFirst().get());

Stream 中的 findAny、max/min、reduce 等方法等返回 Optional 值。还有例如 IntStream.average() 返回 OptionalDouble 等等。

System.out.println(list.stream().findFirst().get());

reduce:

可以将集合中的元素组合起来，例如：字符串拼接，数值的sum,min,max,average都是特殊的reduce。

System.out.println(Arrays.asList(1,2,3,4,5).stream().reduce(0,(a1,a2)->a1+a2));  //求和，返回的是具体数值
System.out.println(Arrays.asList(1,2,3,4,5).stream().reduce((a1,a2)->a1+a2).get());//当存在起始值时，返回的是Optional对象
//获取最大值
System.out.println(Arrays.asList(1,2,3,4,5).stream().reduce((a1,a2)->{
            if(a1>a2) return a1;
            return a2;
        }).get());

limit和skip：

limit返回Stream的前n个元素，skip则是舍弃前n个元素

System.out.println(Arrays.asList(5,4,3,2,1).stream().skip(2).collect(Collectors.toList()))//[3,2,1] 
System.out.println(Arrays.asList(5,4,3,2,1).stream().limit(2).collect(Collectors.toList()));//[5,4]

sort:

对元素进行排序，强大之处在于可以对Stream类进行map,filter,limit,skip,distinct之后在进行排序，提高效率。

        System.out.println(Arrays.asList(5,4,3,2,1).stream().skip(2).sorted(Integer::compare).collect(Collectors.toList())); //[1,2,3]

min,max,distinct

min:获取最小值

max:获取最大值

distinct：过滤掉重复的元素，对于对象使用的是equals方法进行判断是否相等的。

System.out.println(Arrays.asList(1,2,2,3,3,4,5,5,6).stream().min(Integer::compareTo));

System.out.println(Arrays.asList(1,2,2,3,3,4,5,5,6).stream().max(Integer::compareTo));

System.out.println(Arrays.asList(1,2,2,3,3,4,5,5,6).stream().distinct().collect(Collectors.toList()));

allMatch,anyMatch,noneMatch:

allMatch:全部匹配才返回true;

anyMatch:只有一个匹配就返回true

noneMatch：没有匹配返回true