JDK8 StreamApi--Stream流

java小白_hak

已于 2022-08-28 19:16:19 修改

阅读量401

点赞数 1

分类专栏： java # JDK8 文章标签： java c# spring

于 2020-08-28 20:15:03 首次发布

本文链接：https://blog.csdn.net/Platinum_stars/article/details/108285254

版权

java 同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

JDK8

3 篇文章 0 订阅

订阅专栏

Stream

Stream关注的是对数据的运算，与CPU打交道
集合关注的是数据的存储，与内存打交道

①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

Stream 执行流程
① Stream的实例化
② 一系列的中间操作（过滤、映射、…)
③ 终止操作

说明：
一个中间操作链，对数据源的数据进行处理
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

创建方式

用于测试类

/**
 * @author shkstart 邮箱：shkstart@126.com
 */
public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Employee() {
		System.out.println("Employee().....");
	}

	public Employee(int id) {
		this.id = id;
		System.out.println("Employee(int id).....");
	}

	public Employee(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public Employee(int id, String name, int age, double salary) {

		this.id = id;
		this.name = name;
		this.age = age;
		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;

		if (id != employee.id)
			return false;
		if (age != employee.age)
			return false;
		if (Double.compare(employee.salary, salary) != 0)
			return false;
		return name != null ? name.equals(employee.name) : employee.name == null;
	}

	@Override
	public int hashCode() {
		int result;
		long temp;
		result = id;
		result = 31 * result + (name != null ? name.hashCode() : 0);
		result = 31 * result + age;
		temp = Double.doubleToLongBits(salary);
		result = 31 * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
}

/*************************************************/
/**
 * 提供用于测试的数据
 * 
 * @author shkstart 邮箱：shkstart@126.com
 *
 */
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, 7657.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));
		
		return list;
	}

创建 Stream方式一：通过集合

		List<Employee> employees = EmployeeData.getEmployees();

        // default Stream<E> stream() : 返回一个顺序流
        Stream<Employee> stream = employees.stream();

        // default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();

创建 Stream方式二：通过数组

		int[] arr = {1, 2, 3, 4, 5, 6};
        // 调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001, "aa");
        Employee e2 = new Employee(1002, "bb");
        Employee e3 = new Employee(1003, "cc");
        Employee e4 = new Employee(1004, "dd");
        Employee[] arr1 = {e1, e2, e3, e4};
        Stream<Employee> stream1 = Arrays.stream(arr1);

创建 Stream方式三：通过Stream的of()

		Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

创建 Stream方式四：创建无限流

        // 迭代
        // public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        // 遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

        // 生成
        // public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

Stream的中间操作

筛选与切片

filter(Predicate p)——接收 Lambda ，从流中排除某些元素。

limit(n)——截断流，使其元素不超过给定数量。

skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

        List<Employee> list = EmployeeData.getEmployees();
        // filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        // 练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        System.out.println();
        // limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();
        // skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(3).forEach(System.out::println);
        System.out.println();
        // distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 41, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        // System.out.println(list);
        list.stream().distinct().forEach(System.out::println);

映射

map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。

flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

        // map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

        // 练习1：获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().map(Employee::getName).filter(name -> name.length() > 3).forEach(System.out::println);

        // 练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamApiTest2::fromStringToStream);
        streamStream.forEach(s -> s.forEach(System.out::println));
        System.out.println("************");
        // flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamApiTest2::fromStringToStream);
        characterStream.forEach(System.out::println);

	    // 将字符串中的多个字符构成的集合转换为对应的Stream的实例
	    private static Stream<Character> fromStringToStream(String str) {
	        ArrayList<Character> list = new ArrayList<>();
	        for (char c : str.toCharArray()) {
	            list.add(c);
	        }
	        return list.stream();
	    }

排序

sorted()——自然排序

sorted(Comparator com)——定制排序

        // sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 32, 421, 1, 32, 55);
        list.stream().sorted().forEach(System.out::println);
        // 抛异常，原因:Employee没有实现Comparable接口
        // List<Employee> employees = EmployeeData.getEmployees();
        // employees.stream().sorted().forEach(System.out::println);


        // sorted(Comparator com)——定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1, e2) -> {

            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0) {
                return ageValue;
            } else {
                return -Double.compare(e1.getSalary(), e2.getSalary());
            }

        }).forEach(System.out::println);
//        employees.stream().sorted(Comparator.comparingInt(Employee::getAge)).forEach(System.out::println);

Stream的终止操作

allMatch(Predicate p)——检查是否匹配所有元素。

anyMatch(Predicate p)——检查是否至少匹配一个元素。

noneMatch(Predicate p)——检查是否没有匹配的元素。

findFirst——返回第一个元素

findAny——返回当前流中的任意元素

count——返回流中元素的总个数

max(Comparator c)——返回流中最大值

min(Comparator c)——返回流中最小值

forEach(Consumer c)——内部迭代

reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T

reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional

collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

        List<Employee> employees = EmployeeData.getEmployees();

        // allMatch(Predicate p)——检查是否匹配所有元素。
        // 练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

        // anyMatch(Predicate p)——检查是否至少匹配一个元素。
        // 练习：是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

        // noneMatch(Predicate p)——检查是否没有匹配的元素。
        // 练习：是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);

        // findFirst——返回第一个元素
        Optional<Employee> optional = employees.stream().findFirst();
        Employee employee = optional.orElse(null);
        System.out.println(employee);

        // findAny——返回当前流中的任意元素
        Optional<Employee> optional1 = employees.stream().findAny();
        System.out.println(optional1);

        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

        // max(Comparator c)——返回流中最大值
        // 练习：返回最高的工资：
        Stream<Double> doubleStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> max = doubleStream.max(Double::compare);
        System.out.println(max);

        // min(Comparator c)——返回流中最小值
        // 练习：返回最低工资的员工
//        Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        Optional<Employee> min = employees.stream().min(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(min);

        // forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);

        // 使用集合的遍历操作
        employees.forEach(System.out::println);
        
        // reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
        // 练习1：计算1-10的自然数的和
        List<Integer> 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);

        // reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
        // 练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> reduce1 = employees.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println(reduce1);

        // collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
        // 练习1：查找工资大于6000的员工，结果返回为一个List或Set
        List<Employee> list = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        list.forEach(System.out::println);
        System.out.println();
        Set<Employee> set = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        set.forEach(System.out::println);

本文链接： https://blog.csdn.net/Platinum_stars/article/details/108285254

java小白_hak

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JDK8 StreamApi--Stream流

StreamStream关注的是对数据的运算，与CPU打交道集合关注的是数据的存储，与内存打交道①Stream 自己不会存储元素。②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行Stream 执行流程① Stream的实例化② 一系列的中间操作（过滤、映射、…)③ 终止操作说明：一个中间操作链，对数据源的数据进行处理一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
复制链接

扫一扫