黑马程序员技术交流社区

标题: 【厦门校区JavaEE就业5期-每日总结】Stream流 [打印本页]

作者: 厦门校区 时间: 2019-1-6 18:38
标题: 【厦门校区JavaEE就业5期-每日总结】Stream流
1.我们传统的集合操作有什么弊端？
2.获取流有哪两种方式？
3.Stream流中的方法分为哪两类，有什么区别？
4.调用concat方法有什么注意事项

作者: 陈彬 时间: 2019-1-6 20:05

1.我们传统的集合操作有什么弊端？
传统集合中我们要使用集合做各种操作都需要使用循环来遍历集合,然后才能进行下一步的操作.这样就使得了代码特别的臃肿.
2.获取流有哪两种方式？
   1.Collection接口中加入了一个默认的default方法stream用来获取流,所以其所有的实现类均可以直接获取流.map需要使用keySet,values,entrySet等方法,转换成单列集合,才能获取流
   2.Stream接口中有个静态的方法of可以获取对应的流,of中可以传入可变参数.
3.Stream流中的方法分为哪两类，有什么区别？
   1.延迟方法,返回值仍然是Stream接口自身类型的方法,所以可以使用链式调用.
      2.终结方法,,返回值不是Stream接口自身类型的方法,所以因此不能使用链式调用.
4.调用concat方法有什么注意事项
   两个拼接的Stream流的数据类型必须完全相同,即使是子父类关系也不行.

作者: lj478360767 时间: 2019-1-6 20:07
1.我们传统的集合操作有什么弊端？
传统集合的每次遍历循环过于繁琐,如果我们要对一个集合实现不同的遍历操作,就需要多次的从头到尾遍历整个集合,大大降低了程序的效率.

2.获取流有哪两种方式？
第一种,所有Collection下的集合都可以通过.stream的方法获取到Stream流的对象;
第二种,Stream有一个静态方法of,将数组作为参数能够获取到数组对应的流对象;

3.Stream流中的方法分为哪两类，有什么区别？
分为延迟方法和终结方法,两者的区别在于返回值的不同:
延迟方法的返回值还是流对象,能够再次调用Stream中的方法,能够实现链接编程;
终结方法Foreach和count的返回值对象不是流对象,所以执行到这里语句就结束了.

4.调用concat方法有什么注意事项
concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

作者: 陈辉阳 时间: 2019-1-6 20:32
Stream流中方法

所有collection集合 list 还是set都可以通过.stream创建流容器，hashmap可以间接通过keyset方法，和entry 方法，保存键，和键值对到set集合中，然后.stream ，然后就可以使用stream中的方法了

延迟方法：返回的还是一个stream流对象，就可以以再次调用流中的方法，依赖于lembda的延迟特性，所以单独调用延迟方法，并不是对流中的的内容进行操作，而是建立一个模型，等到终结方法时候，一起逐一操作，避免性能浪费

终结方法（内部采用内部迭代遍历）1  count 统计个数

     2  forEach 逐一操作（里面传递一个消费型接口Consumer，这接口有个accept 方法）

返回的不是流对象，所以不能再继续调用stream流中的方法了

方法的引用前提

对象已经存在

方法已经已经存在

方法引用符：：

格式

system.out：：println（）

等效于（s）->{system.out.println}

stream的方法

1 forEach  逐一处理，它的参数是一个consumer接口，consumer是消费型接口，accept方法

2filter 方法过滤它的参数是一个predicate接口，这是一个判断选择的接口，这个接口是对一个数据类型进行判断，返回一个布尔值，

若条件为true 保留数据，若为false 过滤掉数据

3 map方法这是一个映射方法，给一个数据类型，转换为其他的数据类型，map方法的参数是一个Function接口，

function接口中的将string转化为Integer

Integer。Intrger. parseInt（str）

4 count 统计个数

5  limit（）只取前几个

6  skip（）前几个不要，

7  concat  连接俩个stream流格式

Stream.concat(stream1,stream2)

作者: 周章强 时间: 2019-1-6 20:34
1.我们传统的集合操作有什么弊端？

弊端：为了达成目的需要的步骤太过重复，繁琐。需要大量遍历集合。

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

集合：单列collection有默认方法stream,双列Map需要分key、value和entry等不同情况。
数组：stream接口提供静态方法，stream.of（）。

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值是stream接口本身类型，可以链式调用。
终结方法：返回值不是stream接口本身类型，不可链式调用。

4.调用concat方法有什么注意事项
concat是静态方法,与String中的concat方法不同,
方法中传递的对象的数据类型必须相同,子父类的关系也不行。

作者: 吴少华 时间: 2019-1-6 20:38
1.我们传统的集合操作有什么弊端？
遍历代码太繁琐，代码量大，不一定要传统集合遍历的过程，我们只要结果
2.获取流有哪两种方式？
集合可以通过Stream的方法获取到Stream流的对象;
Stream of 方法获取对象
3.Stream流中的方法分为哪两类，有什么区别？
分为延迟方法和终结方法，延迟方法之后还能链式用延迟方法和终结方法，终结方法之后就不能链式用方法
4.调用concat方法有什么注意事项
concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

作者: 李灵杰 时间: 2019-1-6 20:38

1.我们传统的集合操作有什么弊端？
太过繁琐,需要不断创建业务需要的集合
2.获取流有哪两种方式？
Stream有一个静态方法of,将数组作为参数能够获取到数组对应的流对象;

所有Collection下的集合都可以通过.stream的方法获取到Stream流的对象;
3.Stream流中的方法分为哪两类，有什么区别？
分为延迟方法和终结方法,两者的区别在于返回值的不同:
延迟方法可以使用链式编程
终结方法不行,Foreach和count的返回值对象不是流对象
4.调用concat方法有什么注意事项
concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

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

两个流可以使用 Stream 接口的静态方法 concat 合并成为一个流，但必须保证两个流的泛型是一致的

作者: 陈佳鹏 时间: 2019-1-6 20:41
1.对集合进行增删改查都需要先遍历，程序繁琐。
2.stream.of（）和Collection下的集合可以通过.stream方法获得。
3.分为延迟方法和终结方法，延迟方法返回一个新的流对象，可以继续调用流方法，终结方法返回的不是流对象，不能继续调用流方法。
4.为静态方法，方法中对象的泛型必须一致，继承关系也不行

作者: Chidori 时间: 2019-1-6 20:42

1.我们传统的集合操作有什么弊端？
传统集合中，筛选、打印求个数统统都要遍历集合，而我们的目的是想筛选想要的元素，遍历集合不是我们想要的
2.获取流有哪两种方式？
所有的单列集合都可以通过。stream方法获得Stream流对象
Stream流可以通过stream.of添加元素
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回的还是Steam流对象，返回的对象就可以再次调用stream流中的方法，所以单独调用延迟方法并不会对流中的方法进行操作，只有当调用终结方法以后才会运行流中的方法，这样不会造成资源的浪费
终结方法：返回的不是stream流对象，所以不能再继续调用stream流中的方法
4.调用concat方法有什么注意事项
传递的两个泛型要一致

作者: 续扬 时间: 2019-1-6 20:44
1.我们传统的集合操作有什么弊端？在遍历集合时因为一个需求反复输入遍历过程，使代码臃肿
2.获取流有哪两种方式？
collection集合中可以通过stream默认方法获取流；
stream接口中的静态方法of可以获取数组对应的流
3.Stream流中的方法分为哪两类，有什么区别？
foreach用来遍历流中的数据，是一个终结方法，遍历之后就不能继续调用其他方法了。
filter对stream中的流进行过滤。
4.调用concat方法有什么注意事项

是一个静态方法，与String当中的concat方法是不同的，两个流的泛型必须一模一样

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

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

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

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

作者: zhuyiming 时间: 2019-1-6 20:44
1.我们传统的集合操作有什么弊端？传统的集合操作有繁琐,,代码太多,每次操作都要遍历,效率低下
2.获取流有哪两种方式？
第一种,所有的单列集合都可以通过.stream的方法获取到Stream流的对象;
第二种,Stream有一个静态方法of,将数组作为参数能够获取到数组对应的流对象;
3.Stream流中的方法分为哪两类，有什么区别？
分为延迟方法和终结方法,两者的区别在于返回值的不同:
延迟方法返回是一个Stream对象
终结方法返回的不是一个Stream
4.调用concat方法有什么注意事项

concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

作者: 赖熙蒙 时间: 2019-1-6 20:45
1.我们传统的集合操作有什么弊端？答：对集合进行某些操作时，都需要重新遍历一次，过于繁琐。

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

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

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

答：concat是一个静态方法，与String当中的concat方法是不同，传递的两个对象的泛型必须相同。

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

作者: 黄毅 时间: 2019-1-6 20:46
1.我们传统的集合操作有什么弊端？每次遍历循环太繁琐，for循环的语法就是“怎么做”，for循环的循环体才是“做什么”
2.获取流有哪两种方式？
第一种：根据Collection获取流
第二种：根据Stream.of
3.Stream流中的方法分为哪两类，有什么区别？
延迟和终结
延迟方法，可以继续使用数据
终结方法，无法再使用
4.调用concat方法有什么注意事项

是一种静态方法，与 java.lang.String 当中的 concat 方法是不同的
数据类型必须相同

作者: 洪烁铭 时间: 2019-1-6 20:47
本帖最后由洪烁铭于 2019-1-6 21:01 编辑

1.我们传统的集合操作有什么弊端？
使用集合时，为了获得元素，对集合中的元素进行筛选等操作都需要对集合进行遍历，操作起来很麻烦；当需要进行几个筛选操作时，不同的集合之间没有数据的交互。而我们的目的只是为了获取计算结果，却需要反复创建、遍历集合，这是很复杂繁琐的。

2.获取流有哪两种方式？
通过Stream类的静态方法of来获取流对象；
通过创建Stream对象，调用stream方法来获取流。这种方式仅限于collection集合。所以对于map则需要间接使用（keySet、entrySet、values来获得集合，然后再调用stream方法）

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法和终结方法。延迟方法需要等终结方法调用后才会使用，这也是它为什么叫延迟方法的原因（lazy）。现在学到的终结方法有 count、forEach
两个方法的最大区别在于返回值类型不同。延迟方法返回的是流对象本身。

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

作者: 赵烈刚 时间: 2019-1-6 20:47
1.我们传统的集合操作有什么弊端？
步骤繁琐,我们如果想实现多个不同的功能,必须得多次遍历;
2.获取流有哪两种方式？
1).stream（）2).Stream.of(T...t)
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法和终结方法;延迟方法返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。终结方法包括 count 和 forEach 方法。
4.调用concat方法有什么注意事项?
在重复连接构建流时要小心,访问深度级联的流的元素可能导致深层呼叫链，甚至可能导致StackOverflowException ;

作者: 林文悦 时间: 2019-1-6 20:49
1.我们传统的集合操作有什么弊端？
但我们要对集合元素进行操作的时候总是需要不断地循环再循环，很麻烦。

2.获取流有哪两种方式？
①通过数组获取流
②通过集合获取流

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

4.调用concat方法有什么注意事项
concat方法是静态方法，所以可以用Stream接口直接调用，参数传递和返回值也是Stream类型。

作者: 苏志祥 时间: 2019-1-6 20:49

1.我们传统的集合操作有什么弊端？
弊端：对数组集合的元素进行操作的时候，需要每次遍历集合跟数组，导致操作繁杂
2.获取流有哪两种方式？
集合可以通过stream的方法获取到Stream的流对象
也可以通过静态方法Stream.of（）方法创建
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法跟终结方法：看返回值是否还是流对象
4.调用concat方法有什么注意事项
这是一个静态方法，传递的对象的数据类型必须是一样。

作者: 杨鑫棋 时间: 2019-1-6 20:50

1.我们传统的集合操作有什么弊端？

每次遍历都需要写一个for循环或者for增强，过于繁琐。每次需要用到一个集合，都需要对这个集合进行一次遍历，并且要存到新的集合中还得创建新的集合。

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

根据Collection获取流：Collection接口中加入了stream方法用来获取，所以其所有实现类都可以通过这个方法来获取流。
Stream中有个静态方法of，将数组作为对象可以获取数组对应的流对象。

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

延迟方法和终结方法。区别是返回值不同，延迟方法返回的还是一个Stream流对象，终结方法返回的则不是流对象，执行到这就结束了。

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

concat与String类中的concat方法不同，方法中传递的对象的数据类型必须相同。

作者: 董志超Eric 时间: 2019-1-6 20:50
1.我们传统的集合操作有什么弊端？
答：对于集合进行筛选、过滤、转换等操作时，需要重新创建集合，代码比较繁琐。

2.获取流有哪两种方式？
答：
1.对于单列集合（直接获取）双列集合（间接获取）。用Colloction集合的Stream（）方法。返回值为stream对象
2.对于数组使用Stream类的静态方法of，获取stream（）方法

3.Stream流中的方法分为哪两类，有什么区别？
答：
延迟方法：返回值为stream对象的方法，还能继续调用stream类中的方法，只是建立起模型，不会直接执行，需要最后调用终结方法才能执行。
终结方法：返回值不是stream对象的方法，不能继续调用stream类的方法，调用终极方法时，会把之前调用的延迟方法执行一遍，这是对资源的节约。

4.调用concat方法有什么注意事项
答：前提是两个流的泛型必须相同，就算这两个流是父子关系也不能用concat方法。
2019.1.6 JavaSE

作者: 刘荣城 时间: 2019-1-6 20:51
1.我们传统的集合操作有什么弊端？
每次要修改集合元素时，都要遍历集合，当要修改多长时，就要多次遍历集合，只样代码特别多。
2.获取流有哪两种方式？
第一种，只要时单列集合都可以通过点stream方法获取流的对象；
2.用stream的静态方法of，来获取数组对象
3.Stream流中的方法分为哪两类，有什么区别？
有延迟方法和终结方法，
延迟方法是返回值是strerm流对象，能再次调用strerm方法，
终结方法是只能用一次的方法。
4.调用concat方法有什么注意事项
Concat是静态方法，方法传递的对象类型必须一致和string的Concat方法不是一个方法，不要搞混了！

作者: 林晨涵 时间: 2019-1-6 20:51
1.我们传统的集合操作有什么弊端？
传统的集合操作有繁琐,,代码太多,每次操作都要遍历,效率低下
2.获取流有哪两种方式？
collection集合中可以通过stream默认方法获取流；
stream接口中的静态方法of可以获取数组对应的流
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法和终结方法，延迟方法：返回的还是Steam流对象，返回的对象就可以再次调用stream流中的方法，所以单独调用延迟方法并不会对流中的方法进行操作，只有当调用终结方法以后才会运行流中的方法，这样不会造成资源的浪费
4.调用concat方法有什么注意事项
concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行

作者: 王宏 时间: 2019-1-6 20:52
1.我们传统的集合操作有什么弊端？
答：我们的传统集合操作运用起来很不方便，要不断遍历循环，才能得到我们想要的答案

2.获取流有哪两种方式？
答：集合的名称.stream()针对集合的。或者stream.of()针对数组的两种方式

3.Stream流中的方法分为哪两类，有什么区别？
答：一种是延迟方法方法，用过此方法后，这个流还没有结束，还能被流里的另外方法操作，另外一种是终结方法，用过此方法后，流就结束，不能再被流里的别的方法操作

4.调用concat方法有什么注意事项
答：要确保方法内的两个流的泛型一致

作者: Wujainwei 时间: 2019-1-6 20:52
我们传统的集合操作有什么弊端？遍历代码太繁琐，代码量大，不一定要传统集合遍历的过程，我们只要结果 2.获取流有哪两种方式？集合可以通过Stream的方法获取到Stream流的对象; Stream of 方法获取对象 3.Stream流中的方法分为哪两类，有什么区别？分为延迟方法和终结方法，延迟方法之后还能链式用延迟方法和终结方法，终结方法之后就不能链式用方法 4.调用concat方法有什么注意事项 concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

作者: 许晓明 时间: 2019-1-6 20:53
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-1-6 20:55
1.我们传统的集合操作有什么弊端？
当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是要对集合进行遍历，过程太繁杂

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

3.Stream流中的方法分为哪两类，有什么区别？
延迟方法，使用延迟方法后，返还的还是Stream本身，还可以使用链式编程
终结方法，使用终结方法后，返还的不是Stream本身，不可以使用链式编程

4.调用concat方法有什么注意事项
两个流的泛型必须一致，子父类关系也不行

作者: 陈基林 时间: 2019-1-6 20:55

1.我们传统的集合操作有什么弊端？
传统的集合操作中,如果想要对集合中的数据就不得不对集合用for循环进行遍历,我们想要的只是循环体中的方法体去做什么,而不是要这个for循环遍历,且遍历一次只能实现一个功能,如果有多个需求还需要进行多次遍历,代码就很冗长.
2.获取流有哪两种方式？
获取流的方式有两种,一种是根据集合来获取流,如果是Collection接口下的实现类可以直接调用stream方法来获取流,如果是map接口下的可以通过键或者值来形成单列集合之后再使用stream方法来获取流;另外一种是根据数组来获取流,通过Stream类中的静态方法of就可以获取流.
3.Stream流中的方法分为哪两类，有什么区别？
Stream流中的方法分为延迟方法和终结方法这两类,延迟方法的返回的数据还是属于stream流的数据,因此可以使用链式编程,而终结方法就是类似消费此前的延迟方法形成的stream流数据从而生成其他的数据,使用终结方法之后不能再进行链式编程.
4.调用concat方法有什么注意事项
因为concat方法是Stream类的静态方法,所以调用的时候要直接用类名Stream去调用.

作者: 李柏刚 时间: 2019-1-6 20:56
1.我们传统的集合操作有什么弊端？获取指定元素，不得不多次的遍历集合，代码长，繁琐。
2.获取流有哪两种方式？
所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。本小节中，终结方法包括 count 和 forEach 方法。
4.调用concat方法有什么注意事项

concat是静态方法，方法中传递的对象的数据类型必须相同,才可使用concat进行组合，即使两个对象是字父类关系，也一样会报错。

作者: Java中的莫Q哇啦 时间: 2019-1-6 20:57
1.我们传统的集合操作有什么弊端？
对集合内容进行筛选操作的时候太繁琐，要不停创建新的集合接收。
2.获取流有哪两种方式？
Collection集合直接调用stream方法获取Stream流；Stream流调用静态方法of获取Stream流对象。
3.Stream流中的方法分为哪两类，有什么区别？
分为延迟方法和终结方法，延迟方法可以继续调用Stream的方法，终结方法不可以继续调用Stream中的方法。
4.调用concat方法有什么注意事项
1.注意这是一个终结方法，一旦调用后就不可以继续连接Stream方法。2.这是一个静态方法，直接使用Stream调用。3.返回值是一个long类型的数据。

黄成成----

作者: 杨馥榕 时间: 2019-1-6 21:01
1.我们传统的集合操作有什么弊端？
答：代码量多，需要用到方法每次都要遍历集合。
2.获取流有哪两种方式？
答：collection流和map流。
3.Stream流中的方法分为哪两类，有什么区别？
答：延迟类和终结类
延迟类：返回的还是Steram流对象，就可以再次调用Steram流中的方法，依赖lambda的延迟特效，所以单独调用延迟方法，并不是对流中的内容进行操作，只会建立一个模型
终结方法：返回的不是Steeam流对象，所以不能再继续调用strea流中的方法了，当调用终结方法的时候，我们会将之前建立的延迟方法的模型，逐一操作
4.调用concat方法有什么注意事项
[tr][/tr]

答：concat是静态方法,与String中的concat方法不同,方法中传递的对象的数据类型必须相同,子父类的关系也不行,

作者: 艾卡西亚的惊喜 时间: 2019-1-6 21:01
1.我们传统的集合操作有什么弊端？
答：步骤太多，代码过多，不简洁。
2.获取流有哪两种方式？
答：①所有的Collection集合都可以通过Stream默认方法获取流；
②Stream接口的静态方法or可以获取数组对应的流；
3.Stream流中的方法分为哪两类，有什么区别？
答：延迟方法：返回值类型依然是Stream接口本身类型的方法，因此支持链式调用。（除了终结方法外，其余方法为延迟方法。）
终结方法：返回值类型不再是stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。
4.调用concat方法有什么注意事项
答：在重复连接构建流时要小心。访问深度级联的流的元素可能导致深层呼叫链，甚至可能导致StackOverflowException 。

幽默风趣的林少伟

作者: 黄嘉宏 时间: 2019-1-6 21:04

1.我们传统的集合操作有什么弊端？
传统集合需要过程，注重的是怎么做，但我们只是需要得到的数据，过程并不重要。
2.获取流有哪两种方式？
根据collecollection中的方法stream接口有一个of静态方法，Map，数组获取流。
3.Stream流中的方法分为哪两类，有什么区别？
分为延迟方法和终结方法，延迟方法返回的是Stream接口自身类型的方法，支持链式调用。
终结方法返回值类型不再是Stream接口自身类型的方法，不支持链式调用。
4.调用concat方法有什么注意事项
这是个静态方法，要用Stream流调用，不能用String调用。

作者: 苏阿合 时间: 2019-1-6 21:07
1.我们传统的集合操作有什么弊端？
传统的集合：如果我们要对集合的元素进行操作的时候，需要对集合进行循环遍历再进行操作且还要再创建一个集合容器去存储操作后的元素，过程太过繁琐，代码臃肿，阅读性差。

2.获取流有哪两种方式？
(1)可以通过collection集合或该集合下的子类都可以通过stream默认方法获取stream流
(2)可以以 Stream 接口中提供了静态方法
of（）中传入数组和参数（参数类型要一致）获取stream流对象

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

4.调用concat方法有什么注意事项
调用concat方法要注意：concat是静态方法,可以通过Stream类名直接调用，且该方法的参数中传递的两个stream流的泛型类型要一致

作者: ab8846254 时间: 2019-1-8 10:00
本帖最后由 ab8846254 于 2019-1-8 10:02 编辑

1.我们传统的集合操作有什么弊端？
答：传统集合存取数据，复杂，过程繁琐。需要做某一件操作的时候前期需要做很多的准备。
2.获取流有哪两种方式？
答：1.可以通过Collection 接口下的实现类获取Stream流
2.可以通过Stream接口下的静态方法of返回一个Stream流还可以通过ofNullable?方法返回一个Stream流
3.Stream流中的方法分为哪两类，有什么区别？
答：1.延迟方法，方法返回的也是Stream类型对象，因此可以支持链式调用，
2.返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用，其中包含count和forEach方法
4.调用concat方法有什么注意事项
答：concat方法可以把两个Stream流组合到一起，需要注意的是数据的两个流的类型《泛型》要一致

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

黑马程序员IT技术论坛 X3.2