集合的迭代
流使得程序员得以站在更高的抽象层次上对集合进行操作。
传统的迭代方法
直接看代码：

                List<Dog> dogs = new ArrayList<>();
                dogs.add(new Dog("大黄", 2));
                dogs.add(new Dog("小黑", 3));
                dogs.add(new Dog("小哈",1));
               
                //最原始的 for 循环
                for (int i = 0; i < dogs.size(); i++) {
                        System.out.println(dogs.get(i));
                }
                //增强 for 循环
                for (Dog dog1 : dogs) {
                        System.out.println(dog1);
                }
                //使用迭代器
                Iterator<Dog> it = dogs.iterator();
                while (it.hasNext()) {
                        Dog dog2 = it.next();
                        System.out.println(dog2);
                }
说明：
增强 for 循环，只是一个语法糖（Syntax Sugar），它的本质就是使用 迭代器进行迭代。所以在，增强 for 循环里面，无法修改集合。这里也可以使用 while 来迭代 ，但是 while 还没有 for 循环方便呢。

Stream 和 Lambda 进行集合迭代
//使用 Stream 和 Lambda 表达式进行迭代
dogs.stream().forEach(System.out::println);

//只使用 Lambda 表达式进行迭代
dogs.forEach(System.out::println);

这样看似乎是下面这个更简单点，但是 Stream 的作用远不止于此，它可以将多个操作，串联起来，使用 链式编程的方法，实现很复杂的操作。下面这个只是使用 Lambda 进行遍历操作而已。

流和集合
流（Stream）是一种内部迭代方式，可以通过集合直接获取到相应的 流（Stream），例如：Stream<Dog> stream = dogs.stream();，当然了也可以从流获取集合 List<Dog> dogs = stream.collect(Collectors.toList());.。这里只是以 List 集合为例，Map 和 Set 也是可以的。准确的说，流 开启了操作集合的新的方法，使用函数式编程来重构以前的代码，也是非常的不错的。

这个只举一个简单的例子：就可以看出使用 Stream 是多么的方便了。
有一个集合里面存储了 数字和非数字字符串，现在想要求这些数字字符串的和：
“1” “2” “3” “a” “4” “5” “c” “6” “7” “8” “d” “9” "10"

方式一：推荐使用，采用函数式编程（链式编程）：

List<String> mixStr = new ArrayList<String>(Arrays.asList("1", "2", "3", "a", "4", "5", "c", "6", "7", "8", "d", "9", "10"));
int sumary = mixStr.
                stream().
                filter(s->s.matches("^[0-9]*$")).
                map(Integer::parseInt).
                reduce(0, (acc, e)->acc+e);
System.out.println("方式一（推荐）："+sumary);

//有时候，一行太长了，可以分开写，这样增加了可读性。
sumary = mixStr.stream().filter(s->s.matches("^[0-9]*$")).map(Integer::parseInt).reduce(0, (acc, e)->acc+e);

方式二：不推荐使用，采用函数式编程（不使用链式编程）：

Stream<String> filter = mixStr.stream().filter(s->s.matches("^[0-9]*$"));
Stream<Integer> map = filter.map(Integer::parseInt);
Integer reduce = map.reduce(0, (acc, e)->acc+e);
System.out.println(""+reduce);
System.out.println("方式二（不推荐）："+reduce);
这样做增加了很多繁琐的步骤和临时变量，这和函数式编程的思想是相反的，但是这样可以帮助我们学习，理解函数式编程。

方式三：传统的集合操作

sumary = 0;
for (String s : mixStr) {
        if (s.matches("^[0-9]*$")) {
                sumary += Integer.parseInt(s);
        }
}
System.out.println("传统的方式："+sumary);
这样看似乎，还是传统的方式比较简单，可能和这个例子有关，但是仔细分析还是能看出流和集合操作的差异，在流中每一步都是明确的，而且每一步（中间操作，不是终结操作，这个可以自己了解）都是返回一个流，而集合却将这些都耦合到一起了，所以很难修改，而流就很简单了，替换一个中间步骤是很简单的。
例如，只是将reduce过程去掉，换成 forEach 遍历，这需要改变最后一个操作即可，是不是很方便。

//流的用处很多。
mixStr.stream().filter(s->s.matches("^[0-9]*$")).map(Integer::parseInt).forEach(System.out::print);
运行截图：


说明
这个主要是对集合的遍历来说流的好处，并不是说流的（我也是才开始了解，并不是很深入，这里可能只是一条皮毛吧，希望大家喜欢。），如果感兴趣可以参考相关的博客或者书籍，阅读关于流的知识，可以说，流开启了新的时代，正如开头那句话所说的。

集合的迭代
流使得程序员得以站在更高的抽象层次上对集合进行操作。
传统的迭代方法
直接看代码：

                List<Dog> dogs = new ArrayList<>();
                dogs.add(new Dog("大黄", 2));
                dogs.add(new Dog("小黑", 3));
                dogs.add(new Dog("小哈",1));
               
                //最原始的 for 循环
                for (int i = 0; i < dogs.size(); i++) {
                        System.out.println(dogs.get(i));
                }
                //增强 for 循环
                for (Dog dog1 : dogs) {
                        System.out.println(dog1);
                }
                //使用迭代器
                Iterator<Dog> it = dogs.iterator();
                while (it.hasNext()) {
                        Dog dog2 = it.next();
                        System.out.println(dog2);
                }
说明：
增强 for 循环，只是一个语法糖（Syntax Sugar），它的本质就是使用 迭代器进行迭代。所以在，增强 for 循环里面，无法修改集合。这里也可以使用 while 来迭代 ，但是 while 还没有 for 循环方便呢。

Stream 和 Lambda 进行集合迭代
//使用 Stream 和 Lambda 表达式进行迭代
dogs.stream().forEach(System.out::println);

//只使用 Lambda 表达式进行迭代
dogs.forEach(System.out::println);

这样看似乎是下面这个更简单点，但是 Stream 的作用远不止于此，它可以将多个操作，串联起来，使用 链式编程的方法，实现很复杂的操作。下面这个只是使用 Lambda 进行遍历操作而已。

流和集合
流（Stream）是一种内部迭代方式，可以通过集合直接获取到相应的 流（Stream），例如：Stream<Dog> stream = dogs.stream();，当然了也可以从流获取集合 List<Dog> dogs = stream.collect(Collectors.toList());.。这里只是以 List 集合为例，Map 和 Set 也是可以的。准确的说，流 开启了操作集合的新的方法，使用函数式编程来重构以前的代码，也是非常的不错的。

这个只举一个简单的例子：就可以看出使用 Stream 是多么的方便了。
有一个集合里面存储了 数字和非数字字符串，现在想要求这些数字字符串的和：
“1” “2” “3” “a” “4” “5” “c” “6” “7” “8” “d” “9” "10"

方式一：推荐使用，采用函数式编程（链式编程）：

List<String> mixStr = new ArrayList<String>(Arrays.asList("1", "2", "3", "a", "4", "5", "c", "6", "7", "8", "d", "9", "10"));
int sumary = mixStr.
                stream().
                filter(s->s.matches("^[0-9]*$")).
                map(Integer::parseInt).
                reduce(0, (acc, e)->acc+e);
System.out.println("方式一（推荐）："+sumary);

//有时候，一行太长了，可以分开写，这样增加了可读性。
sumary = mixStr.stream().filter(s->s.matches("^[0-9]*$")).map(Integer::parseInt).reduce(0, (acc, e)->acc+e);

方式二：不推荐使用，采用函数式编程（不使用链式编程）：

Stream<String> filter = mixStr.stream().filter(s->s.matches("^[0-9]*$"));
Stream<Integer> map = filter.map(Integer::parseInt);
Integer reduce = map.reduce(0, (acc, e)->acc+e);
System.out.println(""+reduce);
System.out.println("方式二（不推荐）："+reduce);
这样做增加了很多繁琐的步骤和临时变量，这和函数式编程的思想是相反的，但是这样可以帮助我们学习，理解函数式编程。

方式三：传统的集合操作

sumary = 0;
for (String s : mixStr) {
        if (s.matches("^[0-9]*$")) {
                sumary += Integer.parseInt(s);
        }
}
System.out.println("传统的方式："+sumary);
这样看似乎，还是传统的方式比较简单，可能和这个例子有关，但是仔细分析还是能看出流和集合操作的差异，在流中每一步都是明确的，而且每一步（中间操作，不是终结操作，这个可以自己了解）都是返回一个流，而集合却将这些都耦合到一起了，所以很难修改，而流就很简单了，替换一个中间步骤是很简单的。
例如，只是将reduce过程去掉，换成 forEach 遍历，这需要改变最后一个操作即可，是不是很方便。

//流的用处很多。
mixStr.stream().filter(s->s.matches("^[0-9]*$")).map(Integer::parseInt).forEach(System.out::print);
运行截图：


说明
这个主要是对集合的遍历来说流的好处，并不是说流的（我也是才开始了解，并不是很深入，这里可能只是一条皮毛吧，希望大家喜欢。），如果感兴趣可以参考相关的博客或者书籍，阅读关于流的知识，可以说，流开启了新的时代，正如开头那句话所说的。