Stream
学习Stream流需要先了解什么事函数式接口，因为在Stream中的方法参数大都为函数式接口。
函数式接口
有且只有一个抽象方法的接口。函数式接口可以有多个非抽象方法；
Java中内置函数式接口
内置函数式接口：由java官方定义的一些常用的函数式接口。
-
消费型接口(Consumer)
抽象方法 void accept(T t);
传入一个参数数据，执行相应的业务逻辑。无返回值
-
供给型接口(Supplier)
抽象方法：T get();
无需参数，按照方法体中的业务逻辑，返回业务执行结果
-
函数型接口(Function)
抽象方法：R apply(T t);
接受一个参数数据，逻辑处理后，返回一个新的数据值
-
断言型接口(Predicate)
抽象方法：boolean test(T t);
传入参数后，逻辑判断处理后，返回boolean类型的值
Stream的使用
Stream流创建
方式1：根据Collection获取流，Collection接口中有一个stream方法，可以用来获取流
-
default Stream<E> stream()
方式2：使用Stream接口提供的of方法
-
public static
Stream of(T t) -
static
Stream of(T... values)
代码演示：
public class StreamTest {
final static ArrayList<String> LIST_STREAM = new ArrayList<>();
static {
LIST_STREAM.add("张三丰");
LIST_STREAM.add("张三");
LIST_STREAM.add("张学友");
LIST_STREAM.add("张惠美");
LIST_STREAM.add("张无忌");
LIST_STREAM.add("白眉鹰王");
LIST_STREAM.add("紫衫龙王");
LIST_STREAM.add("金毛狮王");
LIST_STREAM.add("青翼蝠王");
}
//方式1
@Test
public void createStreamMethodOneTest(){
LIST_STREAM.stream()
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 张三丰
* 张三
* 张学友
* 张惠美
* 张无忌
* 白眉鹰王
* 紫衫龙王
* 金毛狮王
* 青翼蝠王
*/
}
//方式2
@Test
public void createStreamMethodTwoTest(){
Stream.of("张三","王二","赵六")
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 张三
* 王二
* 赵六
*/
}
}
Steam之forEach方法
void forEach(Consumer<? super T> action) 遍历流中的每一个元素,并对元素进行相应的业务处理，无返回值
注意：forEach在Stream中是一个终结方法
@Test
public void createStreamMethodOneTest(){
LIST_STREAM.stream()
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 张三丰
* 张三
* 张学友
* 张惠美
* 张无忌
* 白眉鹰王
* 紫衫龙王
* 金毛狮王
* 青翼蝠王
*/
}
Steam之filter方法
Stream
筛选流中出符合条件的元素，并返回一个新的流
@Test
public void createStreamTest(){
LIST_STREAM.stream()
.filter(s -> s.startsWith("张"))
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 张三丰
* 张三
* 张学友
* 张惠美
* 张无忌
*/
}
Steam之count方法
long count()：统计元素的个数
注意：该方法是终结方法
@Test
public void countTest(){
long count = LIST_STREAM.stream()
.filter(s -> s.startsWith("张"))
.count();
System.out.println(count);
/**
* 输出结果：
* 5
*/
}
Steam之limit方法
Stream
获取流中的前n个元素，返回一个新的流对象
注意：limit的长度从1开始
collect(Collector<? super T, A, R> collector)
将Stream流对象转成集合对象
@Test
public void count(){
List<String> collect = LIST_STREAM.stream()
.limit(5)
.collect(Collectors.toList());
System.out.println(collect);
/**
* 输出结果：
* [张三丰, 张三, 张学友, 张惠美, 张无忌]
*/
}
Steam之skip方法
Stream
跳过Stream流对象中的前n个元素,返回一个新的Stream流对象
注意：skip中的参数从1开始，输出时不包含第n个元素
@Test
public void skipTest(){
LIST_STREAM.stream()
.skip(5)
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 白眉鹰王
* 紫衫龙王
* 金毛狮王
* 青翼蝠王
*/
}
Steam之concat方法
static
将两个流合并为一个流
注意：该方法为Stream接口中的方法
@Test
public void concat(){
Stream<String> stream = Stream.of("张三", "赵四");
Stream<String> stream1 = Stream.of("王五", "李六");
Stream.concat(stream, stream1)
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 张三
* 赵四
* 王五
* 李六
*/
}
Steam之map方法
对流中的每一个元素进行对应的业务处理，并返回一个新的流
@Test
public void mapTest(){
LIST_STREAM.stream()
.map(s -> s+"...")
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 张三丰...
* 张三...
* 张学友...
* 张惠美...
* 张无忌...
* 白眉鹰王...
* 紫衫龙王...
* 金毛狮王...
* 青翼蝠王...
*/
}
Steam之flapMap方法
将流中的元素分别进行业务处理后，作为流返回。然后将每个元素流作为流返回
@Test
public void flatMapTest(){
LIST_STREAM.stream()
.filter(s -> !s.startsWith("张"))
.flatMap(s -> Stream.of(s).map(s1 -> s1 + "..."))
.forEach(s -> System.out.println(s));
/**
* 输出结果：
* 白眉鹰王...
* 紫衫龙王...
* 金毛狮王...
* 青翼蝠王...
*/
}
Stream中map和flapMap的区别
map中的参数返回的是R,而flap中的参数返回的是Stream<? extends R>
这导致map所操作的流依然是之前流，
但是flapMap却把流中的每一个元素分别变为了流，然后将这些流封装为一个流进行返回。
@Test
public void distinctionOfMapAndFlapMapTest(){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> list1 = Arrays.asList(6, 7, 8, 9, 10);
ArrayList<List<Integer>> lists = new ArrayList<>();
lists.add(list);
lists.add(list1);
List<Integer> collect = lists.stream()
.flatMap(s -> s.stream().map(s1 -> s1 * 2))
.collect(Collectors.toList());
System.out.println(collect);
/**
* flatmap的作用 —— 把嵌套集合，按照子集合的形式，统一放入到新的一个集合中去，这就叫结果展平！
* 例如：一个年级的学生，按照班级为单位，如今年段长想统计该年段所有的学生信息，一个flatmap就能轻松搞定，无需再for循环取遍历获取了。
*/
}