Java 8:在大型列表中计算最小值和最大值的最佳方法

Question

我有下面的代码，其中计算最小和最大订单项目从列表订单并按预期工作。我想知道是否可以进一步重构/改进，使其更优化和高性能地处理数千或订单列表。

我故意不做 Collections.min（itemFrequencyMap.values（）） 和 Collections.max（itemFrequencyMap.values（）），因为它需要对所有值进行两次迭代，然后再次循环遍历 itemFrequency Map 以查找具有最小值和最大值的条目。

@Data
public class Order {
    private Long id;
    private String created_at, current_total_price, currency;
    Double total_price;     
    private List<Item> items;
}

@Data
public class Item {
private Long product_id;
String title, name, price;
}

@Data
public class ItemFrequency {
private Item item;
Long frequency;
}

public void minMaxItems(List<Order> orders) {       

    ItemFrequency minOrder = null;
    ItemFrequency maxOrder = null;
    Map<Item, Long> itemFrequencyMap = new TreeMap<>();
    orders.stream()
            .map(o -> o.getLine_items())
            .flatMap(List::stream)
            .forEach(Item -> {
                itemFrequencyMap.compute(Item, (k, v) -> v == null ? 1 : v + 1);
            });

    boolean isFirstEntry = true;
    Long max = Long.MIN_VALUE, min = Long.MAX_VALUE;
    for (Map.Entry<Item, Long> itemFrequency : itemFrequencyMap.entrySet()) {
        Item Item = itemFrequency.getKey();
        if (isFirstEntry) {
            max = itemFrequency.getValue();
            min = itemFrequency.getValue();
            isFirstEntry = false;
            continue;
        }
        if (itemFrequency.getValue() > max) {                
            max = itemFrequency.getValue();
            maxOrder = new ItemFrequency(Item,max);
        } else if (itemFrequency.getValue() < min) {                
            min = itemFrequency.getValue();
            minOrder = new ItemFrequency(Item,min);
        }
    }
    
}

Answer 1

您可以优化代码以在运行时执行最小和最大有序项目计算，即以不同的顺序添加项目。请在下面找到示例代码。使用这种方法，您可以在O（1）恒定时间内检索最小和最大有序项目。

import java.util.HashMap;
import java.util.List;
import java.util.Objects;

public class Test {
    private static HashMap<Item, Long> itemFrequencyMap = new HashMap<>();
    private static ItemFrequency minOrder;
    private static ItemFrequency maxOrder;


   public ItemFrequency getMinOrder() {
       return minOrder;
   }

   public ItemFrequency getMaxOrder() {
       return maxOrder;
   }

   public static class Item {
       private Long product_id;
       String title;
       String name;
       String price;

       @Override
       public boolean equals(Object o) {
           if (this == o) return true;
           if (!(o instanceof Item)) return false;
           Item item = (Item) o;
           return product_id.equals(item.product_id);
       }

       @Override
       public int hashCode() {
           return Objects.hash(product_id);
       }
   }

      public static class Order {
       private Long id;
       private String created_at, current_total_price, currency;
       private Double total_price;
       private List<Item> items;


       public List<Item> getItems() {
           return items;
       }

       public void addItem(Item item) {
           this.items.add(item);
           long frequency = itemFrequencyMap.getOrDefault(item, 0L) + 1;
           itemFrequencyMap.put(item, frequency);
           if (minOrder.frequency > frequency)
               minOrder = new ItemFrequency(item, frequency);

           if (maxOrder.frequency < frequency)
               maxOrder = new ItemFrequency(item, frequency);
       }
   }
   
   public static class ItemFrequency {
       private Item item;
       private Long frequency;
       public ItemFrequency(Item item, Long frequency) {
           this.item = item;
           this.frequency = frequency;
       }
   }
  }