用java组织对象列表

我有一节课

public class ProductStock {

   private Long id;
   private Integer quantity;

}

还有一张这样的清单

List<ProductStock> productStocks = 
{
  ProductStock(1, 1),
  ProductStock(2, 1),
  ProductStock(3, 1),
  ProductStock(1, 1),
  ProductStock(4, 1),
  ProductStock(5, 1),
  ProductStock(2, 1)
}

我会这样做：

Map<Long, Integer> counting = productStocks.stream().collect(
                Collectors.groupingBy(ProductStock::getId, Collectors.counting()));

Map counting=productStocks.stream（）.collect(
Collectors.groupingBy（ProductStock:：getId，Collectors.counting（））；

---

创建一个新映射，id作为键，计数作为值。

使用Java8 streams，您可以这样尝试：

productStocks = new ArrayList<>( productStocks.stream().collect( 
       Collectors.toMap( p -> p.id, p -> p, (p,o) -> { p.quantity += o.quantity; return p;} ) )
                 .values() );

productStocks=newarraylist（productStocks.stream（）.collect（
toMap（p->p.id，p->p，（p，o）->{p.quantity+=o.quantity；返回p；}）
.values（））；

它的作用是：

• productStocks.stream（）.collect（Collectors.toMap（…）

  为列表创建一个流，并将值收集到映射中

• p->p.id

  使用产品的id作为映射键

• p->p

  如果产品不存在，则将其用作映射值

• （p，o）->{p.quantity+=o.quantity；return p；}

  通过将数量添加到

  p

  中并返回，将现有产品

  p

  和“新”产品值

  o

  合并。或者，您可以创建一个新的

  产品

  实例：

  （p，o）->新产品（p.id，p.quantity+o.quantity）

• 最后，我们根据地图的值构建一个新列表

---

请注意，将元素收集到一个类似于map的映射中可能不会保留元素的顺序。如果要保持源代码列表中定义的顺序，可以将第四个参数添加到

collect（…）

：

LinkedHashMap:：new

可以使用

Map

将所有

ProductStock

聚合到一个位置。然后，您可以使用此

映射的内容

创建新的

列表

，该列表将包含聚合数据

Map<Long, Long> productStockMap = productStocks.stream().collect(Collectors.groupingBy(ProductStock::getId, Collectors.counting()));
productStocks = new ArrayList<>();
for(Map.Entry<Long, Long> entry: productStockMap.entrySet()) {
    productStocks.add(new ProductStock(entry.getKey(), entry.getValue().intValue()));
}

---

您可以通过迭代列表对产品进行分组，并将产品添加到LinkedHashMap以保持顺序：

void mergeProducts() {
    Map<Long, Integer> pMap = new HashMap<Long, Integer>();
    for (ProductStock ps :  productStocks) {
        if (pMap.containsKey(ps.getId())) {
            int qty = pMap.get(ps.getId());
            qty += ps.getQuantity();
            pMap.put(ps.getId(), qty);
        } else {
            pMap.put(ps.getId(), ps.getQuantity());
        }
    }

    System.out.println("Product grouping: ");
    for (Map.Entry<Long, Integer> entry : pMap.entrySet()) {
        System.out.println(entry.getKey() + " " + entry.getValue());
    }
}

void mergeProducts（）{
Map pMap=新的HashMap（）；
对于（ProductStock ps:ProductStock）{
if（pMap.containsKey（ps.getId（）））{
int qty=pMap.get（ps.getId（））；
数量+=ps.getQuantity（）；
pMap.put（ps.getId（），数量）；
}否则{
pMap.put（ps.getId（），ps.getQuantity（））；
}
}
System.out.println（“产品分组：”）；
对于（Map.Entry:pMap.entrySet（））{
System.out.println（entry.getKey（）+“”+entry.getValue（））；
}
}

使用Java8流和地图。除此之外，“最佳”一词相当模糊，但在任何情况下，您都可能想自己尝试一些东西。使用映射并在那里聚合它们。注意：由于自动（取消）装箱而不是

（int）entry.getValue（）.intValue（）

，因此您只能编写

entry.getValue（）

但即使没有这一点，也不需要转换为

int

。不过需要注意的是：

Collectors.counting（）

将对产品进行计数，而不是对数量进行合计。尝试使用除1以外的初始数量。

============Before============

ProductStock{id=1, quantity=1}
ProductStock{id=2, quantity=1}
ProductStock{id=3, quantity=1}
ProductStock{id=1, quantity=1}
ProductStock{id=4, quantity=1}
ProductStock{id=5, quantity=1}
ProductStock{id=2, quantity=1}

=============After============

ProductStock{id=1, quantity=2}
ProductStock{id=2, quantity=2}
ProductStock{id=3, quantity=1}
ProductStock{id=4, quantity=1}
ProductStock{id=5, quantity=1}

void mergeProducts() {
    Map<Long, Integer> pMap = new HashMap<Long, Integer>();
    for (ProductStock ps :  productStocks) {
        if (pMap.containsKey(ps.getId())) {
            int qty = pMap.get(ps.getId());
            qty += ps.getQuantity();
            pMap.put(ps.getId(), qty);
        } else {
            pMap.put(ps.getId(), ps.getQuantity());
        }
    }

    System.out.println("Product grouping: ");
    for (Map.Entry<Long, Integer> entry : pMap.entrySet()) {
        System.out.println(entry.getKey() + " " + entry.getValue());
    }
}