理解stream的使用，从匿名内部类到stream

🍰 个人主页:__Aurora__
🍞文章有不合理的地方请各位大佬指正。
🍉文章不定期持续更新，如果我的文章对你有帮助➡️ 关注🙏🏻 点赞👍 收藏⭐️

java提供了新的API(“stream” 流)，支持许多处理数据的并行操作，其思路和在数据库查询语言中的思路类似。

通俗的讲：想要写两个只有几行代码不同的方法，只需要把不同的那部分代码作为参数传递进去就可以了，可称为函数式编程。

java8为什么要引入stream等技术？

Java编程的核心目的是操作数据（对象），包括各种基本类型（如int、Integer）和复合数据结构（如HashMap、String、String[]等）。在传统的Java编程中，虽然这些数据可以在方法间传递，但某些元素（如方法、类等）却难以在运行时直接传递，这限制了代码的灵活性和表达能力。
为了解决这个问题，Java 8引入了Lambda表达式和Stream API。这些新特性使得代码更加简洁、易读，同时也提高了开发者的生产力。具体而言，Stream API提供了一种高效的方式来处理集合数据，允许开发者以声明式的方式描述对数据的操作，从而避免了显式的循环和复杂的逻辑判断。
Lambda表达式则提供了一种更简洁的方式来表示匿名函数，使得代码更加紧凑，同时也方便了高阶函数的使用。这两项技术的结合，极大地提升了Java在处理数据和编写并发程序方面的能力。

java8前后代码对比，理解条件如何作为参数传递的

首先要认识一下这个符号——::是把 这个方法作为值
有如下需求，对这个商品集合（List<Product>）过滤操作，过滤条件分别有

• 把数量为0的商品过滤出来
• 把类别为水果的商品过滤出来

Product类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Product {
    // 商品ID
    private Long id;
    // 商品名称
    private String name;
    // 商品描述
    private String description;
    // 商品价格
    private Double price;
    // 库存数量
    private Integer stockQuantity;
    }

java8之前可能如下写法，也可能在业务层写过滤函数

    /**
     * 获取库存为0的商品
     *
     * @param products 原商品集合
     * @return 过滤商品集合
     */
    public static List<Product> getStockZone(List<Product> products) {
        List<Product> result = new ArrayList<>();
        for (Product product : products) {
            if (product.getStockQuantity() == 0) {
                result.add(product);
            }
        }
        return result;
    }
    /**
     * 获取集合中类别为水果的 商品集合
     *
     * @param products 原商品集合
     * @return 过滤商品集合
     */
    public static List<Product> getStockFruits(List<Product> products) {
        List<Product> result = new ArrayList<>();
        for (Product product : products) {
            if ("水果".equals(product.getCategory())) {
                result.add(product);
            }
        }
        return result;
    }

对比一下java8的将条件作为参数传递进去

    /**
     * 获取库存为0的商品
     *
     * @param product 原商品
     * @return 过滤商品结果
     */
    public static Boolean checkStockZone(Product product) {
        return (product.getStockQuantity() == 0);
    }

    /**
     * 判断类别为水果
     *
     * @param product 商品
     * @return 过滤商品结果
     */
    public static Boolean checkFruits(Product product) {
        return ("水果".equals(product.getCategory()));
    }
 /**
     * @param products  原集合
     * @param predicate 过滤条件
     * @return 过滤集合
     */
    public static List<Product> filterProduct(List<Product> products,
                                              MyPredicate<Product> predicate) {
        List<Product> result = new ArrayList<>();
        for (Product product : products) {
            if (predicate.test(product)) {
                result.add(product);
            }
        }
        return result;
    }
/**
 * 定义一个泛型接口MyPredicate，用于表示一种断言条件。
 * 该接口包含一个test方法，用于判断给定的输入是否满足特定条件。
 * @param <T> 代表断言条件所作用的泛型类型。
 */
public interface MyPredicate<T> {
    /**
     * 对给定的输入进行断言测试。
     * @param t 代表需要进行断言测试的输入对象。
     * @return boolean 返回一个布尔值，表示输入是否满足断言条件。
     */
    boolean test(T t);
}
	// 做如下调调用 可得到过滤集合
   List<Product> result = filterProduct(products, Product::checkStockZone);

对比看来java8的逻辑更复杂，需要 定义条件，定义条件接口，过滤方法
但上面代码只是为了方便理解::和条件如何作为参数传递的

java从传递方法到Lambda

对上面的代码进行优化

将条件优化掉——匿名内部类

使用匿名内部类

  @Test
   void streamDemo1() {
       List<Product> products = new ArrayList<>();
       products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
       products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
       products.add(new Product(3L, "短袖", "短袖", 80.0, 300, "衣服"));
       products.add(new Product(4L, "短裤", "短裤", 60.0, 400, "衣服"));
       filterProduct(products, new MyPredicate<Product>() {
           @Override
           public boolean test(Product product) {
               return "水果".equals(product.getCategory());
           }
       });
   }

进一步优化条件——Lambda

过滤种类为衣服的商品集合
filterProduct(products,(p)->{return "衣服".equals(p.getCategory());});

//过滤条件接口
public interface MyPredicate<T> {
   boolean test(T t);
}
// 过滤方法
 public static List<Product> filterProduct(List<Product> products,
                                             MyPredicate<Product> predicate) {
       List<Product> result = new ArrayList<>();
       for (Product product : products) {
           if (predicate.test(product)) {
               result.add(product);
           }
       }
       return result;
   }
    @Test
   void streamDemo1() {
       List<Product> products = new ArrayList<>();
       products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
       products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
       products.add(new Product(3L, "短袖", "短袖", 80.0, 300, "衣服"));
       products.add(new Product(4L, "短裤", "短裤", 60.0, 400, "衣服"));
       List<Product> result = filterProduct(products,(p)->{return "衣服".equals(p.getCategory());});
   }
  //结果
   Product(id=3, name=短袖, description=短袖, price=80.0, stockQuantity=300, category=衣服)
   Product(id=4, name=短裤, description=短裤, price=60.0, stockQuantity=400, category=衣服)

优化过滤条件接口——使用java.util.function.Predicate<T>

Predicate<T>功能接口（还有其他功能接口，后续文章详细解释），接受T类型对象，返回boolean类型

   public static <T> List<T> filterProduct(List<T> products,
                                            Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T product : products) {
            if (predicate.test(product)) {
                result.add(product);
            }
        }
        return result;
    }
     @Test
    void streamDemo1() {
        List<Product> products = new ArrayList<>();
        products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
        products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
        products.add(new Product(3L, "短袖", "短袖", 80.0, 300, "衣服"));
        products.add(new Product(4L, "短裤", "短裤", 60.0, 400, "衣服"));
        List<Product> result = filterProduct(products, (Product p) -> "水果".equals(p.getCategory()));
    }

优化过滤方法——stream （最终优化代码）

   @Test
    void streamDemo1() {
        List<Product> products = new ArrayList<>();
        products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
        products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
        products.add(new Product(3L, "短袖", "短袖", 80.0, 300, "衣服"));
        products.add(new Product(4L, "短裤", "短裤", 60.0, 400, "衣服"));
        List<Product> result = products.stream().filter(p -> "水果".equals(p.getCategory())).collect(Collectors.toList());
    }

这样看起来和java8之前的代码简洁多了。

🍉文章不定期持续更新，如果我的文章对你有帮助➡️ 关注🙏🏻 点赞👍 收藏⭐️
转载请注明出处🏀