在Java中从列表中获取最大值

我有一个如下的清单

List{        
{Type=A, Amt=30000},{Type=A, Amt=50000},{Type=B, Amt=40000},{Type=B,Amt=60000},{Type=C,spRqstAmt=50000},{Type=C,Amt=10000}
}

我需要打印每种类型的最大金额

输出：

类型：A， 金额：50000

类型：B， 金额：60000

类型：C， 金额：50000

---

如何实现这一点？

假设您的列表包含Element类型的对象，请使用toMap collector将它们聚合到map中，其中type是一个键，值冲突将以最大值的方式解决：

Map<String,Integer> m = list.stream().collect(Collectors.toMap(Element::getType, Element::getAmt, Math::max))

---

代码从我的头顶，我没有测试它

检查下面的代码。这应该对你有用。也可能有其他方法，这是使用HashMap

数据类

class Data{
    String type;
    int amt;
    
    Data(String s , int a){
        this.type = s;
        this.amt = a;
    }
}

实现类：

        Data data1 = new Data("A",30000);
        Data data2 = new Data("A",50000);
        Data data3 = new Data("B",40000);
        Data data4 = new Data("B",60000);
        Data data5 = new Data("C",50000);
        Data data6 = new Data("C",10000);
        
        ArrayList<Data> al = new ArrayList<>();
        al.add(data1);
        al.add(data2);
        al.add(data3);
        al.add(data4);
        al.add(data5);
        al.add(data6);
        
        
        
        HashMap<String,Integer> hm = new HashMap<>();
        for (int i = 0; i < al.size(); i++) {
            if(hm.containsKey(al.get(i).type)) {
                int tempAmt = hm.get(al.get(i).type);
                if(al.get(i).amt > tempAmt) {
                    hm.put(al.get(i).type, al.get(i).amt);
                }
            }else {
                hm.put(al.get(i).type,al.get(i).amt);
            }
        }
        
        System.out.println(hm);

假设一个类：

class DataClass {
  public String type;
  public Integer amt;
}

你可以：

HashMap<String, Integer> values = new HashMap<>();
for (DataClass data : listDatas) {
  if (values.contains(data.type)) {
     int amt = data.get(type);
     if (data.amt > amt) {
       values.put(data.type, data.amt);
     }
  } else {
    values.put(data.type, data.amt);
  }
}

---

然后，您可以打印结果。

类似于TomášZáluský的答案，使用流API，但这样您可以保留元素对象，如果以后需要：

import static java.util.Comparator.comparingInt;
import static java.util.function.BinaryOperator.maxBy;
import static java.util.stream.Collectors.toMap;

Map<String, Element> groupByMax = list.stream()
                .collect(toMap(Element::getType, e -> e, maxBy(comparingInt(Element::getAmt))));
Collection<Element> elementsWithMaxAmts = groupByMax.values();

Map<String, String> results = new HashMap<>();

for (Map<String, String> m : list) {
    results.merge(m.get("Type"), m.get("Amt"),
            (a, b) -> Integer.valueOf(a)
                    .compareTo(Integer.valueOf(b)) == 1 ? a :
                            b);
    
}
results.entrySet().forEach(System.out::println);

---

在这种情况下，不需要使用流。提供以下地图列表：

List<Map<String, String>> list =
        List.of(Map.of("Type", "A", "Amt", "30000"),
                Map.of("Type", "A", "Amt", "50000"),
                Map.of("Type", "B", "Amt", "40000"),
                Map.of("Type", "B", "Amt", "60000"),
                Map.of("Type", "C", "Amt", "50000"),
                Map.of("Type", "C", "Amt", "10000"));

以显示最大金额的类型打印以下内容

A=50000
B=60000
C=50000

---

您可以使用HashMap将类型存储为键，将金额存储为值。我认为这非常适合您的情况。我们不是家庭作业编写服务。