image.png
- 中间操作（Intermediate Operations）：中间操作会返回一个新的流，一个流可以后面跟随零个或多个intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后会返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。而是在终端操作开始的时候才真正开始执行。
- 终端操作（Terminal Operations）：是指返回最终的结果。一个流只能有一个terminal操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect。
- 中间操作与结束操作，中间操作只是对操作进行了记录，只有结束操作才会触发实际的计算（即惰性求值），这也是Stream在迭代大集合时高效的原因之一
image.png
demo
test1();
test3();
}
//获取流的三步：
//1. 创建stream
//2. 中间操作
//3. 终止stream
// c创建stream有4种方法
public static void test1(){
//1 Collection系列创建stream
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
//2 数组创建stream
String[] array = new String[10];
//Stream<String> stream1 = Arrays.stream(array);
//3 stream.of
Stream<String> stream2 = Stream.of("a","b");
//4. 创建无线流
}
// 终止操作
public static void test2(){
Stream<String> stream2 = Stream.of("a","b");
//void forEach(Consumer<? super T> action);
// stream2.forEach((x) -> x = x + 1 );
String b = "a" + 1;
stream2.forEach(System.out::print);
stream2.limit(1).forEach(System.out::print);
List<Person> list = Arrays.asList(new Person(1),new Person(2),new Person(3));
//filter的参数：Stream<T> filter(Predicate<? super T> predicate);
Stream<Person> stream = list.stream().filter((e) -> e.getAge() > 2);
}
// 中间操作不会有任何结果，需要终止操作
public static void test3() {
List<Person> list = Arrays.asList(new Person(1), new Person(2), new Person(3));
//filter的参数：Stream<T> filter(Predicate<? super T> predicate);
Stream<Person> stream = list.stream().filter((e) -> {
System.out.println("中间操作不会打印");
return e.getAge() > 2;
}).limit(2); //如果list有1万个， 只要找到符合条件的2个就停止遍历，也叫短路，提高效率
stream.forEach(System.out::print);
}
image.png
//映射
public static void test4(){
List<Person> list = Arrays.asList(new Person(1), new Person(2), new Person(3));
//map的参数是函数式接口：<R> Stream<R> map(Function<? super T, ? extends R> mapper);
list.stream().map((x) -> x.getAge()).forEach(System.out::print);
list.stream().map(Person::getAge).forEach(System.out::print);
}
//映射
public static void test5(){
List<String> list = Arrays.asList("aaa","bbb","ccc");
Stream<Stream<Character>> stream = list.stream().map(TestStream1::filterChacter);
stream.forEach((sm) ->{
sm.forEach(System.out::print);
});
Stream<Character> stream2 = list.stream().flatMap(TestStream1::filterChacter);
}
public static Stream<Character> filterChacter(String str){
List<Character> list = new ArrayList<>();
for(Character c : str.toCharArray()){
list.add(c);
}
return list.stream();
[图片上传中...(image.png-e5423c-1648230765636-0)]
}
image.png
//排序
public static void test6() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.stream().sorted().forEach(System.out::print);
}
终止操作
image.png
//终止、查找操作
public static void test7() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc");
//匹配所有的才返回true
//参数：boolean anyMatch(Predicate<? super T> predicate);
boolean matchAll = list.stream().allMatch((x) -> x.equals("aaaa"));
boolean any = list.stream().anyMatch((x) -> x.equals("aaaa"));
boolean none = list.stream().noneMatch((x) -> x.equals("aaaa"));
Optional<String> op = list.stream().findFirst();
String value = op.get();
Optional<String> op2 = list.stream().findAny();
}
[图片上传中...(image.png-a3f50f-1648309034182-0)]
image.png
规约
image.png
//归并
public static void test8() {
List<Integer> list = Arrays.asList(1,2,3,4,5);
//T reduce(T identity, BinaryOperator<T> accumulator);
//因为有起始值，所以不会为空
int totla = list.stream().reduce(0,(x,y)->x+y);
//因为没有起始值，所有可能返回值会为空
Optional<Integer> optional = list.stream().reduce(Integer::sum);
}
//收集
image.png
//收集
public static void test9() {
List<Person> list = Arrays.asList(new Person(1), new Person(2), new Person(3));
List<Integer> ages = list.stream().map(Person::getAge).collect(Collectors.toList());
Set<Integer> sets = list.stream().map(x -> x.getAge()).collect(Collectors.toSet());
//Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
HashSet<Integer> hs = list.stream().map(Person::getAge).collect(Collectors.toCollection(HashSet::new));
}
image.png
//分组
//分组
public static void test10() {
List<Person> list = Arrays.asList(new Person(1), new Person(2), new Person(3));
//分组，可以是age，value是分组后的list
//list.stream().collect(Collectors.groupingBy(x -> x.getAge()));
Map<Integer,List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getAge));
//也支持多级分组，可以无限分下去
Map<Integer,Map<Integer,List<Person>>> map2 = list.stream().collect(Collectors.groupingBy(Person::getAge,Collectors.groupingBy(Person::getAge)));
String s = list.stream().map(x->x.getName()).collect(Collectors.joining(","));
}
image.png
image.png
image.png
减少空指针异常
image.png
image.png
image.png
public interface TestInterface1 {
default String getName(){
return "aaaa";
}
public static void getAge(){
System.out.println("age");
}
}
