看到Stream流这个概念，我们很容易将其于IO流联系在一起，事实上，两者并没有什么关系，IO流是用于处理数据传输的，而Stream流则是用于操作集合的。
当然，为了方便我们区分，我们依旧在这里复习一下IO流的相关知识。
1.什么是IO流?
IO: output: input流:像水流一样传输数据
2.IO流的作用?
用于读写数据(本地文件，网络)存储和读取数据的解决方案
3.IO流按照流向可以分类哪两种流?
输出流:程序
输入流:文件
4.IO流按照操作文件的类型可以分类哪两种流?
字节流:可以操作所有类型的文件
字符流:只能操作纯文本文件
5.什么是纯文本文件?
用windows系统自带的记事本打开并且能读懂的文件txt文件，md文件，xml文件，lrc文件等
在学习Stream流之前，我们需要先学习Lambda表达式的用法。，这涉及到几个概念，分别是函数式编程，匿名内部类
函数式编程
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
匿名内部类
假设我们有一个接口A
内部有一个未被实现的方法eat
如果我们想在main中直接调用eat方法
Lambda表达式
Lambda该怎么用呢？其可以用在只有一个方法的接口上。
Function<T, R> 是 Java 8 中的一个函数式接口，
用于表示接受一个输入参数 T，并返回一个结果 R 的函数。
Function接口中有一个抽象方法apply，用于定义函数的逻辑。
Function接口通常用于将数据进行转换、映射或者执行某种转换操作。
通过这种函数式接口，我们可以实现不同的操作。
package Lambda;
import java.util.function.Function;
public class Lambda1 {
public static void main(String[] args) {
//使用匿名内部类，直接重写接口中的方法，省去创建实现类实现接口的过程和创建实现类对象的过程。
Integer i = TypeConver(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.valueOf(s);
}
});
System.out.println(i);
Integer m = TypeConver((String s) ->{return Integer.valueOf(s);});
System.out.println(m);
//Lambda实现字符串拼接
String string = TypeConver((String str) -> {
return str + "你好";
});
System.out.println(string);
}
public static <R> R TypeConver(Function<String,R> function){
String str="12345";
R result=function.apply(str);
return result;
}
}
案例4：对IntConsumer接口进行实现。
package Lambda;
import java.util.function.IntConsumer;
public class Lambda2 {
public static void main(String[] args) {
forEachArr(new IntConsumer() {
@Override
public void accept(int value) {
System.out.println(value);
}
});
forEachArr((int value)->{
System.out.println(value);
});
}
public static void forEachArr(IntConsumer intConsumer){
int[] arr={1,2,3,4,5,6,7,8};
for(int i:arr){
intConsumer.accept(i);
}
}
}
事实上，我们可以将含有匿名内部类的写法直接一键转化为Lambda表达式的形式。
由此可见，Lambda就是对匿名内部类的优化。
Stream流
学完了Lambda表达式，我们来看看Stream到底是如何操作集合的，尽管集合中为我们提供了大量的方法，但在Stream操作面前根本不值一提。
场景：获取List中元素含"州"的元素，并放入一个List集合中。Stream支持链式编程与Lamba表达式
下面首先是通过我们的一般方法来实现
List<String> citys=hashMap.get("江苏省");
for (String c:citys){
System.out.println(c);
}
List<String> cs1=new ArrayList<>();
for(String city:citys){
if(city.contains("州")){
cs1.add(city);
}
}
System.out.println(cs1);
使用Stream实现，当然，这里的forEach只是将其输出了一下，并没有将其放到一个新的List中。
citys.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("州");
}
}).forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
通过Stream与Lambda实现：
List<String> cs2=citys.stream()
.filter(s->s.contains("州"))
.collect(Collectors.toList());
Stream的流操作涉及三个过程，分别是流创建，中间操作以及结束操作，如果我们不启用结束操作，那么中间操作的过程也是不会执行的。
创建流
package Stream;
import java.util.*;
import java.util.stream.Stream;
public class CreateStream {
public static void main(String[] args) {
//列表创建Stream
List list=new ArrayList<>();
Collections.addAll(list, 1,2,3,4,5);
Stream stream = list.stream();
stream.filter(o -> {
int i= (int) o;
return i>=2;
}).forEach(o -> System.out.print(o));
//数组创建Stream
Integer[] arr={1,2,3,4,5,6,7,8};
Stream<Integer> stream1 = Arrays.stream(arr);
Stream<Integer> stream2 = Stream.of(arr);
stream1.filter(s->s>=2).forEach(s->System.out.print(s));
stream2.forEach(s->{
System.out.print(s);
});
//对于双列集合，将其转换为单列集合后再创建Stream流
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("李白",135);
hashMap.put("杜甫",123);
hashMap.put("白居易",234);
//通过entrySet方法可以将map转换为set
Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
System.out.println();
//set可以创建stream流
Stream<Map.Entry<String, Integer>> stream3 = entries.stream();
stream3.forEach(s->{
System.out.println(s);
});
}
}
中间操作
filter操作
filter，筛选操作，我们先前已经使用过了。
map操作
map，可以对流中的元素进行计算与转换。如下，通过map操作，将原本列表中的对象转换为字符串
list.stream().filter(new Predicate<Author>() {
@Override
public boolean test(Author author) {
return author.getAge()>50;
}
}).forEach(new Consumer<Author>() {
@Override
public void accept(Author author) {
System.out.println(author);
}
});
list.stream().filter(new Predicate<Author>() {
@Override
public boolean test(Author author) {
return author.getAge()>50;
}
}).map(new Function<Author, String>() {
@Override
public String apply(Author author) {
return author.getName();
}
}).forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
可以看到，通过map操作，将原本流中的对象转换为字符串
distinct操作
去除流中的重复元素。其内部是依靠Object中的equals方法来实现的，因此可能需要重写equals方法。
list.add(new Author("李白",46));
list.add(new Author("杜甫",55));
list.add(new Author("白居易",67));
list.add(new Author("白居易",67));
list.stream().distinct().forEach(author -> System.out.println(author));
这里推荐一个插件 Java Stream Debugger，可以方便我们对Stream进行调试。
sorted操作
sorted共有两个，分别是空参的与非空参的。其中空参的那个需要我们在类上实现Comparable接口的方法，而非空参则采用在sorted中实现排序比较。
我们先来试一下无参的sorted。
ArrayList<Author> list = new ArrayList<>();
list.add(new Author("李白",46));
list.add(new Author("杜甫",55));
list.add(new Author("白居易",67));
list.add(new Author("白居易",67));
list.stream().sorted().forEach(author -> System.out.println(author));
发生报错，说要让我们去实现Comparable接口
package Stream;
import java.util.Objects;
public class Author implements Comparable<Author>{
private String name;
private Integer age;
public String getName() {
return name;
}
public Integer getAge() {
return age;
}
@Override
public int compareTo(Author o) {
return this.getAge()-o.getAge();
}
}
随后再次运行即可。
那么带参数的该怎么做呢？
list.stream().distinct().sorted(new Comparator<Author>() {
@Override
public int compare(Author o1, Author o2) {
return o2.getAge()-o1.getAge();
}
}).forEach(author -> System.out.println(author));
limit操作
设置流的最大长度，超出的将被抛弃。设置排序后的前2个。
list.stream().distinct().sorted((o1, o2) -> o2.getAge()-o1.getAge())
.limit(2)
.forEach(author -> System.out.println(author));
skip操作
跳过流中的前n个元素，返回后面的元素。
flatMap操作
先前所接触的map可以将一个对象转换为另一个对象，而flatMap可以将一个对象转换为多个对象作为流中的元素。
下面的代码是什么意思呢，事实上，他是将原本的Author中的Book提取处理，由原本一个Author变为多个Book。
authors.stream().distinct()
.map(author -> author.getBooks())
.forEach(books -> System.out.println(books));
authors.stream().distinct().flatMap(new Function<Author, Stream<Books>>() {
@Override
public Stream<Books> apply(Author author) {
return author.getBooks().stream();
}
}).forEach(new Consumer<Books>() {
@Override
public void accept(Books books) {
System.out.println(books);
}
});
其对应的lambda表达式的写法：
authors.stream().distinct()
.flatMap(author -> author.getBooks().stream())
.forEach( books -> System.out.println(books));
接下来我们再通过一个案例来看看flatMap的作用，我们的书籍类中有一个类别属性，其属性内含有多个值，我们是这样定义的：
我们希望这个类别值能够按",”分开，因此也使用flatMap实现：
List<Author> authors=getAuthors();
authors.stream().distinct().flatMap(new Function<Author, Stream<Books>>() {
@Override
public Stream<Books> apply(Author author) {
return author.getBooks().stream();
}
}).distinct().flatMap(new Function<Books, Stream<String>>() {
@Override
public Stream<String> apply(Books books) {
return Arrays.stream(books.getCategory().split(","));
}
}).forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
对应的Lambda表达式如下：
authors.stream().distinct()
.flatMap( author -> author.getBooks().stream())
.distinct()
.flatMap( books -> Arrays.stream(books.getCategory().split(",")))
.forEach((Consumer<String>) s -> System.out.println(s));
终结操作
forEach操作
这个用于遍历输出流中的元素，前面我们已经用过多次了。
count操作
用于计算流中元素的数量，注意要删除重复元素。
统计这些作者发表的书籍的数目。
ArrayList<Author> authors = getAuthors();
authors.stream()
.flatMap( author -> author.getBooks().stream())
.distinct()
.forEach(books -> System.out.println(books));
long count = authors.stream()
.flatMap( author -> author.getBooks().stream())
.distinct().count();
System.out.println(count);
min与max操作
ArrayList<Author> authors = getAuthors();
Optional<Integer> max = authors.stream()
.flatMap(author -> author.getBooks().stream())
.distinct()
.map(new Function<Books, Integer>() {
@Override
public Integer apply(Books books) {
return books.getPrice();
}
}).max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
System.out.println(max.get());
对应的Lambda表达式写法：
ArrayList<Author> authors = getAuthors();
Optional<Integer> max = authors.stream()
.flatMap(author -> author.getBooks().stream())
.distinct()
.map(books -> books.getPrice())
.max((o1, o2) -> o1 - o2);
System.out.println(max.get());
collect操作
将流中的元素转换为集合。集合分为三种，分别是List、Set以及Map。
需求：获取所有作者名字的集合
collect转换为List集合，如下：
ArrayList<Author> authors = getAuthors();
List<String> collect = authors.stream().map(new Function<Author, String>() {
@Override
public String apply(Author author) {
return author.getName();
}
}).distinct().collect(Collectors.toList());//我们不调用对象去写匿名方法，而是直接调用Collectors这个工具类
System.out.println(collect);
转换为Set的方式很类似，如下：
Set<String> collect1 = authors.stream().map(new Function<Author, String>() {
@Override
public String apply(Author author) {
return author.getName();
}
}).distinct().collect(Collectors.toSet());
System.out.println(collect1);
其对应的Lambda表达式如下：
ArrayList<Author> authors = getAuthors();
List<String> collect = authors.stream().map(author -> author.getName())
.distinct()
.collect(Collectors.toList());//我们不调用对象去写匿名方法，而是直接调用Collectors这个工具类
System.out.println(collect);
Set<String> collect1 = authors.stream().map(author -> author.getName())
.distinct().collect(Collectors.toSet());
System.out.println(collect1);
转换为Map，需要指定两个参数，分别是Key与Value，内部匿名方法实现如下：
Map<String, List<Books>> collect2 = authors.stream().distinct()
.collect(Collectors.toMap(new Function<Author, String>() {
@Override
public String apply(Author author) {
return author.getName();
}
}, new Function<Author, List<Books>>() {
@Override
public List<Books> apply(Author author) {
return author.getBooks();
}
}));
System.out.println(collect2);
对应的Labmbda表达式如下：
Map<String, List<Books>> collect2 = authors.stream().distinct()
.collect(Collectors.toMap( author -> author.getName(), author -> {
return author.getBooks();
}));
System.out.println(collect2);
anyMatch操作
该操作用于进行查找与匹配，其返回值为Boolean，如下面判断是否有作家年龄在80岁以上：
boolean b = authors.stream().anyMatch(new Predicate<Author>() {
@Override
public boolean test(Author author) {
return author.getAge() > 80;
}
});
System.out.println(b);
对应的Lambda表达式：
boolean b = authors.stream().anyMatch(author -> author.getAge() > 80);
allMatch操作
所有流元素是否满足条件，若满足则返回True，否则为False。判断所有作家是否都大于30岁。
ArrayList<Author> authors = getAuthors();
boolean b = authors.stream().allMatch(new Predicate<Author>() {
@Override
public boolean test(Author author) {
return author.getAge() > 30;
}
});
System.out.println(b);
findAny操作
findAny的返回值是Optional对象，返回值是其中一个流元素，即任意一个流元素，他可以调用ifPresent方法，即判断结果为否存在。
ArrayList<Author> authors = getAuthors();
Optional<Author> any = authors.stream().filter(new Predicate<Author>() {
@Override
public boolean test(Author author) {
return author.getAge() > 16;
}
}).findAny();
any.ifPresent(new Consumer<Author>() {
@Override
public void accept(Author author) {
System.out.println(author);
}
});
Lambda表达式写法。
ArrayList<Author> authors = getAuthors();
Optional<Author> any = authors.stream()
.filter(author -> author.getAge() > 16)
.findAny();
any.ifPresent(author -> System.out.println(author));
findFirst操作
findFirst返回查询的第一个结果。
ArrayList<Author> authors = getAuthors();
Optional<Author> first = authors.stream().sorted()
.distinct()
.findFirst();
System.out.println(first);
reduce操作
归并操作，reduce的作用是把stream中的元素给组合起来，按照指定方式得出一个结果，故又被称为缩减操作。reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和初始化值进行计算，计算结果再和后面的元素计算。
下面的代码即reduce的原理，可以看到，我们所需的值，一个是初始化值，另一个便是遍历的值了。
在使用reduce时，一般情况下都需要在前面加一个map用于转换，这在谷歌中十分常用。
计算作家的年龄之和：
ArrayList<Author> authors = getAuthors();
Integer reduce = authors.stream().distinct().map(new Function<Author, Integer>() {
@Override
public Integer apply(Author author) {
return author.getAge();
}
}).reduce(0, new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer result, Integer element) {
return result + element;
}
});
System.out.println(reduce);
对应的Lambda表达式：
Integer reduce1 = authors.stream()
.distinct().map(author -> author.getAge())
.reduce(0, (result, element) -> result + element);
利用reduce求流元素中的最大值：其实我们max也可求出，事实上，max的实现就是reduce。通过指定的初始值为一个最小的int类型，此时第一次max的值即为Integer.MIN_VALUE，随后通过三目运算求出即可。
ArrayList<Author> authors = getAuthors();
Integer reduce = authors.stream().map(author -> author.getAge())
.reduce(Integer.MIN_VALUE, new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer max, Integer element) {
return max > element ? max : element;
}
});
System.out.println(reduce);
对应的Lambda表达式：
Integer reduce1 = authors.stream().map(author -> author.getAge())
.reduce(Integer.MIN_VALUE, (max, element) -> max > element ? max : element);
上面的reduce方法中需要传递两个参数，分别是初始值以及BinaryOperator（一种操作对象）事实上，reduce还有其他形式，比如不指定初始值的情况，其计算原理如下：可以看到，它是将流元素中的第一个值赋值给初始值。
那么了解了这一种reduce的计算原理后，我们先前的计算最值似乎更简单了。
即无需指定初始值，直接计算即可。需要注意的是，其最终的返回值被封装为Optional，所以要调用get方法来获取值。
ArrayList<Author> authors = getAuthors();
Optional<Integer> reduce = authors.stream().map(author -> author.getAge())
.reduce(new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer result, Integer element) {
return result > element ? result : element;
}
});
System.out.println(reduce.get());
如果不调用get方法，reduce的值为：
Stream注意事项
- 惰性求值(如果没有终结操作，没有中间操作是不会得到执行的)
- 流是一次性的(一旦一个流对象经过一个终结操作后。这个流就不能再被使用)
- 不会影响原数据(我们在流中可以多数据做很多处理。但是正常情况下是不会影响原来集合中的元素的。这往往也是我们期望的)正常情况下，只要你不调用set方法之类的。
比如下面我们已经将流使用过一次终结操作了，那么再次使用时便会报错：
ArrayList<Author> authors = getAuthors();
Stream<Author> stream = authors.stream();
stream.map(author -> author.getAge())
.reduce((result, element) -> result > element ? result : element);
stream.map(author -> author.getAge())
.reduce((result, element) -> result > element ? result : element);
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
at java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)
at java.util.stream.ReferencePipeline.<init>(ReferencePipeline.java:94)
at java.util.stream.ReferencePipeline$StatelessOp.<init>(ReferencePipeline.java:618)
at java.util.stream.ReferencePipeline$3.<init>(ReferencePipeline.java:187)
at java.util.stream.ReferencePipeline.map(ReferencePipeline.java:186)
at Stream.Test4.main(Test4.java:18)