List多属性分组,求最值并统计数量

导读:本篇文章讲解 List多属性分组,求最值并统计数量,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com

查询出一个List,根据这个list中的多个属性进行分组,统计出某一属性值最小的(价格),将其另一属性(数量)累加。效果图如下:
在这里插入图片描述
以下两种方法均可实现,推荐第二种(简便),具体实现如下:

实体类:Product

package com.len.controller;
import lombok.Data;

/**
 * 商品类
 *
 * @author wangyan@163.com
 * @version 1.0
 * @date 2019-11-09 22:06
 */
@Data
public class Product {
    // 商品型号
    private String productItem;
    // 商品价格
    private Double productPrice;
    // 数量
    private Integer num;

    public Product(String productItem, Double productPrice, Integer num) {
        this.productItem = productItem;
        this.productPrice = productPrice;
        this.num = num;
    }

    public Product() {
    }

    @Override
    public String toString() {
        return "Product{" +
                "productItem='" + productItem + '\'' +
                ", productPrice=" + productPrice +
                ", num=" + num +
                '}';
    }
}

分组条件类:ItemAndPrice

package com.len.controller;

import lombok.Builder;
import lombok.Data;

/**
 * @author wangyan@163.com
 * @version 1.0
 * @date 2019-11-09 23:34
 */
@Data
@Builder
public class ItemAndPrice {
    // 商品型号
    private String productItem;
    // 商品价格
    private Double productPrice;
}
方法一:
package com.len.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static java.util.stream.Collectors.groupingBy;

/**
 * @author wangyan@163.com
 * @version 1.0
 * @date 2019-11-09 22:01
 */
public class Test {
    // 要求:按照型号和该型号最低价价格分组并统计个数
    public static void main(String[] args) {
        Product product1 = new Product("ss-uu-35", 299.0, 2);
        Product product2 = new Product("ss-uu-35", 399.0, 6);
        Product product3 = new Product("ss-uu-35", 599.0, 2);
        Product product4 = new Product("ss-uu-35", 599.0, 10);
        Product product5 = new Product("ss-uu-36", 999.0, 7);
        Product product6 = new Product("ss-uu-38", 799.0, 3);
        Product product7 = new Product("ss-uu-38", 799.0, 5);
        Product product8 = new Product("ss-uu-38", 899.0, 7);

        List<Product> productList = new ArrayList<>();
        productList.add(product1);
        productList.add(product2);
        productList.add(product3);
        productList.add(product4);
        productList.add(product5);
        productList.add(product6);
        productList.add(product7);
        productList.add(product8);
        // 以型号和价格分组:得到map  key:你定义的分组对象(ItemAndPrice)  value:List<Product>()
        Map<ItemAndPrice, List<Product>> collect = productList.stream()
                .collect(groupingBy(price -> new ItemAndPrice(price.getProductItem(), price.getProductPrice())));
        // map为价格最低的所有规格(collect1的key)
        Map map = new HashMap();
        // 遍历key取出最小价格
        collect.keySet().forEach(s -> {
            if (map.get(s.getProductItem()) != null) {
                ItemAndPrice itemAndPrice = (ItemAndPrice) map.get(s.getProductItem());
                if (itemAndPrice.getProductPrice() > s.getProductPrice()) {
                    map.put(s.getProductItem(), s);
                }
            } else {
                map.put(s.getProductItem(), s);
            }
        });
        // 根据取出的最小价格key,去collect拿value(List<Product>)
        List<Product> productList1 = new ArrayList<>();
        map.values().forEach(i -> {
            productList1.addAll(collect.get(i));
        });
        System.out.println(lowestPriceResult(productList1));
    }

    public static List<Product> lowestPriceResult(List<Product> list) {
        List<Product> result = new ArrayList<>();
        Map<String, List<Product>> duListGroup = getListGroup(list);
        for (Map.Entry<String, List<Product>> entry : duListGroup.entrySet()) {
            entry.getValue().forEach(item -> {
                Product product = new Product();
                product.setProductItem(entry.getKey());
                product.setProductPrice(item.getProductPrice());
                product.setNum(countByList(entry.getValue()));
                if (!result.contains(product)) {
                    result.add(product);
                }
            });
        }
        return result;
    }

    //分组方法
    public static Map<String, List<Product>> getListGroup(List<Product> list) {
        HashMap<String, List<Product>> ret = new HashMap<>();
        //同名的分为一组
        for (int i = 0; i < list.size(); i++) {
            Product product = list.get(i);
            //如果不存在实体字段的键,则创建一个list,并将list添加至map
            if (!ret.containsKey(product.getProductItem())) {
                ArrayList<Product> li = new ArrayList<>();
                li.add(product);
                ret.put(product.getProductItem(), li);
            } else {
                //如果存在,则直接在list中添加一个即可
                ret.get(product.getProductItem()).add(product);
            }
        }
        return ret;
    }

    public static Integer countByList(List<Product> list) {
        Integer temp = 0;
        for (Product p : list) {
            temp = temp + p.getNum();
        }
        return temp;
    }

}

方法二:
package com.len.controller;

import java.util.*;

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.minBy;

/**
 * @author wangyan@163.com
 * @version 1.0
 * @date 2019-11-10 23:03
 */
public class Test1 {
    public static void main(String[] args) {
        Product product1 = new Product("ss-uu-35", 299.0, 2);
        Product product2 = new Product("ss-uu-35", 399.0, 6);
        Product product3 = new Product("ss-uu-35", 599.0, 2);
        Product product4 = new Product("ss-uu-35", 599.0, 10);
        Product product5 = new Product("ss-uu-36", 999.0, 7);
        Product product6 = new Product("ss-uu-38", 799.0, 3);
        Product product7 = new Product("ss-uu-38", 799.0, 5);
        Product product8 = new Product("ss-uu-38", 899.0, 7);

        List<Product> productList = new ArrayList<>();
        productList.add(product1);
        productList.add(product2);
        productList.add(product3);
        productList.add(product4);
        productList.add(product5);
        productList.add(product6);
        productList.add(product7);
        productList.add(product8);

        List<Product> productList1 = new ArrayList<>();
        // 以型号和价格分组:得到map  key:你定义的分组对象(ItemAndPrice)  value:List<Product>()
        Map<ItemAndPrice, List<Product>> collect = productList.stream()
                .collect(groupingBy(price -> new ItemAndPrice(price.getProductItem(), price.getProductPrice())));
        Map<String, Optional<Product>> collect1 = productList.stream().collect(groupingBy(Product::getProductItem, minBy(Comparator.comparingDouble(Product::getProductPrice))));
        collect1.entrySet().forEach(entry -> {
            entry.getValue().ifPresent(v -> {
                ItemAndPrice itemAndPrice = ItemAndPrice.builder().productItem(v.getProductItem()).productPrice(v.getProductPrice()).build();
                int sum = collect.get(itemAndPrice).stream().mapToInt(Product::getNum).sum();
                productList1.add(new Product(v.getProductItem(), v.getProductPrice(), sum));

            });
        });
        System.out.println(productList1);
    }
}

方法一和方法二效果一样的:
在这里插入图片描述

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/115792.html

(0)

相关推荐

发表回复

登录后才能评论
半码博客——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!