1.我们传统的集合操作有什么弊端？
传统集合需要多步遍历代码:几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。
循环遍历的弊端:专注于这么做，而不是做什么.for循环的语法就是“怎么做”;for循环的循环体才是“做什么".
程序员需要装逼,需要更加文雅的写法.
2.获取流有哪两种方式？
方式一: 通过单列集合的stream()
方式二: 通过Stream.of方法 传递数组 或者 单一元素 进行获取流
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。本小节中，终结方法包括 count 和 forEach 方法。
没有遇到终结方法之前,延迟方法都是耍流氓.流在操作过程中,如果执行的是初始操作或者中间操作,那么实际上不会对流元素进行处理只有在进行Stream的终止操作的时候才执行.
4.调用concat方法有什么注意事项?
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat.这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
数组使用Stream.of方法获取的流进行拼接，返回的是泛型为String类型的流；
集合使用stream方法，不建议使用Stream.of方法,返回的流的泛型值会是集合带泛型

1.我们传统的集合操作有什么弊端？
传统集合需要多步遍历代码:几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。
循环遍历的弊端:专注于这么做，而不是做什么.for循环的语法就是“怎么做”;for循环的循环体才是“做什么".
程序员需要装逼,需要更加文雅的写法.
2.获取流有哪两种方式？
方式一: 通过单列集合的stream()
方式二: 通过Stream.of方法 传递数组 或者 单一元素 进行获取流
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。本小节中，终结方法包括 count 和 forEach 方法。
没有遇到终结方法之前,延迟方法都是耍流氓.流在操作过程中,如果执行的是初始操作或者中间操作,那么实际上不会对流元素进行处理只有在进行Stream的终止操作的时候才执行.
4.调用concat方法有什么注意事项?
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat.这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
数组使用Stream.of方法获取的流进行拼接，返回的是泛型为String类型的流；
集合使用stream方法，不建议使用Stream.of方法,返回的流的泛型值会是集合带泛型

1.我们传统的集合操作有什么弊端？
传统集合需要多步遍历代码:几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。
循环遍历的弊端:专注于这么做，而不是做什么.for循环的语法就是“怎么做”;for循环的循环体才是“做什么".
程序员需要装逼,需要更加文雅的写法.
2.获取流有哪两种方式？
方式一: 通过单列集合的stream()
方式二: 通过Stream.of方法 传递数组 或者 单一元素 进行获取流
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。本小节中，终结方法包括 count 和 forEach 方法。
没有遇到终结方法之前,延迟方法都是耍流氓.流在操作过程中,如果执行的是初始操作或者中间操作,那么实际上不会对流元素进行处理只有在进行Stream的终止操作的时候才执行.
4.调用concat方法有什么注意事项?
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat.这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
数组使用Stream.of方法获取的流进行拼接，返回的是泛型为String类型的流；
集合使用stream方法，不建议使用Stream.of方法,返回的流的泛型值会是集合带泛型

1.我们传统的集合操作有什么弊端？
传统的集合操作代码太过冗余，不够简洁，经常为了达到一个结果要进行多次筛选，需要进行重复循环遍历，过于浪费资源。

2.获取流有哪两种方式？
（1）使用单列集合获取Stream流使用stream（）方法；
（2）使用数组获取Stream流使用Stream.of传递一个数组或者单一元素。

3.Stream流中的方法分为哪两类，有什么区别？
（1）延迟方法：返回值的类型仍然是Stream接口自身类型的方法，因此可以继续调用其拥有的方法；
（2）终结方法：返回值的类型不是Stream接口自身类型的方法，因此不能再条用其拥有的方法。

4.调用concat方法有什么注意事项
concat方法是Stream接口中的静态方法，所以只能通过Stream接口来调用，并且其参数类型是Stream，而且返回值也是一个Stream类型。

1.我们传统的集合操作有什么弊端？
（1）代码编写繁琐
（2）没有延迟加载，系统更加耗能

2.获取流有哪两种方式？
（1）Stream 接口的静态方法 of 可以获取数组对应的流
（2）Collestion集合可以通过默认方法.stream（）获取


3.Stream流中的方法分为哪两类，有什么区别？
中间操作和终止操作
中间操作：返回值依旧是Stream类型可以继续使用其方法
终止操作：没有返回值类型所以不能再使用该Stream流


4.调用concat方法有什么注意事项
合并两个流时,两个流的数据类型要一样或着两个流的数据类型同时继承某个父类或同时实现了某个接口

1.我们传统的集合操作有什么弊端？
答：传统的集合操作主要注重于怎么做，即在对集合进行操作的时候需要多次的使用普通for循环或者增强for循环来遍历代码，代码会比较冗长。

2.获取流有哪两种方式？
答：获取流的方式有2种。
        方式一：单列集合的Stream();   类名.Stream();
        方式二：Stream.of方法 传递数组 或者单一元素 进行获取流

3.Stream流中的方法分为哪两类，有什么区别？
答：分为延迟方法和终结方法。他们之间的差别：延迟方法会返回流对象，终结方法不会返回流对象。
延迟方法包括：filter，map，limit，skip，concat等
终结方法包括：forEach，count等

4.调用concat方法有什么注意事项
答：concat方法是用来把两个流对象统一成一个流对象，注意事项是：这两个流对象必须是同一种泛型的流对象

1.我们传统的集合操作有什么弊端？
当需要对集合的元素进行操作的时候，往往需要一次次的遍历集合，造成代码的重复和编写效率的低下

2.获取流有哪两种方式？
获取流有两种方式：
（1）所有的Collection集合都可以通过stream默认方法获取流；
（2）Stream接口的静态方法of可以获取数组对应的流

3.Stream流中的方法分为哪两类，有什么区别？
Stream流的方法分为：
（1）延迟方法：返回值类型是Stream接口自身类型的方法，因此支持链式调用。
（2）终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用。

4.调用concat方法有什么注意事项
两个流可以使用 Stream 接口的静态方法 concat 合并成为一个流，但必须保证两个流的泛型是一致的

1.我们传统的集合操作有什么弊端？
答;
当我们对集合内的元素进行操作的时候，往往需要遍历集合，造成代码重复率高和编写效率的低下
2.获取流有哪两种方式？
答：
方式一：通过单列集合的stream()
方式二：通过Stream.of方法 传递数组 或者单一元素 进行获取

3.Stream流中的方法分为哪两类，有什么区别？
答：
延迟方法：返回值类型依然是Stream接口自身类型的方法，因此支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用
4.调用concat方法有什么注意事项
答：
合并流的时候要注意两个流的泛型要相同，不然编译会报错

1.我们传统的集合操作有什么弊端？
代码冗长，太注重过程，当需要对集合的元素进行操作的时候，往往需要一次次遍历集合，造成代码的重复和编写效率的低下

2.获取流有哪两种方式？
Collection 集合可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。终结方法包括 count 和 forEach 方法。

4.调用concat方法有什么注意事项
concat是一个抽象方法，通过Stream类来调用；合并的两个流必须数据类型一样

1.我们传统的集合操作有什么弊端？
答：（1）代码冗余繁琐；（2）需要创建许多集合浪费系统性能。
2.获取流有哪两种方式？
答：两种获取流的方式
方式一: 通过单列集合的stream()；
方式二: 通过Stream.of方法，传递数组或者单一元素，进行获取流；
3.Stream流中的方法分为哪两类，有什么区别？
答：延迟方法：返回值类型仍然是stream接口自身类型的方法，支持链式调用。
终结方法：返回值不再是stream接口自身类型的方法，不再支持链式调用。
4.调用concat方法有什么注意事项
答：concat方法是stream接口的静态方法，只能用类名调用；参数类型都是stream类型，返回一个新的stream类型。
合并两个流时,两个流的数据类型必须一致或两个流的数据类型同时继承某个父类或同时实现了某个接口,否则将无法使用concat方法合并两个流；

1.我们传统的集合操作有什么弊端？
传统的集合为了获取最后的结果太专注怎么做，编写起来复杂。
代码不够简洁

2.获取流有哪两种方式？
方式一：可以通过单列集合的Stream()来获取
方式二：可以通过Stream.of方法传递数组或者单一元素进行获取流

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值是Stream接口本身类型的方法，这种的支持链式调用
总终结方法：返回值不再是Stream接口本身类型的方法，这种的不支持链式调用。其中学习了的有forEach和count

4.调用concat方法有什么注意事项
调用concat方法的时候必须保证这两个流的泛型是一致的

1.我们传统的集合操作有什么弊端？
当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。另一方面，使用线性

循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。增加了代码量，

2.获取流有哪两种方式？
Collection 集合可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

3.Stream流中的方法分为哪两类，有什么区别？
    延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法

外，其余方法均为延迟方法。）
    终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那

样的链式调用。终结方法包括 count 和 forEach 方法。

4.调用concat方法有什么注意事项
concat是一个抽象方法，通过Stream类来调用；合并的两个流必须数据类型一样。

1.我们传统的集合操作有什么弊端？
（1）代码冗余，细节较繁琐；
（2）不具有并行能力；
（3）没有延迟加载，容易产生不必要的资源浪费。
2.获取流有哪两种方式？
方式一: 通过单列集合的.stream(）获取；
方式二: 通过Stream.of方法传递数组或者单一元素进行获取流。
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：对集合中的内容进行操作，返回Stream流，可以进行链式处理，处理过的流不会保存数据；
终结方法：对流中的数据进行最终的整合处理，返回的不再是流，不能再进行链式处理。
4.调用concat方法有什么注意事项
concat是将流与流拼接在一起。
如果是用Stream.of方法获取的流进行拼接，那么返回的 是泛型为String类型的流；
如果是拼接.stream方法获取到的流，那么将返回<ArrayList<String>>泛型的流。

1.我们传统的集合操作有什么弊端？
答：
        弊端：
                代码编写冗余；
                在操作过程中会经常产生一些无用的代码，会造成系统性能的降低
2.获取流有哪两种方式？
答：
        通过单列集合(collection)的Stream方法获取流；
        通过Stream接口的静态方法of获取数组或单一元素对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
答：
        中间操作：调用后返回值还是Stream对象，因此可以继续使用Stream流中的方法；
        终止操作：调用该方法后，返回值不是Stream对象，因此不能继续调用Stream流中的方法；
4.调用concat方法有什么注意事项?
答：
        注意事项：
                被组合的两个流，必须继承相同的父类或实现相同的接口，才能进行组合，否则无法组合；

1.我们传统的集合操作有什么弊端？
答：
传统的集合操作代码编写繁杂、冗长，要对集合进行操作，需要不断地创建集合、对集合进行遍历，从而是我们不得不适用for循环来遍历，造成代码重复度太高。
而我们今天所学的Stream流，代码编写简洁，Stream流具有并行的能力，可以利用流的延迟加载特性，提升代码性能。

2.获取流有哪两种方式？
答：
方式一：通过单列集合调用stream()方法，获取stream流
方式二：通过Stream类中的of方法，传递数组或着单一元素获取stream流

3.Stream流中的方法分为哪两类，有什么区别？
答：
延迟方法：当我们调用延迟的方法，返回的是一个Stream流对象，所以可以进行链式编程
终止方法：返回值不再是Stream类型，当我们调用了终止方法，就不能再调用延迟方法。

4.调用concat方法有什么注意事项
答：
concat能将两个流合并成一个流，是个静态方法，可以使用类名调用，建议参数传递的时候数据类型相同，不推荐不同的类型数据参数传递

1.我们传统的集合操作有什么弊端？
答：
        弊端：
                代码编写冗余；
                会造成系统性能的降低
                不支持并行
2.获取流有哪两种方式？
答：
        通过单列集合(collection)的Stream方法获取流；
        通过Stream接口的静态方法of获取数组或单一元素对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
答：
        中间操作：调用后返回值还是Stream对象，因此可以继续使用Stream流中的方法；
        终止操作：调用该方法后，返回值不是Stream对象，因此不能继续调用Stream流中的方法；
4.调用concat方法有什么注意事项?
答：
        注意事项：
                被组合的两个流，必须继承相同的父类或实现相同的接口，才能进行组合，否则无法组合；

1.我们传统的集合操作有什么弊端？
当需要对集合的元素进行操作的时候，往往需要一次次遍历集合，造成代码的重复和编写效率的低下。

2.获取流有哪两种方式？
所有Collection接口的实现类都可以调用stream()方法来获取流；
Map接口下的实现类可以将key、value或者entry先转换成集合，然后再获取流；
集合可以通过Stream类的静态方法of()获取流。

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用；
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不支持链式调用。

4.调用concat方法有什么注意事项
concat()方法是Stream接口的静态方法，因此要通过Stream接口来调用，参数类型为两个Stream类型 ，返回值类型也是一个Stream类型。

李伟斌

1.我们传统的集合操作有什么弊端？
答：遍历时需要使用for循环进行遍历，相对Steam流的foeEach方法代码繁琐，浪费性能。
2.获取流有哪两种方式？
答：a.对象.Stream()；
       b.Stream.of();
3.Stream流中的方法分为哪两类，有什么区别？
答：延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。终结方法包括 count 和 forEach 方法。
4.调用concat方法有什么注意事项?
答：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
       合并流的时候要注意两个流的泛型要相同，不然编译会报错。

叶凌青

1.我们传统的集合操作有什么弊端？每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。 这样就增加了代码量，并浪费了资源。
2.获取流有哪两种方式？
Collection 集合可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。终结方法包括 count 和 forEach 方法。
4.调用concat方法有什么注意事项
concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

1.我们传统的集合操作有什么弊端？
传统集合需要多步遍历代码:几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。
循环遍历的弊端:专注于这么做，而不是做什么.for循环的语法就是“怎么做”;for循环的循环体才是“做什么".
程序员需要装逼,需要更加文雅的写法.
2.获取流有哪两种方式？
方式一: 通过单列集合的stream()
方式二: 通过Stream.of方法 传递数组 或者 单一元素 进行获取流
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。本小节中，终结方法包括 count 和 forEach 方法。
没有遇到终结方法之前,延迟方法都是耍流氓.流在操作过程中,如果执行的是初始操作或者中间操作,那么实际上不会对流元素进行处理只有在进行Stream的终止操作的时候才执行.
4.调用concat方法有什么注意事项?
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat.这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
数组使用Stream.of方法获取的流进行拼接，返回的是泛型为String类型的流；
集合使用stream方法，不建议使用Stream.of方法,返回的流的泛型值会是集合带泛型