黑马程序员技术交流社区

标题: 【厦门校区JavaEE就业6期-每日总结】Stream流 [打印本页]
作者: 厦门校区    时间: 2019-4-6 14:09
标题: 【厦门校区JavaEE就业6期-每日总结】Stream流
1.我们传统的集合操作有什么弊端？
2.获取流有哪两种方式？
3.Stream流中的方法分为哪两类，有什么区别？
4.调用concat方法有什么注意事项?
作者: 陈伟彬    时间: 2019-4-6 18:55
1.我们传统的集合操作有什么弊端？
答：
        弊端：
                代码编写冗余；
                在操作过程中会经常产生一些无用的代码，会造成系统性能的降低
2.获取流有哪两种方式？
答：
        通过单列集合(collection)的Stream方法获取流；
        通过Stream接口的静态方法of获取数组或单一元素对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
答：
        中间操作：调用后返回值还是Stream对象，因此可以继续使用Stream流中的方法；
        终止操作：调用该方法后，返回值不是Stream对象，因此不能继续调用Stream流中的方法；
4.调用concat方法有什么注意事项?
答：
        注意事项：
                被组合的两个流，必须继承相同的父类或实现相同的接口，才能进行组合，否则无法组合；
作者: 黑马6期陈华    时间: 2019-4-6 19:11
1.我们传统的集合操作有什么弊端？
（1）代码冗余，细节较繁琐；
（2）不具有并行能力；
（3）没有延迟加载，容易产生不必要的资源浪费。
2.获取流有哪两种方式？
方式一: 通过单列集合的.stream(）获取；
方式二: 通过Stream.of方法传递数组或者单一元素进行获取流。
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：对集合中的内容进行操作，返回Stream流，可以进行链式处理，处理过的流不会保存数据；
终结方法：对流中的数据进行最终的整合处理，返回的不再是流，不能再进行链式处理。
4.调用concat方法有什么注意事项
concat是将流与流拼接在一起。
如果是用Stream.of方法获取的流进行拼接，那么返回的 是泛型为String类型的流；
如果是拼接.stream方法获取到的流，那么将返回<ArrayList<String>>泛型的流。
作者: 陈志铖    时间: 2019-4-6 19:38
本帖最后由 陈志铖 于 2019-4-7 14:39 编辑

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方法,返回的流的泛型值会是集合带泛型
作者: 罗加铭    时间: 2019-4-6 20:29
1.我们传统的集合操作有什么弊端？
答：编写比较繁琐，注重于做什么，跟流相比没有延迟加载特性，不能提升代码性能

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

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

4.调用concat方法有什么注意事项
答：他是终结方法，不再支持链式调用。
作者: 余建强    时间: 2019-4-6 20:50

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

两个流可以使用 Stream 接口的静态方法 concat 合并成为一个流，但必须保证两个流的泛型是一致的
作者: 庄家琦    时间: 2019-4-6 20:51
1.我们传统的集合操作有什么弊端？
代码繁琐
效率低→集合有要更改底层会不停地创建集合
集合并不能并行

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

3.Stream流中的方法分为哪两类，有什么区别？
中间操作方法 中间方法流还存在并没有结束刻意继续执行流的后续步骤
终止操作方法 终止方法执行后 流就关闭了 不能再执行该流的其他方法了

4.调用concat方法有什么注意事项
Stream中的静态方法concat是将两个流合并成为一个流.这两个流的数据类型需要一致
作者: 黑马六期-董安平    时间: 2019-4-6 21:05
1.我们传统的集合操作有什么弊端？
答;
当我们对集合内的元素进行操作的时候，往往需要遍历集合，造成代码重复率高和编写效率的低下
2.获取流有哪两种方式？
答：
方式一：通过单列集合的stream()
方式二：通过Stream.of方法 传递数组 或者单一元素 进行获取

3.Stream流中的方法分为哪两类，有什么区别？
答：
延迟方法：返回值类型依然是Stream接口自身类型的方法，因此支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用
4.调用concat方法有什么注意事项
答：
合并流的时候要注意两个流的泛型要相同，不然编译会报错
作者: 黄杰南    时间: 2019-4-6 21:10
1.我们传统的集合操作有什么弊端？
每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。

循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次

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

浪费了资源。

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

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

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

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

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

流的泛型是一致的
作者: 徐代成    时间: 2019-4-6 21:10
1.我们传统的集合操作有什么弊端？

1.传统的集合操作注重的是怎么做而忽略了做什么，我们对集合进行增删改查的时候，都要去遍历集合，使得代码不够简洁，出现代码重复度高等问题

2.获取流有哪两种方式？

所有的单列集合我们都可以通过对象名.stream来获取流对象，双列集合可以通过键值对或者entry等方式获取流对象
数组或者单一元素可以通过Stream接口提供的静态方法of来获取流对象

3.Stream流中的方法分为哪两类，有什么区别？

延迟方法和终结方法；
延迟方法：返回值类型还是Stream对象，这类方法不会关闭流通道，可以一直调用延迟方法
终结方法：返回值类型不是Stream对象，调用终结方法后流通道会关闭，比能在调用该对象了

4.调用concat方法有什么注意事项

Stream中的concat方法是一种静态方法，与 java.lang.String 当中的 concat 方法是不同的，该方法的数据类型必须相同
作者: zhaizhile    时间: 2019-4-6 21:13
1.我们传统的集合操作有什么弊端？
代码冗余，细节较繁琐;
没有延迟加载，可能产生不必要的资源浪费

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

3.Stream流中的方法分为哪两类，有什么区别？

延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）

终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法


4.调用concat方法有什么注意事项
两个流可以使用 Stream 接口的静态方法 concat 合并成为一个流，但必须保证两个流的泛型是一致的
作者: 郑海波    时间: 2019-4-6 21:16
1.我们传统的集合操作有什么弊端？
1.代码冗长
2.对集合元素进行不同操作，需要对数组进行反复遍历
3.不能延迟执行

2.获取流有哪两种方式？
方法一：通过单列集合的Stream()获取流（把数组转成流）
方法二：通过Stream.of对单一元素或者数组获取流

3.Stream流中的方法分为哪两类，有什么区别？
中间操作：调用之后有返回值，返回值是一个新的流
终止操作：调用该方法后返回值不是新的流，是一个最终执行结果

4.调用concat方法有什么注意事项?
必须是实现相同接口或者父类的数据类型才能合并
作者: javawjs    时间: 2019-4-6 21:16
王佳盛
1.        我们传统的集合操作有什么弊端？
代码冗余；不支持并行；

2.        获取流有哪两种方式？
第一种：调用Collection接口的默认方法stream()
第二种：调用Stream接口的静态方法Stream.of() （用于数组）

3.        Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型是Stream流，并且在执行期间实际上不会对流中元素进行操作，只有执行到终止方法才会对流元素进行操作。
终止方法：返回值不是Stream流的方法就是终止方法。

4.        调用concat方法有什么注意事项
必须保证concat方法连接的两个Stream流的泛型是一致的
作者: 高坂火龙果    时间: 2019-4-6 21:17
黄志斌：
1.我们传统的集合操作有什么弊端？
答：传统的集合操作主要注重于怎么做，即在对集合进行操作的时候需要多次的使用普通for循环或者增强for循环来遍历代码，代码会比较冗长。

2.获取流有哪两种方式？
答：获取流的方式有2种。
第一种为：对于collection集合使用，collection.stream（）,可以获得该集合的流对象。
第二种为：直接通过Stream类的静态方法of()，在of()里面传入数组会返回一个stream类的对象。

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

4.调用concat方法有什么注意事项
答：concat方法是用来把两个流对象统一成一个流对象，注意事项是：这两个流对象必须是同一种泛型的流对象。
作者: 管文祥    时间: 2019-4-6 21:18
1.我们传统的集合操作有什么弊端？
答：每当需要对集合和数组进行操作的时候，总是需要进行循环、循环、再循环。循环是一种方式，却不是目的。并且线性循环只能遍历一次。如果希望再次遍历，只能再次使用另一个循环从新开始。
2.获取流有哪两种方式？
答：1.通过单列集合的stream（）
2.通过Stream.of方法传递数组或者单列集合
3.Stream流中的方法分为哪两类，有什么区别？
答：延迟方法和终结方法
延迟方法返回值类型仍是Stream接口自身类型的方法，支持链式调用：filter、limit、skip、concat
终结方法返回值类型不再是Stream接口自身类型的方法，不支持链式调用，count和forEach
4.调用concat方法有什么注意事项
答：concat是一个静态方法，通过类名Stream调用，如果有两个流要合并，要求两个流的数据类型要一致。
作者: 陈前凌    时间: 2019-4-6 21:18
1.我们传统的集合操作有什么弊端？
代码冗长，太注重过程，当需要对集合的元素进行操作的时候，往往需要一次次遍历集合，造成代码的重复和编写效率的低下

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

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

4.调用concat方法有什么注意事项
concat是一个抽象方法，通过Stream类来调用；合并的两个流必须数据类型一样
作者: 开心的小孩    时间: 2019-4-6 21:21
1.我们传统的集合操作有什么弊端？

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

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型依然是Stream接口自身类型的方法，因此支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用
4.调用concat方法有什么注意事项
合并流的时候要注意两个流的泛型要相同，不然编译会报错
作者: 陈驰煜    时间: 2019-4-6 21:21
1.我们传统的集合操作有什么弊端？
对传统集合内的元素操作时,必须要用循环或者迭代器遍历其元素,然而循环或者迭代器有时并不是我们需要的,但不得不做,导致代码冗余,同时造成性能浪费.

2.获取流有哪两种方式？
集合获取流: 直接调用集合的stream()方法获取流;
数组获取流: 使用Stream.of()方法传入数组,获取流

3.Stream流中的方法分为哪两类，有什么区别？
分为中间方法和终止方法;
中间方法如filter()、map()等,其的返回值仍然是Stream流对象,可以通过链式调用继续对流进行操作;
终止方法如forEach()、count()等, 其返回值不是Stream流对象,不能再使用链式调用继续对流进行操作

4.调用concat方法有什么注意事项
合并两个流时,两个流的数据类型必须一致或两个流的数据类型同时继承某个父类或同时实现了某个接口,否则将无法使用concat方法合并两个流
作者: 开心的小孩    时间: 2019-4-6 21:22
陈鹏涛
1.我们传统的集合操作有什么弊端？

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

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型依然是Stream接口自身类型的方法，因此支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用
4.调用concat方法有什么注意事项
合并流的时候要注意两个流的泛型要相同，不然编译会报错
作者: 卢勇炜    时间: 2019-4-6 21:24
1.我们传统的集合操作有什么弊端？
答：代码冗长；对集合元素进行不同操作，要一致数组进行遍历；用Stream流可以延迟执行

2.获取流有哪两种方式？
答:（1）对于collection集合使用，collection.stream（）,可以获得该集合的流对象。
    （2）直接通过Stream类的静态方法of()，在of()里面传入数组会返回一个stream类的对象

3.Stream流中的方法分为哪两类，有什么区别？
答:延迟方法：返回值类型是Stream流，并且在执行期间实际上不会对流中元素进行操作，只有执行到终止方法才会对流元素进行操作。
终止方法：返回值不是Stream流的方法就是终止方法

4.调用concat方法有什么注意事项?
答：被合并的两个流的数据类型要一致；
作者: LIUXIAOMING    时间: 2019-4-6 21:25

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方法,返回的流的泛型值会是集合带泛型
作者: 厦门第六期刘鹏    时间: 2019-4-6 21:27
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方法,返回的流的泛型值会是集合带泛型
作者: 厦门第六期刘鹏    时间: 2019-4-6 21:28
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方法,返回的流的泛型值会是集合带泛型
作者: 林艺彬    时间: 2019-4-6 21:29
1.我们传统的集合操作有什么弊端？
传统的集合操作代码太过冗余，不够简洁，经常为了达到一个结果要进行多次筛选，需要进行重复循环遍历，过于浪费资源。

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

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

4.调用concat方法有什么注意事项
concat方法是Stream接口中的静态方法，所以只能通过Stream接口来调用，并且其参数类型是Stream，而且返回值也是一个Stream类型。
作者: 刘曾铭    时间: 2019-4-6 21:29
1.我们传统的集合操作有什么弊端？
（1）代码编写繁琐
（2）没有延迟加载，系统更加耗能

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


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


4.调用concat方法有什么注意事项
合并两个流时,两个流的数据类型要一样或着两个流的数据类型同时继承某个父类或同时实现了某个接口
作者: 蓝建华    时间: 2019-4-6 21:36
1.我们传统的集合操作有什么弊端？
答：传统的集合操作主要注重于怎么做，即在对集合进行操作的时候需要多次的使用普通for循环或者增强for循环来遍历代码，代码会比较冗长。

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

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

4.调用concat方法有什么注意事项
答：concat方法是用来把两个流对象统一成一个流对象，注意事项是：这两个流对象必须是同一种泛型的流对象
作者: 黄成龙    时间: 2019-4-6 21:39
1.我们传统的集合操作有什么弊端？
当需要对集合的元素进行操作的时候，往往需要一次次的遍历集合，造成代码的重复和编写效率的低下

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

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

4.调用concat方法有什么注意事项
两个流可以使用 Stream 接口的静态方法 concat 合并成为一个流，但必须保证两个流的泛型是一致的
作者: 陈弘帅    时间: 2019-4-6 21:39

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

3.Stream流中的方法分为哪两类，有什么区别？
答：
延迟方法：返回值类型依然是Stream接口自身类型的方法，因此支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用
4.调用concat方法有什么注意事项
答：
合并流的时候要注意两个流的泛型要相同，不然编译会报错
作者: 龙舟    时间: 2019-4-6 21:40
1.我们传统的集合操作有什么弊端？
代码冗长，太注重过程，当需要对集合的元素进行操作的时候，往往需要一次次遍历集合，造成代码的重复和编写效率的低下

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

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

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

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

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

4.调用concat方法有什么注意事项
调用concat方法的时候必须保证这两个流的泛型是一致的
作者: 王旭艺    时间: 2019-4-6 21:43
1.我们传统的集合操作有什么弊端？
当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。另一方面，使用线性

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

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

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

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

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

4.调用concat方法有什么注意事项
concat是一个抽象方法，通过Stream类来调用；合并的两个流必须数据类型一样。
作者: 陈鉴    时间: 2019-4-6 21:43
1.我们传统的集合操作有什么弊端？
（1）代码冗余，细节较繁琐；
（2）不具有并行能力；
（3）没有延迟加载，容易产生不必要的资源浪费。
2.获取流有哪两种方式？
方式一: 通过单列集合的.stream(）获取；
方式二: 通过Stream.of方法传递数组或者单一元素进行获取流。
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：对集合中的内容进行操作，返回Stream流，可以进行链式处理，处理过的流不会保存数据；
终结方法：对流中的数据进行最终的整合处理，返回的不再是流，不能再进行链式处理。
4.调用concat方法有什么注意事项
concat是将流与流拼接在一起。
如果是用Stream.of方法获取的流进行拼接，那么返回的 是泛型为String类型的流；
如果是拼接.stream方法获取到的流，那么将返回<ArrayList<String>>泛型的流。
作者: 李煜霖    时间: 2019-4-6 21:45
1.我们传统的集合操作有什么弊端？
答：
        弊端：
                代码编写冗余；
                在操作过程中会经常产生一些无用的代码，会造成系统性能的降低
2.获取流有哪两种方式？
答：
        通过单列集合(collection)的Stream方法获取流；
        通过Stream接口的静态方法of获取数组或单一元素对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
答：
        中间操作：调用后返回值还是Stream对象，因此可以继续使用Stream流中的方法；
        终止操作：调用该方法后，返回值不是Stream对象，因此不能继续调用Stream流中的方法；
4.调用concat方法有什么注意事项?
答：
        注意事项：
                被组合的两个流，必须继承相同的父类或实现相同的接口，才能进行组合，否则无法组合；
作者: 黄振明    时间: 2019-4-6 21:47
1.我们传统的集合操作有什么弊端？
答：
传统的集合操作代码编写繁杂、冗长，要对集合进行操作，需要不断地创建集合、对集合进行遍历，从而是我们不得不适用for循环来遍历，造成代码重复度太高。
而我们今天所学的Stream流，代码编写简洁，Stream流具有并行的能力，可以利用流的延迟加载特性，提升代码性能。

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

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

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

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

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

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

4.调用concat方法有什么注意事项
concat()方法是Stream接口的静态方法，因此要通过Stream接口来调用，参数类型为两个Stream类型 ，返回值类型也是一个Stream类型。
作者: omasoo    时间: 2019-4-6 21:50
李伟斌

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

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

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法和终结方法，
(1)延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。
(2)终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。终结方法包括 count 和 forEach 方法。
4.调用concat方法有什么注意事项
合并两个流时,两个流的数据类型必须一致或两个流的数据类型同时继承某个父类或同时实现了某个接口
作者: Wyt1935    时间: 2019-4-6 21:53

吴元陶

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

3.Stream流中的方法分为哪两类，有什么区别？
答：
延迟方法：返回值类型依然是Stream接口自身类型的方法，因此支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不支持链式调用
4.调用concat方法有什么注意事项
答：
合并流的时候要注意两个流的泛型要相同，不然编译会报错
作者: chenopen    时间: 2019-4-6 21:58
陈开明：
1.我们传统的集合操作有什么弊端？
弊端：代码编写冗余，不具有并行功能，没有延迟加载能力。
2.获取流有哪两种方式？
一种是直接调用stream()方法，一种是调用Stream.of()方法。
3.Stream流中的方法分为哪两类，有什么区别？
分为中间方法和终止方法。
中间方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。
终止方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。
4.调用concat方法有什么注意事项
两个将要合并的流的泛型最好是一致的。
作者: 李伟艺    时间: 2019-4-6 21:58

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方法,返回的流的泛型值会是集合带泛型
作者: 卢春旭    时间: 2019-4-6 21:58
1.我们传统的集合操作有什么弊端？
传统的集合：如果我们要对集合的元素进行操作的时候，需要对集合进行循环遍历再进行操作且还要再创建一个集合容器去存储操作后的元素，过程太过繁琐，代码臃肿，阅读性差。
2.获取流有哪两种方式？
(1)可以通过collection集合或该集合下的子类都可以通过stream默认方法获取stream流
(2)可以以 Stream 接口中提供了静态方法
of（）中传入数组和参数（参数类型要一致）获取stream流对象
3.Stream流中的方法分为哪两类，有什么区别？
Stream流中的方法分为:
(1)延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用
(2)终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持链式调用
4.调用concat方法有什么注意事项
调用concat方法要注意：concat是静态方法,可以通过Stream类名直接调用，且该方法的参数中传递的两个stream流的泛型类型要一致
作者: 唐彬桂    时间: 2019-4-6 21:58
1.我们传统的集合操作有什么弊端？
1代码冗余，细节较繁琐；
2不具有并行能力；
3没有延迟加载，容易产生不必要的资源浪费。
2.获取流有哪两种方式？
集合变量名.stream()
stream.of(数组变量名或者单一元素)

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

4.调用concat方法有什么注意事项
注意事项：被组合的两个流，必须继承相同的父类或实现相同的接口，才能进行组合，否则无法组合
作者: 廖艺铭    时间: 2019-4-6 21:58
1.我们传统的集合操作有什么弊端？
弊端：
每当我们需要对集合中的元素进行操作的时候，使用线性循环就意味着只能遍历一次，如果希望再次遍历，只能再使用另一个循环从头开始，某种程度上造成代码冗余

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

3.Stream流中的方法分为哪两类，有什么区别？
①延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用，包括有filter、map、limit、skip、concat
②终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用，包括有count、forEach

4.调用concat方法有什么注意事项
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
①concat是静态方法
②返回的结果是将第二个参数的流拼接在第一个参数的流后边
作者: 林奕全    时间: 2019-4-6 21:59
1.我们传统的集合操作有什么弊端？

传统的集合操作,需要得到一个结果,中间的过程比较繁杂,代码冗余度过高.

2.获取流有哪两种方式？

1)通过Collection中加入的default方法来调用Stream()方法获取流,它的所有实现类都可以通过此方法获取流;

2)数组获取流, 通过Stream里的of()方法将数组作为参数传递,来获取流

3.Stream流中的方法分为哪两类，有什么区别？

1)延迟方法:返回值类型仍然是Stream接口本身的类型,支持链式编程 属于延迟方法的有filter,limit,skip,concat

2)终结方法:返回值类型不再是Stream接口自身的类型,不支持链式编程 属于终结方法的有forEach,count

4.调用concat方法有什么注意事项

Concat方法是将两个流组合并在一起, 使用的时候尽量相同泛型的流进行合并.
作者: JavaEE06蒋才东    时间: 2019-4-6 22:00
1.我们传统的集合操作有什么弊端？
（1）代码冗余，细节较繁琐；
（2）不具有并行能力；
（3）没有延迟加载，容易产生不必要的资源浪费。

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

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

4.调用concat方法有什么注意事项
concat是一个静态方法，通过类名Stream调用，如果有两个流要合并，要求两个流的数据类型要一致。
作者: 吴越    时间: 2019-4-6 22:00
1.我们传统的集合操作有什么弊端？
答：传统集合操作的弊端：
①强调格式和过分关注【怎么做】，代码冗余
②会产生过多的循环遍历，步骤繁琐
③没有延迟加载，可能产生资源浪费

2.获取流有哪两种方式？
答：①单列集合中，Collecion接口中加入了stream方法用于获取流
Stream<String> collectionStream = c.stream();
②数组中，可以通过Stream接口中提供的静态方法of获取流
Stream<String> arrStream = Stream.of(arr);

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

4.调用concat方法有什么注意事项
答：①Stream中的concat方法是静态方法，用于把两个流合并成一个。
②参数列表中参数的顺序就是合成后的流中元素的顺序。
③参与合成的流泛型的类型必须是合成后的流泛型类型或其子类。
作者: 沈松宏    时间: 2019-4-6 22:49
1.我们传统的集合操作有什么弊端？
①强调格式和过分关注【怎么做】，代码冗余
②会产生过多的循环遍历，步骤繁琐
③没有延迟加载，可能产生资源浪费

2.获取流有哪两种方式？
①单列集合中，Collecion接口中加入了stream方法用于获取流
Stream<String> collectionStream = c.stream();
②数组中，可以通过Stream接口中提供的静态方法of获取流
Stream<String> arrStream = Stream.of(arr);
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法；返回值类型仍然是 Stream 接口自身类型的方法，因此支持

链式调用
终结方法返回值类型不再是 Stream 接口自身类型的方法，因此不再支

持类似 StringBuilder 那样的链式调用
4.调用concat方法有什么注意事项
concat是一个静态方法，通过类名Stream调用，如果有两个流要合并，

要求两个流的数据类型要一致
作者: 叶彬彬    时间: 2019-4-7 09:00
1.我们传统的集合操作有什么弊端？
当我们想要对集合中的元素进行筛选时，就要遍历一次集合，如果要进行多个条件筛选，就要进行多次遍历，导致代码冗余度过高

2.获取流有哪两种方式？
所有的单列集合都可以通过stream默认方法获取流
数组通过接口Stream静态方法of获取流

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值也是一个Stream流，可以支持链式调用
终结方法：返回值不是Stream流，不支持链式调用

4.调用concat方法有什么注意事项
concat方法用于将两个流合并成一个流，是Stream接口中的静态方法
作者: 龚荣章    时间: 2019-4-7 09:04
1.我们传统的集合操作有什么弊端？
答：
        弊端：
                代码编写冗余；
                在操作过程中会经常产生一些无用的代码，会造成系统性能的降低
2.获取流有哪两种方式？
答：
        通过单列集合(collection)的Stream方法获取流；
        通过Stream接口的静态方法of获取数组或单一元素对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
答：
        中间操作：调用后返回值还是Stream对象，因此可以继续使用Stream流中的方法；
        终止操作：调用该方法后，返回值不是Stream对象，因此不能继续调用Stream流中的方法；
4.调用concat方法有什么注意事项?
答：
        注意事项：
                被组合的两个流，必须继承相同的父类或实现相同的接口，才能进行组合，否则无法组合；
作者: 张广发    时间: 2019-4-8 09:16
1.我们传统的集合操作有什么弊端？
（1）代码冗余，细节较繁琐；
（2）不具有并行能力；
（3）没有延迟加载，容易产生不必要的资源浪费。
2.获取流有哪两种方式？
方式一: 通过单列集合的.stream(）获取；
方式二: 通过Stream.of方法传递数组或者单一元素进行获取流。
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：对集合中的内容进行操作，返回Stream流，可以进行链式处理，处理过的流不会保存数据；
终结方法：对流中的数据进行最终的整合处理，返回的不再是流，不能再进行链式处理。
4.调用concat方法有什么注意事项
concat是将流与流拼接在一起。
如果是用Stream.of方法获取的流进行拼接，那么返回的 是泛型为String类型的流；
如果是拼接.stream方法获取到的流，那么将返回<ArrayList<String>>泛型的流。
作者: 魏政    时间: 2019-4-9 21:40
1.我们传统的集合操作有什么弊端？

对传统集合内的元素操作时,必须要用循环或者迭代器遍历其元素,然而循环或者迭代器有时并不是我们需要的,但不得不做,导致代码冗余,同时造成性能浪费.

2.获取流有哪两种方式？

集合获取流: 直接调用集合的stream()方法获取流;
数组获取流: 使用Stream.of()方法传入数组,获取流

3.Stream流中的方法分为哪两类，有什么区别？

分为中间方法和终止方法;
中间方法如filter()、map()等,其的返回值仍然是Stream流对象,可以通过链式调用继续对流进行操作;
终止方法如forEach()、count()等, 其返回值不是Stream流对象,不能再使用链式调用继续对流进行操作

4.调用concat方法有什么注意事项

合并两个流时,两个流的数据类型必须一致或两个流的数据类型同时继承某个父类或同时实现了某个接口,否则将无法使用concat方法合并两个流

作者: 钟扬辉    时间: 2019-4-11 21:10

1.我们传统的集合操作有什么弊端？
弊端：
每当我们需要对集合中的元素进行操作的时候，使用线性循环就意味着只能遍历一次，如果希望再次遍历，只能再使用另一个循环从头开始，某种程度上造成代码冗余

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

3.Stream流中的方法分为哪两类，有什么区别？
①延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用，包括有filter、map、limit、skip、concat
②终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用，包括有count、forEach

4.调用concat方法有什么注意事项
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
①concat是静态方法
②返回的结果是将第二个参数的流拼接在第一个参数的流后边
作者: 开心的小孩    时间: 2019-4-11 21:11
陈鹏涛
1.我们传统的集合操作有什么弊端？
（1）代码冗余，细节较繁琐；
（2）不具有并行能力；
（3）没有延迟加载，容易产生不必要的资源浪费。
2.获取流有哪两种方式？
方式一: 通过单列集合的.stream(）获取；
方式二: 通过Stream.of方法传递数组或者单一元素进行获取流。
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：对集合中的内容进行操作，返回Stream流，可以进行链式处理，处理过的流不会保存数据；
终结方法：对流中的数据进行最终的整合处理，返回的不再是流，不能再进行链式处理。
4.调用concat方法有什么注意事项
concat是将流与流拼接在一起。
如果是用Stream.of方法获取的流进行拼接，那么返回的 是泛型为String类型的流；
如果是拼接.stream方法获取到的流，那么将返回<ArrayList<String>>泛型的流。
作者: 卢勇炜    时间: 2019-4-11 21:19
1.我们传统的集合操作有什么弊端？
1.代码冗长
2.对集合元素进行不同操作，需要对数组进行反复遍历
3.不能延迟执行

2.获取流有哪两种方式？
方法一：通过单列集合的Stream()获取流（把数组转成流）
方法二：通过Stream.of对单一元素或者数组获取流

3.Stream流中的方法分为哪两类，有什么区别？
中间操作：调用之后有返回值，返回值是一个新的流
终止操作：调用该方法后返回值不是新的流，是一个最终执行结果

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2