运维开发网

Java8中Stream的排序,查找和匹配的用法

运维开发网 https://www.qedev.com 2020-03-07 16:45 出处:51CTO 作者:孤魂1996
Java8中Stream的排序,查找和匹配的用法

Java8中Stream的排序,查找和匹配的用法

排序

  1. sorted( )---自然排序
  2. sorted(Comparator com)---定制排序

    public class Employee {
    
    private String name;
    private Integer age;
    private Double salary;
    private Status status;
    
    public Employee() {
        super();
    }
    
    public  Employee(Integer age){
        this.age = age;
    }
    
    public Employee(String name, Integer age, Double salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    
    public Employee(String name, Integer age, Double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(Integer age) {
        this.age = age;
    }
    
    public double getSalary() {
        return salary;
    }
    
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    
    public Status getStatus() {
        return status;
    }
    
    public void setStatus(Status status) {
        this.status = status;
    }
    
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", status=" + status +
                '}';
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
    
    public enum Status{
        FREE,
        BUSY,
        VOCATION;
    }
    }
    @Test
    public void test1(){
        List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
    
        //自然排序
        list.stream()
            .sorted()
            .forEach(System.out::println);
    
        System.out.println("------------------------------");
    
        //定制排序
        employees.stream()
                 .sorted((e1, e2) -> {
                     if (e1.getAge() == e2.getAge()){
                         return e1.getName().compareTo(e2.getName());
                     }else{
                         return Integer.compare(e1.getAge(), e2.getAge());
                     }
                 }).forEach(System.out::println);
    }

    查找与匹配

  3. allMatch---检查是否匹配所有元素
  4. anyMatch---检查是否至少匹配一个元素
  5. noneMatch---检查是否没有匹配所有元素
  6. findFirst---返回第一个元素
  7. findAny---返回当前流中的任意元素
  8. count---返回流中元素的总个数
  9. max---返回流中最大值
  10. min---返回流中最小值

    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18 ,9999.99, Employee.Status.FREE),
            new Employee("李四", 38, 5555.99, Employee.Status.BUSY),
            new Employee("王五", 50, 6666.66, Employee.Status.VOCATION),
            new Employee("赵六", 16, 3333.33, Employee.Status.FREE),
            new Employee("田七", 8, 7777.77, Employee.Status.BUSY)
    );
    @Test
    public void test2(){
        //allMatch---检查是否匹配所有元素
        boolean b1 = employees.stream()
                .allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b1);
    
        //anyMatch---检查是否至少匹配一个元素
        boolean b2 = employees.stream()
                 .anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b2);
    
        //noneMatch---检查是否没有匹配所有元素
        boolean b3 = employees.stream()
                 .noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b3);
    
        //findFirst---返回第一个元素
        Optional<Employee> op = employees.stream()
                 .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
                 .findFirst();
        System.out.println(op.get());
    
        //findAny---返回当前流中的任意元素
        Optional<Employee> op2 = employees.stream()
                 .filter((e) -> e.getStatus().equals(Employee.Status.FREE))
                 .findAny();
        System.out.println(op2.get());
    }
    
    @Test
    public void test3(){
        //count---返回流中元素的总个数
        Long count = employees.stream()
                 .count();
        System.out.println(count);
    
        //max---返回流中最大值
        Optional<Employee> op1 = employees.stream()
                .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(op1.get());
    
        //min---返回流中最小值
        Optional<Double> op2 = employees.stream()
                .map(Employee::getSalary)
                .min(Double::compare);
        System.out.println(op2.get());
    }
0

精彩评论

暂无评论...
验证码 换一张
取 消