Question

下面是我的代码

Failed

在这里，对于每条记录，我想显示id相同的每条记录的最大/最小版本。我尝试了一下，但是只能获得一个记录，即所有记录的最大/最小版本，但是我想要最大/最小每个相似ID的版本。

感谢您的帮助。

Answer 1

例如，您可以通过使用一些数据结构来存储最小值和最大值来做到这一点。本示例向您的Main添加了一种方法，该方法可以输出版本号的最小值和最大值。

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

public class Main {

    public static void main(String[] args) {

        List<Ex> list = new ArrayList<Ex>();

        Ex rec1 = new Ex("HR3-A1234", 0.00);
        Ex rec2 = new Ex("HR3-A1234", 0.01);
        Ex rec3 = new Ex("HR3-A1234", 1.00);
        Ex rec4 = new Ex("HR3-A2345", 0.00);
        Ex rec5 = new Ex("HR3-A2345", 0.01);
        Ex rec6 = new Ex("HR3-A3456", 0.01);
        Ex rec7 = new Ex("HR3-A3456", 1.00);
        Ex rec8 = new Ex("HR3-A4567", 0.01);

        list.add(rec1);
        list.add(rec2);
        list.add(rec3);
        list.add(rec4);
        list.add(rec5);
        list.add(rec6);
        list.add(rec7);
        list.add(rec8);

        displayMinMaxOfEach(list);
    }

    public static void displayMinMaxOfEach(List<Ex> exes) {
        // declare two maps for storing minumum and maximum values
        Map<String, Double> minExes = new HashMap<String, Double>();
        Map<String, Double> maxExes = new HashMap<String, Double>();

        // check each Ex in the list in order to get the minimum values
        exes.forEach((Ex ex) -> {
            if (minExes.containsKey(ex.getId())) {
                // if already contained, check if the new version is lower
                if (minExes.get(ex.getId()) > ex.getVersion()) {
                    // if it is lower, overwrite the old version number
                    minExes.put(ex.getId(), ex.getVersion());
                }
            } else {
                // if not already contained, just add it to the map
                minExes.put(ex.getId(), ex.getVersion());
            }
        });

        // check each Ex in the list in order to get the maximum values
        exes.forEach((Ex ex) -> {
            if (maxExes.containsKey(ex.getId())) {
                // if already contained, check if the new version is higher
                if (maxExes.get(ex.getId()) < ex.getVersion()) {
                    maxExes.put(ex.getId(), ex.getVersion());
                }
            } else {
                // if not already contained, just add it to the map
                maxExes.put(ex.getId(), ex.getVersion());
            }
        });

        // print minumum values from the minimum map
        System.out.println("Minimum versions:");
        minExes.forEach((id, version) -> {
            System.out.println(id + ": " + version);
        });

        // print maximum values from the maximum map
        System.out.println("Maximum versions:");
        maxExes.forEach((id, version) -> {
            System.out.println(id + ": " + version);
        });
    }
}

Answer 2

有很多方法可以实现这一目标。例如，按ID向Map添加值。或使用Streams API等。我将给出一个简单的解决方案-首先对数组进行排序，然后遍历它。对于每个ID，您将首先获得最小值，然后获得最大值。因此，这里有一些代码可以检查每个ID的最小和最大打印量。如果您只有该ID的一条记录，它将同时以min和max的形式打印（如果您不想要它，可以使用它）

    Collections.sort(list, new Comparator<Ex>() {
        @Override
        public int compare(Ex o1, Ex o2) {  //Simple comparator ;)
            if (o1.getId().compareTo(o2.getId()) != 0) {
                return o1.getId().compareTo(o2.getId());
            }
            return Double.compare(o1.getVersion(), o2.getVersion());
        }
    });

    String currentId=null;  //Iterate and print the results
    double previousValue=0;
    for (Ex ex : list) {
        if(!ex.getId().equals(currentId)) {
            if(currentId!=null) {
                System.out.println("Id:"+currentId+" Max:"+previousValue);  
            }
            currentId=ex.getId();
            System.out.println("Id:"+currentId+" Min:"+ex.getVersion());
        }
        previousValue=ex.getVersion();
    }
    System.out.println("Id:"+currentId+" Max:"+previousValue);

查找arraylist对象的max或min元素

2 个答案: