列出多属性分组，找出最大值并统计数量

查询一个List，根据列表中的多个属性进行分组，统计出最小的属性值（价格），将其他属性（数量）相加。效果图如下：

实体类：产品

套件 com.len.控制器; 
导入lombok.数据;

/**
 *商品类别
 *
 * @作者support@www.sychzs.cn
 * @版本1.0
 * @日期 2019-11-09 22:06
 */
@数据
公共 类 产品 { 
    //产品型号
    私有字符串产品项目;
    //产品价格
    私人双倍产品价格;
    //数量
    private 整数;公共 产品(字符串产品项目,双产品价格 , 整数) {
        这个.产品项目=产品项目;
        这个.产品价格=产品价格;
        这个.num =num;
    }

    公共 产品() {
    }

    @覆盖
    公共字符串toString（）{
        退货 》产品{" +
                "productItem='" + 产品项目 + '\' '+
                ", 产品价格 = " + 产品价格 +
                ", num=" + num +
                '}';
    }
}

分组条件类：ItemAndPrice

套件 com.len.控制器; 

导入lombok.Builder;
导入lombok.数据;

/**
 * @作者support@www.sychzs.cn
 * @版本1.0
 * @日期 2019-11-09 23:34
 */
@数据
@Builder
公共 类项目和价格{ 
    //商品型号
    私有字符串产品项目;
    //商品价格
    私人双倍产品价格;
}

方法一：

套件 com.len.控制器; 

导入java.util.ArrayList ;
导入java.util.HashMap; 
导入java.util.列表; 
导入java.util.地图; 导入静态java.util. 流.收藏家.分组依据 ;

/**
 * @作者support@www.sychzs.cn
 * @版本1.0
 * @日期 2019-11-09 22:01
 */
公共 班级测试{ 
    //需求：按照型号及该型号的最低价格分组统计数量
    公共 静态空主要 （字符串[]args） {
        产品product1 = 新 产品("ss-uu-35" ,299.0, 2);
        产品product2 = 新 产品("ss-uu-35" ,399.0, 6);
        产品product3 = 新 产品("ss-uu-35" ,599.0, 2);
        产品product4 = 新 产品("ss-uu-35" ,599.0, 10);产品product5 = 新 产品("ss-uu-36",999.0, 7);
        产品product6 = 新 产品("ss-uu-38", 799.0, 3);
        产品product7 = 新 产品("ss-uu-38", 799.0, 5);
        产品product8 = 新 产品("ss-uu-38", 899.0, 7);

        列表<产品>产品列表=新 ArrayList<>( );
        产品列表.添加(产品1);
        产品列表.添加(产品2);
        产品列表.添加(产品3);
        产品列表.添加(产品4);产品列表.添加(产品5);
        产品列表.添加(产品6);
        产品列表.添加(产品7);
        产品列表.添加(产品8);
        //按型号和价格分组：获取地图 key：你定义的分组对象（ItemAndPrice） value：List()
        地图<商品和价格,列表<产品> >收集=产品列表。 流()
                .收集(分组依据(价格- >新商品和价格（ 价格。获取产品项目(),价格 .获取产品价格())));
         // 地图是价格最低的所有规格（collect1的key）
        地图地图= new HashMap();
        //遍历key获取最低价格收集.keySet().forEach(s) ->{
            如果 （地图。获取（） s.获取产品项目() ) != null) {
                商品和价格 商品和价格 = (商品和价格) 地图.获取(s.获取产品项目());
                if (项目和价格.获取产品价格() > s.获取产品价格()){
                    地图.put(s.getProductItem() ,);
                }
            } 其他 {
                地图.put(s.getProductItem() ,);
            }
        });//根据取出的最低价格key，去采集获取价值（List）
        列表<产品>产品列表1 =新  ArrayList<>( );
        地图.值().forEach(i ->{
            产品列表1.addAll(收集.获取(i));
        });
        系统.输出.println(最低价格结果() 产品列表1));
    }

    公共 静态列表<产品> 最低价格结果(列表<产品>列表){
        列表<产品>结果=新 ArrayList<>( );地图<字符串,列表<产品> > duListGroup = getListGroup(列表);
        用于 （地图。条目< 字符串,列表<产品 >>条目: duListGroup.entrySet()) {
            条目.getValue().forEach(项目->{
                产品产品= 新 产品(); 
                产品.setProductItem(条目.getKey());
                产品.设置产品价格(项目.获取产品价格( ));
                产品.setNum(按列表计数(条目.) getValue()));如果 （！结果。包含(产品)){ 
                    结果.添加（产品）;
                }
            });
        }
        返回结果;
    }

    //分组方法
    公共 静态地图<字符串, 列表<产品>> getListGroup(列表<产品>列表)  {
        HashMap<String,列表<产品>> ret = 新 HashMap<>();
        //同名的分为一组
        对于（int我=0; i < 列表.尺寸();i++){产品产品=列表.获取(i);
            //如果实体字段的key不存在，则创建一个列表，并将列表添加到map中
            if (!ret.包含钥匙 (产品.获取产品项目(）））{
                ArrayList<产品> li =new  ArrayList<>( );
                li.添加（产品）;
                ret.put(产品.getProductItem(),李);
            } 其他 {
                //如果存在就添加一个到列表中
                ret.获取(产品.getProductItem()).添加(产品);
            }
        }
        返回返回;
    }公共 静态整数按列表计数（列表） <产品>列表) {
        整数温度 = 0;
        用于 (产品页:列表) {
            温度 = 温度 + p.getNum（） );
        }
        返回温度;
    }

}

方法二：

套件 com.len.控制器; 

导入java.util.*; 

导入静态java.util. 流.收藏家.分组依据 ;
导入静态java.util. 流.收集器.minBy ;

/**
 * @作者support@www.sychzs.cn
 * @版本1.0
 * @日期 2019-11-10 23:03
 */公共 类测试1{ 
    公共 静态空主要(字符串[]args) {
        产品product1 = 新 产品("ss-uu-35", 299.0, 2);
        产品product2 = 新 产品("ss-uu-35", 399.0, 6);
        产品product3 = 新 产品("ss-uu-35", 599.0, 2);
        产品product4 = 新 产品("ss-uu-35", 599.0, 10);
        产品product5 = 新 产品("ss-uu-36", 999.0, 7);
        产品product6 = 新 产品("ss-uu-38", 799.0, 3);产品product7 = 新 产品("ss-uu-38", 799.0, 5);
        产品product8 = 新 产品("ss-uu-38", 899.0, 7);

        列表<产品>产品列表=新 ArrayList<>( );
        产品列表.添加(产品1);
        产品列表.添加(产品2);
        产品列表.添加(产品3);
        产品列表.添加(产品4);
        产品列表.添加(产品5);
        产品列表.添加(产品6);
        产品列表.添加(产品7);
        产品列表.添加(产品8);列表<产品>产品列表1 =新  ArrayList<>( );
        //按型号和价格分组：获取地图 key：你定义的分组对象（ItemAndPrice） value：List()
        地图<商品和价格,列表<产品> >收集=产品列表。 流()
                .收集(分组依据(价格- >新商品和价格（ 价格。获取产品项目(),价格 .获取产品价格())));地图<字符串,可选<产品> >收集1=产品列表.流().收集(分组() 产品::getProductItem , minBy(比较器.比较双( 产品::获取产品价格))));
        收集1.entrySet().forEach(ent) ry->{
            条目.getValue().ifPresent(v) ->{
                项目和价格 项目和价格 = 项目和价格.建造者(). productItem(v.getProductItem ()).产品价格(v. 获取产品价格()).构建();int总和=收集.获取() 商品和价格).流().mapToInt(产品::getNum ).总和() ;
                产品列表1.添加（新产品（） v.获取产品项目(), v.获取产品价格(),总和 ));

            });
        });
        系统.输出.println(productList1);
    }
}

方法一和方法二效果一样的：