示例代码
package com.debuggg.java.exer5;
import com.debuggg.java.exer4.Employee;
import com.debuggg.java.exer4.EmployeeData;
import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/**
* 作者 ZYL
* 功能描述 :
* 1.Stream 关注的是对数据的运算，与CPU打交道
* 集合关注的是数据的存储，与内存打交道
* 2.
* 1）Stream 自己不会存储元素
* 2）Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
* 3）Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
*
* 3.Stream 执行流程
* 1）Stream的实例化
* 2）一系列的中间操作（过滤，映射，。。。）
* 3）终止操作
* 4.说明：
* 1）一个中间操作链，对数据源的数据进行处理
* 2）一旦执行终止操作，就执行中间操作链，并产生结果，之后，不会再被使用
*
* 测试Strem的实例化
* 日期 2020-03-01 18:32
* 参数 null
* 返回值
*/
public class StreamAPITest {
/**
* 作者 ZYL
* 功能描述 : 创建Stream方式一：通过集合
* java8中的Collection接口被扩展，提供了两个获取流的方法
* 1)default Stream<E> stream():返回一个顺序流
* 2)default Stream<E> parallelStream():返回一个并行流
*
* 日期 2020-03-01 18:38
* 参数
* 返回值 void
*/
@Test
public void test1(){
List<Employee> employees = EmployeeData.getEmployees();
// 1)default Stream<E> stream():返回一个顺序流
Stream<Employee> stream = employees.stream();
// default Stream<E> parallelStream():返回一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
}
/**
* 作者 ZYL
* 功能描述 : 创建Stream方式二：通过数组
* java8中的Arrays的静态方法stream()可以获取数组流：
* 1）static <T> Stream<T> stream(T[] array):返回一个流
* 重载形式，能够处理对应基本类型的数组：
* 2）public static IntStream stream(int[] array)
* 3）public static LongStream stream(long[] array)
* 4）public static DoubleStream stream(double[] array)
*
* 日期 2020-03-01 18:43
* 参数
* 返回值 void
*/
@Test
public void test2(){
String[] strings = {"马化腾", "马云"};
Stream<String> stream = Arrays.stream(strings);
int[] ints = {1,2,3};
IntStream stream1 = Arrays.stream(ints);
}
/**
* 作者 ZYL
* 功能描述 : 创建Stream方式三：通过Stream的of()
* 可以调用Stream类静态方法of(),通过显示值创建一个流，它可以接受任意数量的参数
* 1.public static<T> Stream<T> of(T... values):返回一个流
* 日期 2020-03-01 19:06
* 参数
* 返回值 void
*/
@Test
public void test3(){
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
}
/**
* 作者 ZYL
* 功能描述 : 创建Stream方式四：创建无限流
* 可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流
* 1）迭代
* public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
* 2）生成
* public static<T> Stream<T> generate(Supplier<T> s)
* 日期 2020-03-01 19:10
* 参数
* 返回值 void
*/
@Test
public void test4(){
//遍历前十个偶数
Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out :: println);
//获取10个随机数并遍历处理啊
Stream.generate(() -> Math.random()).limit(10).forEach((d) -> System.out.println(d));
}
/**
* 作者 ZYL
* 功能描述 : Stream的中间操作
* 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，
* 否则中间操作不会执行任何处理！而在终止操作时一次性全部处理，称为“惰性求值”
* 1.筛选与切片方法：
* filter(Predicate p) 接收Lambda,从流中排除某些元素
* distinct() 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
* limit(long maxSize) 截断流，使其元素不超过给定水浪
* skip(long n) 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补
*
* 2.映射
* map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
* mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
* mapToInt(ToIntFunction f) 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
* mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
* flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
*
* 3.排序
* sorted() 产生一个新流，其中按自然顺序排序
* sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
*
* 日期 2020-03-01 19:22
* 参数 null
* 返回值
*/
/**
* 作者 ZYL
* 功能描述 : 筛选与切片
* 日期 2020-03-01 23:36
* 参数
* 返回值 void
*/
@Test
public void test5(){
// * 1.筛选与切片方法：
// *
// * filter(Predicate p) 接收Lambda,从流中排除某些元素
Stream<Employee> stream = EmployeeData.getEmployees().stream();
//过滤工资大于7000的employee
// stream.filter(e -> e.getSalary() > 7000).forEach(System.out :: println);
// * distinct() 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
// stream.distinct().forEach(System.out::println);
// * limit(long maxSize) 截断流，使其元素不超过给定水浪
// stream.limit(5).forEach(System.out::println);
// * skip(long n) 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补
//跳过2个，去重，过滤工资大于6000，限制取1的写法
stream.skip(2).distinct().filter(e -> e.getSalary() > 6000).limit(1).forEach(System.out::println);
}
/**
* 作者 ZYL
* 功能描述 :
* * 2.映射
* * map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
* * mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
* * mapToInt(ToIntFunction f) 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
* * mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
* * flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
* 日期 2020-03-01 23:54
* 参数 null
* 返回值
*/
@Test
public void test6(){
List<Employee> employees = EmployeeData.getEmployees();
Stream<Employee> stream = employees.stream();
String[] strings = {"aa", "bb", "cc", "dd"};
Stream<String> stream1 = Arrays.stream(strings);
stream1.map(String::toUpperCase).forEach(System.out::println);
//给每个员工涨工资5000
// stream.map(e -> {
// e.setSalary(e.getSalary() + 5000.0);
// return e;
// }).forEach(System.out::println);
// * map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
//获取员工姓名长度大于3的
employees.stream().map(Employee::getName).filter(e -> e.length() > 3).forEach(System.out::println);
System.out.println();
//获取工资的列表清单
employees.stream().mapToDouble(e -> e.getSalary()).forEach(System.out::println);
// * mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
System.out.println();
//获取年龄清单
employees.stream().mapToInt(Employee::getAge).forEach(System.out::println);
// * mapToInt(ToIntFunction f) 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
//获取年龄清单，并且将年龄设置成Long型
employees.stream().mapToLong(Employee::getAge).forEach(System.out::println);
// * mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
// * flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
System.out.println();
//将strings的字符拆散
Arrays.stream(strings).flatMap(StreamAPITest::formString2Stream).forEach(System.out::println);
//等价于
System.out.println();
Stream<Stream<Character>> streamStream = Arrays.stream(strings).map(StreamAPITest::formString2Stream);
streamStream.forEach( s -> s.forEach(System.out::println));
}
public static Stream<Character> formString2Stream(String str){
List<Character> list = new ArrayList<>();
for (char c : str.toCharArray()) {
list.add(c);
}
return list.stream();
}
/**
* 作者 ZYL
* 3.排序
* sorted() 产生一个新流，其中按自然顺序排序
* sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
* 日期 2020-03-02 0:05
* 参数 null
* 返回值
*/
@Test
public void test7(){
// * 3.排序
// * sorted() 产生一个新流，其中按自然顺序排序
List<Employee> employees = EmployeeData.getEmployees();
//构造器中的比较方法，按照工资的升序排序
employees.stream().sorted().forEach(System.out::println);
System.out.println();
// * sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
//按照工资从高到底排序
employees.stream().sorted((o1,o2) -> -o1.getSalary().compareTo(o2.getSalary())).forEach(System.out::println);
}
/**
* 作者 ZYL
* 功能描述 : Strem的终止操作
* 1.终端操作会从流的流水线生成结果，其结果可以时任何不是流的值，例如：List,Integer,甚至时void
* 2.流进行了终止操作之后，不能再次使用
*
* 3.具体操作
* 1）匹配与查找
* ①allMatch(Predicate p) 检查是否匹配所有元素
* ②anyMatch(Predicate p) 检查是否至少匹配一个元素
* ③noneMatch(Predicate p) 检查是否一个都没有匹配上
* ④findFirst() 返回第一个元素
* ⑤findAny() 返回当前流中的任意元素
* ⑥count() 返回流中的元素总数
* ⑦max(Comparator c) 返回流中的最大值
* ⑧min(Comparator c) 返回流中的最小值
* ⑨forEach(Consumer c)内部迭代（使用Collection接口需要用户取做迭代，成为外部迭代。相反
* Stream API使用内部迭代----它帮你把迭代做了）
* 2）规约
* ①reduce(T iden,BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回T
* ②reduce(BinaryOperator b) 可以将流中元素反复结合起来得到一个值。返回Optional<T>
* 备注：map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名
* 3）收集
* ①collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
* Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
* 另外：Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
* 日期 2020-03-02 0:55
* 参数 null
* 返回值
*/
/**
* 作者 ZYL
* 功能描述 : 匹配与查找i
* 日期 2020-03-02 0:59
* 参数 null
* 返回值
*/
@Test
public void test8(){
// * ①allMatch(Predicate p) 检查是否匹配所有元素
int[] ints = {1, 2, 3, -9, 20, -38, 100, 88};
System.out.println(Arrays.stream(ints).allMatch(s -> s > 80));
System.out.println();
// * ②anyMatch(Predicate p) 检查是否至少匹配一个元素
System.out.println(Arrays.stream(ints).anyMatch(s -> s > 80));
System.out.println();
// * ③noneMatch(Predicate p) 检查是否一个都没有匹配上
System.out.println(Arrays.stream(ints).noneMatch(s -> s > 80));
System.out.println();
// * ④findFirst() 返回第一个元素
System.out.println(Arrays.stream(ints).findFirst());
System.out.println();
// * ⑤findAny() 返回当前流中的任意元素
System.out.println(Arrays.stream(ints).findAny());
System.out.println();
// * ⑥count() 返回流中的元素总数
System.out.println(Arrays.stream(ints).count());
System.out.println();
// * ⑦max(Comparator c) 返回流中的最大值
System.out.println(Arrays.stream(ints).max());
System.out.println();
// * ⑧min(Comparator c) 返回流中的最小值
System.out.println(Arrays.stream(ints).min());
System.out.println();
// * ⑨forEach(Consumer c)内部迭代（使用Collection接口需要用户取做迭代，成为外部迭代。相反
Arrays.stream(ints).forEach(System.out::println);
System.out.println();
// * Stream API使用内部迭代----它帮你把迭代做了）
}
/**
* 作者 ZYL
* 功能描述 :
* 2）规约
* ①reduce(T iden,BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回T
* ②reduce(BinaryOperator b) 可以将流中元素反复结合起来得到一个值。返回Optional<T>
* 备注：map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名
* 日期 2020-03-02 1:23
* 参数 null
* 返回值
*/
@Test
public void test9(){
int[] ints = {1, 2, -3};
OptionalInt reduce = Arrays.stream(ints).reduce((i1, i2) -> i1 * i2);
System.out.println(reduce);
}
/**
* 作者 ZYL
* 功能描述 :
* 3）收集
* ①collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
* Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
* 另外：Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
* 日期 2020-03-02 1:41
* 参数 null
* 返回值
*/
@Test
public void test10(){
List<Integer> list = Arrays.asList(1, 2, 3, -9, 20, -38, 100, 88);
Set<Integer> collect = list.stream().filter(i -> i > 0).collect(Collectors.toSet());
list.stream().filter(i -> i > 0).collect(Collectors.toList());
System.out.println(collect);
// * 3）收集
// * ①collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
// * Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
// * 另外：Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
}
}
Employee代码
package com.debuggg.java.exer4;
import java.util.Objects;
public class Employee implements Comparable<Employee>{
private Integer id;
private String name;
private Integer age;
private Double salary;
public Employee() {
}
public Employee(Integer id, String name, Integer age, Double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public Employee(Integer id) {
this.id = id;
}
public Employee(Integer id,String name) {
this.id = id;
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return Objects.equals(id, employee.id) &&
Objects.equals(name, employee.name) &&
Objects.equals(age, employee.age) &&
Objects.equals(salary, employee.salary);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age, salary);
}
@Override
public int compareTo(Employee o) {
return this.salary.compareTo(o.getSalary());
}
}
EmployeeData代码
package com.debuggg.java.exer4;
import java.util.ArrayList;
import java.util.List;
public class EmployeeData {
public static List<Employee> getEmployees(){
List<Employee> list = new ArrayList<>();
list.add(new Employee(1001,"马化腾",34,6000.38));
list.add(new Employee(1002,"马云",12,9876.12));
list.add(new Employee(1003,"刘强东",33,3000.82));
list.add(new Employee(1004,"雷军",26,7567.37));
list.add(new Employee(1005,"李彦宏",65,5555.32));
list.add(new Employee(1006,"比尔盖茨",42,9500.43));
list.add(new Employee(1007,"任正非",26,4333.32));
list.add(new Employee(1008,"扎克伯格",35,2500.32));
list.add(new Employee(1008,"扎克伯格",35,2500.32));
return list;
}
}
更多内容请访问：IT源点
注意：本文归作者所有，未经作者允许，不得转载
