在没有接触java8的时候，我们遍历一个集合都是用循环的方式，从第一条数据遍历到最后一条数据，现在思考一个问题，为什么要使用循环，因为要进行遍历，但是遍历不是唯一的方式，遍历是指每一个元素逐一进行处理（目的），而并不是从第一个到最后一个顺次处理的循环，前者是目的，后者是方式。 所以为了让遍历的方式更加优雅，出现了流（stream）！

假设一个案例：将集合A根据条件1过滤为子集B,然后根据条件2过滤为子集C

在没有引入流之前我们的做法可能为：

public class Demo02NormalFilter { 

       public static void main(String[] args) { 

           List<String> list = new ArrayList<>(); 

           list.add("张无忌"); 

           list.add("周芷若"); 

           list.add("赵敏"); 

           list.add("张强"); 

           list.add("张三丰"); 

           List<String> zhangList = new ArrayList<>(); 

           for (String name : list) { 

               if (name.startsWith("张")) { 

                   zhangList.add(name); 

               } 

           } 

     

           List<String> shortList = new ArrayList<>(); 

           for (String name : zhangList) { 

               if (name.length() == 3) { 

                   shortList.add(name); 

               } 

           } 

     
           for (String name : shortList) { 

               System.out.println(name); 

           } 

       } 

   } 

现在以流的方式实现同样的功能：

      public static void main(String[] args) { 
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.stream().filter(s->s.startsWith("张")).filter(s-> s.length() == 3).forEach(System.out::println);

从上面的两段代码可以看出流的存在让代码更加优雅。既然是筛选那么就直接用过滤方法就好了。

这个和lambda表达式的延迟加载的原理一样，它可以进行链式编程，比如 ().filter().map().limit()，可以点下去，到最后一步(方法为count或者foreach)加载数据。这里主要介绍map和concat方法

      Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter(s -> s.startsWith("张"));
        result.forEach(name-> System.out.println(name));

将流中的元素映射到另一个流中，这个是在后期经常用到的，比如方法所接收的返回值是A,但是接收的却是B
这里举两个例子

将String类型的流转换为Integer 类型

        Stream<String> stringStream = Stream.of("1", "2", "3", "4", "5", "6");
        stringStream.map(str->Integer.parseInt(str)).forEach(System.out::println);

方法需要返回的是List，但是这里只有List,此时就要想到stream().map

    public  List<String> queryNamesByIds(List<Long> ids){
        List<Category> categories = this.categoryMapper.selectByIdList(ids);
       return  categories.stream().map(category -> category.getName()).collect(Collectors.toList());
    }

      Stream<String> streamA = Stream.of("张无忌","张翠山");
        Stream<String> streamB = Stream.of("美羊羊","喜羊羊");
        //写法1
        //Stream.concat(streamA, streamB).forEach(System.out::println);
        
        //写法2
       Stream<String> result=  Stream.concat(streamA, streamB);
       result.forEach(name-> System.out.println(name));

执行完的结果不能在调用延迟方法。 如 ().filter().count().limit()这样的写法就会报错。
cout方法与foreach方法比较简单，这里不介绍了。