互联网网站备案,河北省建设厅网站工程师查询,安防网站源码,网站建设 400电话 广告一、概述
1 是什么
是数据渠道#xff0c;用于操作数据源#xff08;集合、数组等#xff09;所生成的元素序列。
Stream 不会存储数据Stream 不会改变数据源#xff0c;相反#xff0c;会返回一个持有结果的新Stream。Stream 操作是延迟执行的#xff0c;这意…一、概述
1 是什么
是数据渠道用于操作数据源集合、数组等所生成的元素序列。
Stream 不会存储数据Stream 不会改变数据源相反会返回一个持有结果的新Stream。Stream 操作是延迟执行的这意味着会等到需要结果的时候才执行。
2 Stream 和collection的区别 Connection是一种静态的内存数据结构Stream是有关计算的前者主要面向内存存储在内存中后者是面向CPU通过CPU实现计算。 集合讲的是数据Stream讲的是计算。
3 执行步骤
创建Stream 一个数据源会获取一个流中间操作 一个中间操作链对数据源的数据进行处理。终止操作终端操作 一旦执行终止操作就执行中间操作链并产生结果之后不会再被使用。
二、创建方式
1 通过集合
default StreamE stream() : 返回一个顺序流default StreamE parallelStream() : 返回一个并行流/*** 方式一: 通过集合创建流* default StreamE stream() ,返回一个顺序流* default StreamE parallelStream() ,返回一个并行流*/Testpublic void test1() {ListEmployee employees EmployeeData.getEmployee();// default StreamE stream() ,返回一个顺序流StreamEmployee stream employees.stream();// default StreamE parallelStream() ,返回一个并行流StreamEmployee parallelStream employees.parallelStream();}2 通过数组创建流
Java8 中的Arrays的静态方法stream()可以获取数据流。
static IntStream stream(int[] array)/*** 方式二: 通过数组创建流* Java8 中的Arrays的静态方法stream()可以获取数据流。* p* static IntStream stream(int[] array)*/Testpublic void test2() {int[] arr new int[]{1, 2, 3, 4, 5};// static IntStream stream(int[] array)IntStream stream Arrays.stream(arr);Employee employee1 new Employee(1002, 玛火腿, 34, 123);Employee employee2 new Employee(1003, tom, 23, 2222);Employee[] employees new Employee[]{employee1, employee2};StreamEmployee stream1 Arrays.stream(employees);}
3 通过Stream的of()
可以调用Stream类的静态方法of()通过显示值创建一个流。他可以接受任意数量的参数
public staticT StreamT of(T... values)/*** 方式三: 通过Stream的of()* 可以调用Stream类的静态方法of()通过显示值创建一个流。他可以接受任意数量的参数* public staticT StreamT of(T... values)*/Testpublic void test3() {StreamInteger integerStream Stream.of(1, 2, 3, 4, 5);}4 创建无限流
以使用静态方法Stream.iterate()和Stream.generate()创建无限流
/*** 方式四: 创建无限流* 可以使用静态方法Stream.iterate()和Stream.generate()创建无限流*/Testpublic void test4() {//迭代// public staticT StreamT iterate(final T seed, final UnaryOperatorT f)Stream.iterate(0, t - t 2).limit(10).forEach(System.out::println);//出生//public staticT StreamT generate(SupplierT s)Stream.generate(Math::random).limit(10).forEach(System.out::println);}
三、中间操作
1 筛选切片 多个中间操作可以连接起来形成一个流水线除非流水线上触发种植操作否则中间操作不会执行任何的处理而在种植操作时一次性全部处理称为“惰性求值”。
1. filter
从流中排除某些元素
StreamT filter(Predicate? super T predicate);/*** 从流中排除某些元素* StreamT filter(Predicate? super T predicate);* filter 中 参数 通过Lambda表达式 实现 Predicate 函数式接口*/Testpublic void test1() {ListEmployee employees EmployeeData.getEmployee();employees.stream().filter(e - e.getAge() 23).forEach(System.out::println);}2. limit
截断流 使元素不超过给定数量 /*** 截断流 使元素不超过给定数量* StreamT limit(long maxSize);*/Testpublic void test2() {ListEmployee employees EmployeeData.getEmployee();employees.stream().limit(5).forEach(System.out::println);}3. skip
掉过元素返回一个扔掉前n个元素的流若流中元素不足n个则返回一个空流 /*** 掉过元素返回一个扔掉前n个元素的流若流中元素不足n个则返回一个空流* StreamT skip(long n);*/Testpublic void test3() {ListEmployee employees EmployeeData.getEmployee();employees.stream().skip(5).forEach(System.out::println);}4. distinct
筛选通过流所生成的元素的hashcode()和equals()去除重复元素。 /*** 筛选 通过流所生成的元素的hashcode()和equals()去除重复元素。* StreamT distinct();*/Testpublic void test4() {ListEmployee employees EmployeeData.getEmployee();employees.stream().distinct().forEach(System.out::println);System.out.println(-----------------------------------------------------);employees.stream().forEach(System.out::println);}2 映射
1. map 接受一个函数作为参数将元素转换为其他形式或者提取信息该函数会被应用到每个元素上并将其映射成一个新的元素 /*** 映射* 接受一个函数作为参数将元素转换为其他形式或者提取信息该函数会被应用到每个元素上并将其映射成一个新的元素* R StreamR map(Function? super T, ? extends R mapper);*/Testpublic void test5() {ListEmployee employees EmployeeData.getEmployee();employees.stream().map(Employee::getName).filter(name - name.length() 3).forEach(System.out::println);}2. flatMap
接收一个函数作为参数将流中的每个值都换成另一个流然后把所有流连接成一个流。 /*** 接收一个函数作为参数将流中的每个值都换成另一个流然后把所有流连接成一个流。* R StreamR flatMap(Function? super T, ? extends Stream? extends R mapper);*/Testpublic void test6() {ListString list Arrays.asList(aa,bbbb);StreamStreamCharacter streamStream list.stream().map(Stream_api_test2::formStringtoStream);streamStream.forEach(System.out::println);System.out.println(-----------------------------------------------------);list.stream().map(Stream_api_test2::formStringtoStream).forEach(e-{e.forEach(System.out::println);});System.out.println(-----------------------------------------------------);StreamCharacter characterStream list.stream().flatMap(Stream_api_test2::formStringtoStream);characterStream.forEach(System.out::println);}/*** 将字符串中的多个字符构成的集合转换为对应Stream的实例* param str 字符串* return Stream实例*/public static StreamCharacter formStringtoStream(String str) {ListCharacter arrayList new ArrayList();for (Character s :str.toCharArray()) {arrayList.add(s);}StreamCharacter stream arrayList.stream();return stream;}3 排序
1. sorted-自然排序
自然排序 产生一个新的流其中按自然顺序排序 /*** 自然排序 产生一个新的流其中按自然顺序排序* StreamT sorted();*/Testpublic void test7() {ListInteger list Arrays.asList(23, 44, 34, 6, 1, 334, 546, 23, 1211, 453435, 2, 1, 3, 3);list.stream().sorted().forEach(System.out::println);}2. sorted-定制排序
定制排序 产生一个新的流其中按比较器顺序排序 /*** 定制排序 产生一个新的流其中按比较器顺序排序* StreamT sorted(Comparator? super T comparator);*/Testpublic void test8() {ListEmployee employees EmployeeData.getEmployee();employees.stream().sorted((e1, e2) - Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);}四、 终止操作
1 匹配 查找
1. allMatch
检查是否匹配所有元素所有元素匹配就是ture 否则为false /*** 检查是否匹配所有元素所有元素匹配就是ture 否则为false* boolean allMatch(Predicate? super T predicate);*/Testpublic void test1() {ListEmployee employees EmployeeData.getEmployee();//都大于18 则为ture否则为falseboolean b employees.stream().allMatch(e - e.getAge() 18);System.out.println(b);}2. anyMatch
检查是否至少一个匹配的元素有一个匹配就是ture 否则为false /*** 检查是否至少一个匹配的元素有一个匹配就是ture 否则为false* boolean anyMatch(Predicate? super T predicate);*/Testpublic void test2() {ListEmployee employees EmployeeData.getEmployee();//有一个大于33 则为ture否则为falseboolean b employees.stream().anyMatch(e - e.getAge() 33);System.out.println(b);}3. noneMatch
是否没有匹配的元素 有一个匹配就是false 全都不匹配则为ture /*** 是否没有匹配的元素 有一个匹配就是false 全都不匹配则为ture* boolean noneMatch(Predicate? super T predicate);*/Testpublic void test3() {ListEmployee employees EmployeeData.getEmployee();//有大于33的元素 则为false否则为tureboolean b employees.stream().noneMatch(e - e.getAge() 33);System.out.println(b);}4. findFirst
返回第一个元素 /*** 返回第一个元素* OptionalT findFirst();*/Testpublic void test4() {ListEmployee employees EmployeeData.getEmployee();OptionalEmployee employee employees.stream().findFirst();System.out.println(employee);}5. findAny
返回任意一个元素 /*** 返回任意一个元素* OptionalT findAny();*/Testpublic void test5() {ListEmployee employees EmployeeData.getEmployee();OptionalEmployee employee employees.stream().findAny();System.out.println(employee);}6. count
返回流中元素的总个数 /*** 返回流中元素的总个数* long count();*/Testpublic void test6() {ListEmployee employees EmployeeData.getEmployee();long count employees.stream().filter(e-e.getAge()30). count ();System.out.println(count);}7. max
返回流最大值 /*** 返回流最大值*/Testpublic void test7() {ListEmployee employees EmployeeData.getEmployee();OptionalEmployee maxEmployee employees.stream().max((e1, e2) - Integer.compare(e1.getAge(), e2.getAge()));System.out.println(maxEmployee);}8. min
返回流中最小值 /*** 返回流中最小值*/Testpublic void test8() {ListEmployee employees EmployeeData.getEmployee();OptionalEmployee maxEmployee employees.stream().min((e1, e2) - Integer.compare(e1.getAge(), e2.getAge()));System.out.println(maxEmployee);}9. forEach /*** 内部迭代*/Testpublic void test9() {ListEmployee employees EmployeeData.getEmployee();employees.stream().forEach(System.out::println);}2 规约
1. reduce-T
将流中的元素返回结合起来得到一个值返回 T /*** 将流中的元素返回结合起来得到一个值返回 T* T reduce(T identity, BinaryOperatorT accumulator);* T identity 为一个初始值*/Testpublic void test1() {ListInteger list Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);Integer reduce list.stream().reduce(0, Integer::sum);System.out.println(reduce);}2. reduce - Optional
将流中的元素返回结合起来得到一个值返回一个Optional
/*** 将流中的元素返回结合起来得到一个值返回一个OptionalT* OptionalT reduce(BinaryOperatorT accumulator);*/Testpublic void test2() {ListEmployee employees EmployeeData.getEmployee();OptionalDouble reduce employees.stream().map(Employee::getSalary).reduce(Double::sum);System.out.println(reduce);System.out.println(-------------------------------------);employees.stream().map(Employee::getSalary).reduce((d1, d2) - {System.out.println(d1 : d1);System.out.println(d2 : d2);System.out.println(d1 d2 : (d1 d2));System.out.println(-----------);return d1 d2;});}3 收集 将流转换为其他形式接受一个Collector接口的实现用于给Stream中元素做汇总的方法。Collector接口中发给发的实现决定了如何对流执行收集操作 如收集到 ListSetMap。Collector实用类提供了很多静态方法可以方便地创建收集器实例。如下 /*** 将流转换为其他形式接受一个Collector接口的实现用于给Stream中元素做汇总的方法* Collector接口中发给发的实现决定了如何对流执行收集操作 如收集到 ListSetMap* Collector实用类提供了很多静态方法可以方便地创建收集器实例。* R, A R collect(Collector? super T, A, R collector);*/Testpublic void test3() {ListEmployee employees EmployeeData.getEmployee();ListString collect employees.stream().filter(e-e.getAge()30).map(Employee::getName).collect(Collectors.toList());System.out.println(collect);System.out.println(-------------------------------------);SetString collect1 employees.stream().filter(e - e.getAge() 30).map(Employee::getName).collect(Collectors.toSet());System.out.println(collect1);}
