什么是流？
流是一种处理数据的高级手段，任何数据都可以转化成流进行处理。对Stream流来说，比较常见数据源有集合、数组、IO等。
流的特点
1、只能遍历一次
我们可以把流想象成一条流水线，流水线的源头是数据源，数据源中的每个元素是流的操作对象。
数据源中的元素被依次输送到流水线上，然后我们就可以对这些流水线上的元素进行各种操作，一旦元素走到了流水线的尽头，那么该元素也被“消费掉了”，之后在此次流水线上我们便无法再对该元素进行任何操作。
2、内部迭代
平常我们是赢得for循环、增强for等一些遍历操作都是显示的操作数据源，而stream流的遍历过程对我们来说是不可见的，采用的是内部迭代的方式遍历。
流的各种操作
1、中间操作
当数据源中的元素进到流水线上，同时在元素走到流尽头之前，这个过程中的所有操作都是“中间操作”，元素进行完中间操作之后依旧处于流水线上，所以我们还可以继续对元素进行中间操作；因此，中间操作的特点是，操作后的结果依旧是流。
2、终结操作
当完成了所有我们想要进行的中间操作，也就意味着我们对此次数据源的流处理已经结束，所以，我们应当将处理后的数据源从流水线取出，而取出的值就是整个stream流的最终处理的结果。
常见数据源获取流对象
1、集合
List<String> strings = new ArrayList<>();
strings.add("hello");
strings.add("world");
Stream<String> stream = strings.stream();
2、数组
String[] strings = {"hello","world"};
Stream<String> stream = Arrays.stream(strings);
3、值
Stream<String> stream = Stream.of("hello", "world");
4、IO流
Stream<String> stream = Files.lines(Paths.get("文件地址"), Charset.defaultCharset());
常见中间操作
personlist.add(new Person("皮卡丘",24,"公","鼠"));
personlist.add(new Person("波克比",22,"母","蛋"));
personlist.add(new Person("喷火龙",25,"公","龙"));
personlist.add(new Person("肯泰罗",25,"公","牛"));
1.map映射
map函数接受一个Lambda表达式作为参数，该表达式执行的返回值类型将用作一个新类型流输出，数据源中的每个元素都将传入map进行Lambda表达式执行，最后执行的结果将存入一个以表达式返回值类型为目标的新流。如下，Person类型流通过map操作转变成String类型流
List<String> personlistName =personlist.stream().map(Person::getName).collect(Collectors.toList()); //[皮卡丘, 波克比, 喷火龙, 肯泰罗]
2.filter过滤
//filter函数接受一个Lambda表达式作为参数，该表达式返回一个boolean值，数据源中的每个元素都将传入filter进行Lambda表达式判断，最终过滤出表达式为true的元素。
List<Person> personlistFilter = personlist.stream().filter(a->"公".equals(a.getSex())).collect(Collectors.toList());
//[Person(name=皮卡丘, age=24, sex=公, species=鼠), Person(name=喷火龙, age=25, sex=公, species=龙),
// Person(name=肯泰罗, age=25, sex=公, species=牛)]
3.sorted排序
在不指定比较器参数的情况下，默认使用自然排序。
Stream<Integer> stream = Stream.of(1, 3, 21, 54, 34, 6, 9, 7, 11);
List<Integer> collect = stream.sorted().collect(Collectors.toList());
//[1, 3, 6, 7, 9, 11, 21, 34, 54]
List<Person> personlistSorted = personlist.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
//[Person(name=波克比, age=22, sex=母, species=蛋), Person(name=皮卡丘, age=24, sex=公, species=鼠),
// Person(name=喷火龙, age=25, sex=公, species=龙), Person(name=肯泰罗, age=25, sex=公, species=牛)]
倒序
List<Person> personlistSorted2 = personlist.stream().sorted(Comparator.comparing(Person::getAge).reversed()).collect(Collectors.toList());
//[Person(name=喷火龙, age=25, sex=公, species=龙), Person(name=肯泰罗, age=25, sex=公, species=牛),
// Person(name=皮卡丘, age=24, sex=公, species=鼠), Person(name=波克比, age=22, sex=母, species=蛋)]
4.distinct去重
//去掉重复的元素
Stream<String> stream2 = Stream.of("hello", "world","hello");
List<String> collect2 = stream2.distinct().collect(Collectors.toList()); //[hello, world]
5、limit截取
//从头开始截取指定数量的元素
Stream<Integer> streamLimit = Stream.of(1, 3, 21, 54, 34, 6, 9, 7, 11);
List<Integer> streamLimit1 = streamLimit.limit(2).collect(Collectors.toList()); //[1, 3]
6、skip跳过
// 跳过数据源的前两个元素
Stream<Integer> streamSkip = Stream.of(1, 3, 21, 54, 34, 6, 9, 7, 11);
List<Integer> streamSkip2 = streamSkip.skip(2).collect(Collectors.toList());
// [21, 54, 34, 6, 9, 7, 11]
终止操作
Stream<Integer> stream3 = Stream.of(1, 3, 21, 54, 34, 6, 9, 7, 11);
foreach 遍历
stream3.forEach(System.out::println);
count统计
Stream<String> stream4 = Stream.of("hello", "world","hello");
long count = stream4.filter(s -> s.startsWith("hello")).count(); //2
collect收集
collect方法用于收集流中间操作完后的元素，至于收集成哪种类型的数据结构需要通过Collectors收集器指定，常见的有Collectors.toList()、Collectors.toSet()、Collectors.toMap()
Stream<Integer> stream6 = Stream.of(1, 3, 21, 54, 34, 6, 9, 7, 11);
List<Integer> streamTolist = stream6.collect(Collectors.toList());
Set<Integer> streamToSet = stream6.collect(Collectors.toSet());
Map<String,Integer > streamToMap = personlist.stream().collect(Collectors.toMap(Person::getName,Person::getAge));
// {皮卡丘=24, 喷火龙=25, 肯泰罗=25, 波克比=22}