java的foeachr循环_Java 8 Stream详解

概述

继Java 8系列之Lambda表达式之后，我们来了解Stream。Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。

聚合操作

为了学习聚合的使用，在这里，先定义一个数据类：

public class Student {

int no;

String name;

String sex;

float height;

public Student(int no, String name, String sex, float height) {

this.no = no;

this.name = name;

this.sex = sex;

this.height = height;

}

****

}

Student stuA = new Student(1, "A", "M", 184);

Student stuB = new Student(2, "B", "G", 163);

Student stuC = new Student(3, "C", "M", 175);

Student stuD = new Student(4, "D", "G", 158);

Student stuE = new Student(5, "E", "M", 170);

List list = new ArrayList<>();

list.add(stuA);

list.add(stuB);

list.add(stuC);

list.add(stuD);

list.add(stuE);

现有一个List list里面有5个Studeng对象，假如我们想获取Sex=“G”的Student，并打印出来。如果按照我们原来的处理模式，必然会想到一个for循环就搞定了，而在for循环其实是一个封装了迭代的语法块。在这里，我们采用Iterator进行迭代：

Iterator iterator = list.iterator();

while(iterator.hasNext()) {

Student stu = iterator.next();

if (stu.getSex().equals("G")) {

System.out.println(stu.toString());

}

}

整个迭代过程是这样的：首先调用iterator方法，产生一个新的Iterator对象，进而控制整

个迭代过程，这就是外部迭代 迭代过程通过显式调用Iterator对象的hasNext和next方法完成迭代

而在Java 8中，我们可以采用聚合操作：

list.stream()

.filter(student -> student.getSex().equals("G"))

.forEach(student -> System.out.println(student.toString()));

首先，通过stream方法创建Stream，然后再通过filter方法对源数据进行过滤，最后通过foeEach方法进行迭代。在聚合操作中，与Labda表达式一起使用，显得代码更加的简洁。这里值得注意的是，我们首先是stream方法的调用，其与iterator作用一样的作用一样，该方法不是返回一个控制迭代的 Iterator 对象，而是返回内部迭代中的相应接口： Stream，其一系列的操作都是在操作Stream,直到feach时才会操作结果，这种迭代方式称为内部迭代。

外部迭代和内部迭代(聚合操作)都是对集合的迭代，但是在机制上还是有一定的差异：

迭代器提供next()、hasNext()等方法，开发者可以自行控制对元素的处理，以及处理方式，但是只能顺序处理；

stream()方法返回的数据集无next()等方法，开发者无法控制对元素的迭代，迭代方式是系统内部实现的，同时系统内的迭代也不一定是顺序的，还可以并行，如parallelStream()方法。并行的方式在一些情况下，可以大幅提升处理的效率。

Stream

如何使用Stream?

聚合操作是Java 8针对集合类，使编程更为便利的方式，可以与Lambda表达式一起使用，达到更加简洁的目的。

前面例子中，对聚合操作的使用可以归结为3个部分：

1.创建Stream:通过stream()方法，取得集合对象的数据集。

2.Intermediate:通过一系列中间(Intermediate)方法，对数据集进行过滤、检索等数据集的再次处理。如上例中，使用filter()方法来对数据集进行过滤。

3.Terminal通过最终(terminal)方法完成对数据集中元素的处理。如上例中，使用forEach()完成对过滤后元素的打印。

在一次聚合操作中，可以有多个Intermediate，但是有且只有一个Terminal。也就是说，在对一个Stream可以进行多次转换操作，并不是每次都对Stream的每个元素执行转换。并不像for循环中，循环N次，其时间复杂度就是N。转换操作是lazy(惰性求值)的，只有在Terminal操作执行时，才会一次性执行。可以这么认为，Stream 里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在 Terminal 操作的时候循环 Stream 对应的集合，然后对每个元素执行所有的函数。

Stream的操作分类

刚才提到的Stream的操作有Intermediate、Terminal和Short-circuiting：

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

Terminal：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、iterator

Short-circuiting：

anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

惰性求值和及早求值方法

像filter这样只描述Stream，最终不产生新集合的方法叫作惰性求值方法；而像count这样最终会从Stream产生值的方法叫作及早求值方法。

long count = allArtists.stream()

.filter(artist -> {

System.out.println(artist.getName());

return artist.isFrom("London");

})

.count();

如何判断一个操作是惰性求值还是及早求值，其实很简单，只需要看其返回值即可：如果返回值是Stream，那么就是惰性求值；如果返回值不是Stream或者是void，那么就是及早求值。上面的示例中，只是包含两步：一个惰性求值-filter和一个及早求值-count。

前面，已经说过，在一个Stream操作中，可以有多次惰性求值，但有且仅有一次及早求值。

创建Stream

我们有多种方式生成Stream:

Stream接口的静态工厂方法(注意：Java8里接口可以带静态方法)；

Collection接口和数组的默认方法(默认方法,也使Java的新特性之一，后续介绍)，把一个Collection对象转换成Stream

其他

Random.ints()

BitSet.stream()

Pattern.splitAsStream(java.lang.CharSequence)

JarFile.stream()

静态工厂方法

of

of方法，其生成的Stream是有限长度的，Stream的长度为其内的元素个数。

of(T... values)：返回含有多个T元素的Stream

of(T t)：返回含有一个T元素的Stream

例如：

Stream integerStream = Stream.of(1, 2, 3);

Stream stringStream = Stream.of("A");

generator

generator方法，返回一个无限长度的Stream,其元素由Supplier接口的提供。在Supplier是一个函数接口，只封装了一个get()方法，其用来返回任何泛型的值，该结果在不同的时间内，返回的可能相同也可能不相同，没有特殊的要求。

generate(Supplier s)：返回一个无限长度的Stream

这种情形通常用于随机数、常量的 Stream，或者需要前后元素间维持着某种状态信息的 Stream。

把 Supplier 实例传递给 Stream.generate() 生成的 Stream，默认是串行(相对 parallel 而言)但无序的(相对 ordered 而言)。

示例：

Stream generateA = Stream.generate(new Supplier() {

@Override

public Double get() {

return java.lang.Math.random();

}

});

Stream generateB = Stream.generate(()-> java.lang.Math.random());

Stream generateC = Stream.generate(java.lang.Math::random);

以上三种形式达到的效果是一样的，只不过是下面的两个采用了Lambda表达式，简化了代码，其实际效果就是返回一个随机值。一般无限长度的Stream会与filter、limit等配合使用，否则Stream会无限制的执行下去，后果可想而知，如果你有兴趣，不妨试一下。

empty

empty方法返回一个空的顺序Stream，该Stream里面不包含元素项。

Collection接口和数组的默认方法

在Collection接口中，定义了一个默认方法stream()，用来生成一个Stream。

public interface Collection extends Iterable {

***

default Stream stream() {

return StreamSupport.stream(spliterator(), false);

}

***

}

在Arrays类，封装了一些列的Stream方法，不仅针对于任何类型的元素采用了泛型，更对于基本类型作了相应的封装，以便提升Stream的处理效率。

public class Arrays {

***

public static Stream stream(T[] array) {

return stream(array, 0, array.length);

}

public static LongStream stream(long[] array) {

return stream(array, 0, array.length);

}

***

｝

示例：

int ids[] = new int[]{1, 2, 3, 4};

Arrays.stream(ids)

.forEach(System.out::println);

其他

Random.ints()

BitSet.stream()

Pattern.splitAsStream(java.lang.CharSequence)

JarFile.stream()