Stream流的使用

首先创建一个实体类Order（订单），定义四个属性并重写equals、toString等方法

import java.time.LocalDateTime;
import java.util.*;

class Order {
    private String orderId;
    private String productName;
    private double price;
    private LocalDateTime orderTime;

    // 构造方法、getter和setter这里省略
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Order order = (Order) o;
        return Double.compare(order.price, price) == 0 &&
                Objects.equals(orderId, order.orderId) &&
                Objects.equals(productName, order.productName) &&
                Objects.equals(orderTime, order.orderTime);
    }
    //重写HashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(orderId, productName, price, orderTime);
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public LocalDateTime getOrderTime() {
        return orderTime;
    }

    public void setOrderTime(LocalDateTime orderTime) {
        this.orderTime = orderTime;
    }

    // 重写toString方法，否则输出的是对象的内存空间
    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + '\'' +
                ", productName='" + productName + '\'' +
                ", price=" + price +
                ", orderTime=" + orderTime +
                '}';
    }
}

之后在实际应用中熟悉stream流，先塞一些代码到集合中

 Order order1 = new Order();
        order1.setOrderTime(LocalDateTime.now());
        order1.setProductName("鱼罐头");
        order1.setOrderId("001");
        order1.setPrice(10);
        Order order2 = new Order();
        order2.setOrderTime(LocalDateTime.now());
        order2.setProductName("辣条");
        order2.setOrderId("002");
        order2.setPrice(0.5);
        Order order3 = new Order();
        order3.setOrderTime(LocalDateTime.now());
        order3.setProductName("冰红茶");
        order3.setOrderId("003");
        order3.setPrice(3);

        ArrayList<Order> orders = new ArrayList<>();
        orders.add(order1);
        orders.add(order2);
        orders.add(order3);

1、filter方法：过滤方法，filter 方法是一个非常常用的中间操作，用于从流中筛选出符合给定条件的元素。filter 方法接收一个 Predicate 函数式接口作为参数，该接口定义了一个布尔条件。只有满足该条件的元素才会被保留在流中，不满足条件的元素将被排除。

        // 使用filter方法进行过滤：
        List<Order> orderList = orders.stream().filter(order -> order.getPrice() > 3).collect(Collectors.toList());
        orderList.stream().forEach(System.out::println);

输出结果：

2、sorted方法：排序方法，默认升序。加reversed方法可调整为降序

        // 使用sorted方法对数据进行排序(默认升序)，降序排序加reversed方法反转
        List<Order> orderList2 = orders.stream().sorted(Comparator.comparingDouble(Order::getPrice)).collect(Collectors.toList());
        orderList2.forEach(System.out::println);

输出结果：

3、map方法：对对象进行一对一的转换

        // 使用map方法进行对象的一对一转换
        List<String> orderIdList = orders.stream().map(Order::getOrderId).collect(Collectors.toList());
        orderIdList.stream().forEach(System.out::println);

输出结果：

4、Match方法校验数据：

        // 使用Match方法检查数据
        boolean isPriceExpensive = orders.stream().anyMatch(order -> order.getPrice() > 9);
        System.out.println(isPriceExpensive);
        boolean isPriceValid = orders.stream().allMatch(order -> order.getPrice() > 0);
        System.out.println(isPriceValid);

结果：

5、findFirst以及findAny方法

        // 查找第一个或最后一个数据，本例：查找价格最贵的订单价格
        Optional<Order> maxPriceOrder = orders.stream().sorted(Comparator.comparingDouble(Order::getPrice).reversed()).findFirst();
        System.out.println(maxPriceOrder);
        
        Optional<Order> ordersPresent = orders.stream().findAny();
        System.out.println(ordersPresent);

结果：

6、终结方法groupingBy，条件对键操作

// 分组的使用groupingBy
        Map<String, List<Order>> groupOrders = orders.stream().collect(Collectors.groupingBy(order -> {
            if (order.getPrice() < 1) {
                return "cheap";
            } else if (order.getPrice() > 1 && order.getPrice() < 10) {
                return "normal";
            } else {
                return "expensive";
            }
        }));
        System.out.println(groupOrders);

结果;

7、分区方法partitioningBy，二元分类

        // 分区的使用partitioningBy
        Map<Boolean, List<Order>> booleanOrderMap = orders.stream().collect(Collectors.partitioningBy(order -> order.getPrice() > 3));
        System.out.println(booleanOrderMap);

结果：

Tips：

总的来说，stream流在工作中用的还是很多的，大家有必要好好学一下。