什么是Stream？
什么是流？获取流流的操作
中间操作终端操作流操作的演示
**中间操作的演示：****终端操作演示**
在看Stream流前，请足够了解到Lambda表达式
Java8 Lambda表达式的了解
Stream是Java8的新特性，它允许你以声明的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。
此外与Stream与Lambda表达式相结合后编码的效率大大提高，并且可读性更强。
要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全 不同的概念。
举个简单的例子：
public static void main(String[] args) {
List applestore = new ArrayList();
applestore.add(new Apple(1, "red", 500, "河南"));
applestore.add(new Apple(2, "red", 400, "陕西"));
applestore.add(new Apple(3, "green", 300, "上海"));
applestore.add(new Apple(4, "green", 200, "湖北"));
applestore.add(new Apple(5, "green", 100, "湖南"));
}
现在在applestore中找到红色的手机
在这里我们就可以使用Stream流来进行操作。
Listapples = applestore .stream() .filter(a -> a.getColor().equals("red")) .collect(Collectors.toList());
在这里就使用了Stream的流操作，使用的是声明式方法。总起可以看作是一个流的操作。
说明要做的步骤（筛选，排序，取值），而不是具体的写怎么去操作这个。将要做的步骤串在一起。达到一种流水线的操作。
在整个过程当中，数据都是以流的形式进行操作。
简单的定义，就是 “从支持数据处理操作的源，生成的元素序列”。
流是个抽象的概念，并且具有方向性。可以将流想象成一个“水管”，水（就是数据）在水管里面流动。
数据源： 获取数据的源，比如集合数组等。
元素列表： 和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。
数据处理操作： 流更偏向于数据处理和计算，比如 filter、map、find、sort 等。
说通俗一点就是，我们通过一个集合的Stream方法转换获得一个流，然后对这个流进行一系列我们需要的操作，处理完后。最后，再将这个流转换为我们人能看得懂的数据集合
获取流就是支持数据的操作
- 使用 Collection 接口下的 stream()
Listlist = new ArrayList<>(); Stream stream = list.stream();
- 使用 Arrays 中的 stream() 方法，将数组转成流。
Integer[] nums = new Integer[10]; Streamstream = Arrays.stream(nums);
- 使用 Stream 中的静态方法：of()
Streamstream = Stream.of(1,2,3,4,5,6);
- 使用 BufferedReader.lines() 方法，将每行内容转成流
BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
Stream lineStream = reader.lines();
流的操作
流操作可以分为两类：中间操作和终端操作。
查看stream、filter的底层代码：
可以看出在获得流的时候，底层的传递都是以流的形式进行传送。
集合/数组 → 元素序列（Stream）→ 中间操作（过滤/去重/排序/…）→ 终端操作（最终的结果）
诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终 端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。
在对数据的的中间操作时，可以使用lambda的表达式进行操作。
Java8 Lambda表达式的了解
● filter：过滤流中的某些元素,
● sorted(): 自然排序，流中元素需实现 Comparable 接口 。
● distinct: 去除重复元素
● limit(n): 获取 n 个元素
● skip(n): 跳过 n 元素，配合 limit(n)可实现分页 map(): 将其映射成一个新的元素
● forEach: 遍历流中的元素
● toArray:将流中的元素倒入一个数组
● Min:返回流中元素最小值
● Max:返回流中元素最大值
● count:返回流中元素的总个数
● reduce:所有元素求和
● anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
● allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
● findFirst：返回流中第一个元素
● collect:将流中的元素倒入一个集合,Collection 或 Map
public static void main(String[] args) {
Stream.of(2,4,3,6,1,7,5,5,7)
//中间操作
.filter((e) -> {return e>3;}) //使用Lambda的表达式 表示大于3的留下
//filter的结果为 4,6,7,5,5,7
.sorted() //自然排序，流中元素需实现
//sorted的结果为 4,5,5,6,7,7
.distinct() //去除重复元素
//distinct的结果为 4,5,6,7
.skip(1) //跳过 n 元素 这里意思跳过1个元素，从第二个开始
//skip的结果为 5,6,7
.limit(2) //获取 n 个元素 这里获取了两个元素
//limit的结果为 5,6
//终端操作
.forEach((a) ->{
System.out.println(a);
});
}
结果输出：
map：将其映射成一个新的元素
演示：
import java.util.ArrayList;
public class StreamDemo2 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList<>();
arrayList.add(new Apple(101, "小智", "红色"));
arrayList.add(new Apple(102, "张三", "蓝色"));
arrayList.add(new Apple(103, "蕾姆", "绿色"));
arrayList.add(new Apple(104, "亚当", "白色"));
arrayList.add(new Apple(105, "夏娃", "白色"));
arrayList.stream()
//map（方法）将某一个值映射到Stream
//Apple::getNumber意思是将Apple对象中的number 转换为Stream中的流
.map(Apple::getNumber)
//之下的操作就是对Apple中所有的number数据进行操作
.forEach((e) -> {
System.out.println(e);
});
}
}
创建对应的Apple类（生成它的get/set方法和构造方法还有()方法 ）
package com.wang.javaforword.stream;
public class Apple {
private Integer number;
private String name;
private String color;
public Apple() {
}
public Apple(Integer number, String name, String color) {
this.number = number;
this.name = name;
this.color = color;
}
public Integer getNumber() {
return number;
}
public void setNumber(Integer number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Apple{" +
"number=" + number +
", name='" + name + ''' +
", color='" + color + ''' +
'}';
}
}
终端操作演示
- toarray：将流中的元素倒入一个数组
public static void main(String[] args) {
Object[] array = Stream.of(2,4,3,6,1,7,5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.toArray();//转换成一个数组
System.out.println(array);
System.out.println(Arrays.toString(array));
}
2. max 取出数据中的最大值
min 取出数据中的最小值
count 返回流中元素的总个数
reduce 返回流中所有元素的求和
public static void main(String[] args) {
Integer max = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.max((o1, o2) -> {
return o1 - o2;
})//max的返回值是一个Optional这样的对象中
//再调用Optional中的get的这个方法，将值拿到就行了
.get();
Integer min = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.min((o1, o2) -> {
return o1 - o2;
})//min和max一样同理
.get();
Long count = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.count();//count返回的总共有多少个数据元素
Integer reduce = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.reduce((o1, o2) -> {
return o1 + o2;
})//count返回的总共有多少个数据元素
.get();
System.out.println("max：" + max);
System.out.println("min：" + min);
System.out.println("count:" + count);
System.out.println("reduce：" + reduce);
}
3. anyMatch：只要流中有一个元素满足条件则返 回 true，否则返回 false
allMatch: 当流中每个元素都符合条件时才返 回 true，否则返回 false
public static void main(String[] args) {
boolean anyMatch = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.anyMatch((e) -> {
return e > 3;
});//表示流中的元素只要有一个大于3就返回true
boolean allMatch = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.allMatch((e) -> {
return e > 3;
});//表示流中的元素全部都大于3才返回true
System.out.println("angMatch:" + anyMatch);
System.out.println("allMatch:" + allMatch);
}
3. findFirst：返回流中第一个元素
public static void main(String[] args) {
Integer findFirst = Stream.of(2, 4, 3, 6, 1, 7, 5)
//中间操作
.sorted() //自然排序
//sorted的结果为 1,2,3,4,5,6,7
//终端操作
.findFirst() //findFirst的终端操作也用的是Optional的对象
.get(); //要对数据进行输出，所以也要用的get的方法
System.out.println("findFirst：" + findFirst);
}
4. collect：将流中的元素倒入一个集合,Collection 或 Map
collect() 方法，是可以收集流中的数据到集合或者数组中去。
public static void main(String[] args) {
ArrayList arrayList = new ArrayList<>();
arrayList.add(new Apple(101, "小智", "红"));
arrayList.add(new Apple(303, "张三", "蓝"));
arrayList.add(new Apple(202, "蕾姆", "绿"));
arrayList.add(new Apple(505, "亚当", "白"));
arrayList.add(new Apple(404, "夏娃", "白"));
//转换前
System.out.println("转换前：");
System.out.println(arrayList);
List list = arrayList.stream()
//中间操作，进行了一个排序的操作
.sorted((o1,o2)->{return o1.getNumber()- o2.getNumber();})
.collect(Collectors.toList());//将处理完后的流转换为List类型的数据
System.out.println("转换为一个List的集合：");
System.out.println(list);
Set set = arrayList.stream()
//中间操作，进行了一个排序的操作
.collect(Collectors.toSet());//将处理完后的流转换为List类型的数据
System.out.println("转换为一个Set的集合：");//set就是不重复
System.out.println(set);
Map map = arrayList.stream()
//中间操作，进行了一个排序的操作
.collect(Collectors.toMap(Apple::getNumber,Apple::getName));//将处理完后的流转换为List类型的数据
System.out.println("转换为map的结果：");
System.out.println(map);
}
