Stream流式计算

一.什么是Stream流式计算（学习此之前，要先知道四大函数式接口）

        1.常用的集合是为了存储数集，而对于集合数据的一些处理（像筛选集合数据等）可以使用Stream流来处理
        2.java.util.tream包下的Stream接口 支持顺序和并行聚合操作的一系列元素
        3.Stream流可以结合四大函数式接口进行数据处理（方法的参数支持函数式接口）
使用

        4.集合.stream() 可以将集合对象 转为 流对象，调用流对象的一些方法进行数据操作
二.常用方法
        1.filter(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的元素组成的流。
        2.count() 返回此流中的元素数。
        3.forEach(Consumer<? super T> action) 对此流的每个元素执行操作。
        4.sorted(Comparator<? super T> comparator) 返回由该流的元素组成的流，根据提供的 Comparator进行排序。
        5.map(Function<? super T,? extends R> mapper)返回由给定函数应用于此流的元素的结果组成的流。

结合下面的代码举例，你就会对此有更深刻的理解

package study_stream;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
 
public class Demo1 {
    public static void main(String[] args) {
 
        User user1 = new User("xiaosi1",20,18000);
        User user2 = new User("xiaosi2",21,19000);
        User user3 = new User("xiaosi3",23,20000);
        User user4 = new User("xiaosi4",24,21000);
        User user5 = new User("xiaosi5",25,22000);
        User user6 = new User("xiaosi6",26,23000);
 
        List<User> list = Arrays.asList(user1,user2,user3,user4,user5,user6);
 
        // 1. forEach
 
        list.stream().forEach((user)->{
            System.out.println(user);
 
        });
 
        list.stream().close();
 
        System.out.println("===================");
 
 
        //2.  filter、Predicate判定式函数接口
        // 筛选年龄在21之上，薪水在20000以上的user
 
        list.stream().
                filter((user)->{ return user.getSalary() > 20000; }).
                filter((user)->{return user.getAge()>= 21; }).
                forEach(System.out::println);
 
 
        list.stream().close();
 
        System.out.println("==================");
 
        // 3. map(Function<? super T,? extends R> mapper)
        //返回由给定函数应用于此流的元素的结果组成的流。
        // salary排序
 
        list.stream().
                filter((user)->{return user.getSalary() < 20000; }).
                map((user)->{ return user.getSalary() + 2000; }). // 返回salary,18000 + 2000 、19000 + 2000
                sorted((u1,u2)->{ return u1.compareTo(u1); }).
                forEach(System.out::println);
 
 
        list.stream().close();
 
    }
 
 
 
 
}
 
 
 
class User{
    private String name;
    private int age;
    private int salary;
 
    public User(String name, int age, int salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
 
    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 int getSalary() {
        return salary;
    }
 
    public void setSalary(int salary) {
        this.salary = salary;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}
 
输出:
 
User{name='xiaosi1', age=20, salary=18000}
User{name='xiaosi2', age=21, salary=19000}
User{name='xiaosi3', age=23, salary=20000}
User{name='xiaosi4', age=24, salary=21000}
User{name='xiaosi5', age=25, salary=22000}
User{name='xiaosi6', age=26, salary=23000}
===================
User{name='xiaosi4', age=24, salary=21000}
User{name='xiaosi5', age=25, salary=22000}
User{name='xiaosi6', age=26, salary=23000}
==================
20000
21000