Java 查找arraylist对象的最大或最小元素

下面是我的代码

class Ex{

    String id;
    double version;

    public Ex(String id, double version) {
        this.id = id;
        this.version = version;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getVersion() {
        return version;
    }

    public void setVersion(double version) {
        this.version = version;
    }
}

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);
    }
}

class-Ex{
字符串id；
双版本；
公共Ex（字符串id，双版本）{
this.id=id；
this.version=版本；
}
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共双getVersion（）{
返回版本；
}
公共版本（双版本）{
this.version=版本；
}
}
公共班机{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
Ex rec1=新Ex（“HR3-A1234”，0.00）；
Ex rec2=新Ex（“HR3-A1234”，0.01）；
Ex rec3=新Ex（“HR3-A1234”，1.00）；
Ex rec4=新Ex（“HR3-A2345”，0.00）；
Ex rec5=新Ex（“HR3-A2345”，0.01）；
Ex rec6=新Ex（“HR3-A3456”，0.01）；
Ex rec7=新Ex（“HR3-A3456”，1.00）；
Ex rec8=新Ex（“HR3-A4567”，0.01）；
列表。添加（rec1）；
列表。添加（rec2）；
增加（记录3）；
增加（记录4）；
增加（记录5）；
增加（记录6）；
增加（记录7）；
增加（记录8）；
}
}

这里，对于每个记录，我想为id相同的每个记录显示最大/最小版本。我尝试过，但只能得到一个记录，即所有记录的最大/最小版本，但我想要每个类似id的最大/最小版本

---

非常感谢您的帮助。谢谢。

实现这一点的方法有很多。例如，通过ID向映射添加值。或者使用Streams API等。我将给出一个简单的解决方案—首先对数组进行排序，然后对其进行检查。对于每个ID，您将首先获得最小值，然后是最大值。因此，这里有一些代码来检查每个ID打印的最小值和最大值。如果该ID只有一条记录，它将同时打印为最小值和最大值（如果不需要，可以使用它）

Collections.sort（列表，新比较器（）{
@凌驾
公共整数比较（exO1，exO2）{//简单比较器；）
如果（o1.getId（）.compareTo（o2.getId（））！=0）{
返回o1.getId（）.compareTo（o2.getId（））；
}
返回Double.compare（o1.getVersion（），o2.getVersion（））；
}
});
字符串currentId=null//迭代并打印结果
双前值=0；
用于（例如：列表）{
如果（！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）；

例如，您可以使用一些数据结构来存储最小值和最大值。本例向

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);
        });
    }
}

import java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
公共班机{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
Ex rec1=新Ex（“HR3-A1234”，0.00）；
Ex rec2=新Ex（“HR3-A1234”，0.01）；
Ex rec3=新Ex（“HR3-A1234”，1.00）；
Ex rec4=新Ex（“HR3-A2345”，0.00）；
Ex rec5=新Ex（“HR3-A2345”，0.01）；
Ex rec6=新Ex（“HR3-A3456”，0.01）；
Ex rec7=新Ex（“HR3-A3456”，1.00）；
Ex rec8=新Ex（“HR3-A4567”，0.01）；
列表。添加（rec1）；
列表。添加（rec2）；
增加（记录3）；
增加（记录4）；
增加（记录5）；
增加（记录6）；
增加（记录7）；
增加（记录8）；
显示MinMaxOfech（列表）；
}
公共静态void displayminMaxOfech（列表EXE）{
//声明两个用于存储最小值和最大值的映射
Map minExes=newhashmap（）；
Map maxes=new HashMap（）；
//检查列表中的每个Ex，以获得最小值
exes.forEach（（Ex）->{
if（minExes.containsKey（例如getId（））{
//如果已包含，请检查新版本是否较低
if（minExes.get（ex.getId（））>ex.getVersion（））{
//如果较低，则覆盖旧版本号
put（例如getId（），例如getVersion（））；
}
}否则{
//如果尚未包含，只需将其添加到地图中即可
put（例如getId（），例如getVersion（））；
}
});
//检查列表中的每个Ex，以获得最大值
exes.forEach（（Ex）->{
if（maxes.containsKey（例如getId（））{
//如果已包含，请检查新版本是否更高
if（maxes.get（ex.getId（））{
System.out.println（id+“：”+版本）；
});
//从最大值映射打印最大值
System.out.println（“最大版本：”）；
maxExes.forEach（（id，版本）->{
System.out.println（id+“：”+版本）；
});
}
}

即使失败，请添加您尝试的代码。显示您的搜索代码？：）或者，如果您查找min或max，您可以将该方法拆分为一半并传递一个参数。因为当前它会重复相同的代码两次，但在<和>@VeselinDavidov中存在差异。您完全正确，这并不是关于最小代码行数的最佳解决方案。本规范旨在作为一个示例，以促进对操作的理解

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);
        });
    }
}