Java 查找对象数组列表中每个字段的最小/最大值的有效方法

我有以下ArrayList

List list1

其中

list1

具有以下值（浮动）：

现在我需要从第一列中找到最小值，即从

中，它必须返回2.89

然后从

中查找max，它必须返回125.89

现在对第二列重复同样的操作，并使用4个不同的变量存储它们，分别是min_col1、max_col1、min_col2和max_col2

min_col1 = 2.89
max_col1 = 125.89
min_col2 = 1.23
max_col2 = 231.23

我一直在研究各种解决方案，这些解决方案建议使用两个for循环，这确实很耗时，而且一些线程建议使用stream（），这是针对整个列表（即，不是针对每一列）发现的

---

有没有一种有效的方法可以做到这一点？我也在看apachecommons

遗憾的是没有

FloatStream

，但是您可以将值扩大到两倍，然后安全地缩小它们

我假设你有A和B的获得者，你已经忽略了

if (list1.isEmpty())
{
   throw /*something*/;
}
min_col1 = (float) list1.stream().mapToDouble(DataSt::getA).min().getAsDouble();
max_col1 = (float) list1.stream().mapToDouble(DataSt::getA).max().getAsDouble();
min_col2 = (float) list1.stream().mapToDouble(DataSt::getB).min().getAsDouble();
max_col2 = (float) list1.stream().mapToDouble(DataSt::getB).max().getAsDouble();

---

如果您只需要找到这些值，只需在列表中循环一次就足够了。我建议学习一点大O符号，以了解算法的性能

您可以这样做：

float min_col1 = Float.MAX_VALUE;
float max_col1 = Float.MIN_VALUE;
float min_col2 = Float.MAX_VALUE;
float max_col2 = Float.MIN_VALUE;

for (DataSt data : list1) {

    if (data.getA() < min_col1) {
        min_col1 = data.getA();
    }

    if (data.getA() > max_col1) {
        max_col1 = data.getA();
    }

    if (data.getB() < min_col2) {
        min_col2 = data.getB();
    }

    if (data.getB() > max_col2) {
        max_col2 = data.getB();
    }
}

float min_col1=float.MAX_值；
float max_col1=float.MIN_值；
float min_col2=float.MAX_值；
float max_col2=float.MIN_值；
对于（数据集数据：列表1）{
if（data.getA（）max_col1）{
max_col1=data.getA（）；
}
if（data.getB（）max_col2）{
max_col2=data.getB（）；
}
}

我为您制作了一些样品

    float Fmin = 0f;
    float Fmax = 0f;
    float Smin = 0f;
    float Smax = 0f;
    for (int i = 0; i < dataSts.size(); i++)
    {
        DataSt dataSt = dataSts.get(i);
        float a = dataSt.getA();
        float b = dataSt.getB();
        if(i == 0)
        {
            Fmin = a;
            Fmax = a;
            Smin = b;
            Smax = b;
            continue;
        }

        if(a < Fmin )
            Fmin = a;

        if(b < Smin )
            Smin = b;

        if(a > Fmax)
            Fmax = a;

        if(b > Smax)
            Smax = b;

    }
    System.out.println(Fmin +": "+Fmax+" : "+Smin+" : "+Smax);

float Fmin=0f；
浮动Fmax=0f；
浮点数Smin=0f；
浮点数Smax=0f；
对于（int i=0；iFmax）
Fmax=a；
如果（b>Smax）
Smax=b；
}
系统输出打印项次（Fmin+“：“+Fmax+”：“+Smin+”：“+Smax”）；

到目前为止，您尝试了什么？你在哪里会遇到性能问题？如果你能分享你已经拥有的代码就好了。这表明您自己已经做出了努力，而不仅仅是在寻找为您编写代码的人。此外，还可以更容易地查看代码中是否有错误和/或是否有可能进行改进。请通过使用这些嵌套循环向我们展示您的努力。然后我们可以向您展示如何改进它。但是，如果您的代码执行实际任务，并且没有性能问题，那么为什么要更改工作解决方案呢？您没有2D数组。您有一个1D对象数组，每个对象包含2个浮点数。这比在

min（）、max（）

中使用

.map（）

而不是

.mapToDouble

时使用

比较器.naturalOrder（）

更有效吗？这为什么更有效？这样你将在列表中循环4次。我完全忽略了效率方面。如果没有衡量出某件事是一个问题，或者没有定义一个效率目标，这是一个完全没有意义的要求。在实践中，这可能比基于for循环的解决方案的性能差得多，而且明显更清晰，更易于维护。如果列表为空，则必须检查大量的sentinel值。问题不在于处理边缘情况，是吗？这只是一种一气呵成的通用方法。要么在答案中提到这一点，要么改进代码，否则答案就不好。哦，拜托，在这种情况下，值只是保持在默认值。你的答案会在空名单上崩溃，哈哈。这里没什么可做的。。。再见，这不是坏事。尝试获取零的最小/最大值将导致异常。故障安全解决方案无法调试。

float min_col1 = Float.MAX_VALUE;
float max_col1 = Float.MIN_VALUE;
float min_col2 = Float.MAX_VALUE;
float max_col2 = Float.MIN_VALUE;

for (DataSt data : list1) {

    if (data.getA() < min_col1) {
        min_col1 = data.getA();
    }

    if (data.getA() > max_col1) {
        max_col1 = data.getA();
    }

    if (data.getB() < min_col2) {
        min_col2 = data.getB();
    }

    if (data.getB() > max_col2) {
        max_col2 = data.getB();
    }
}

    float Fmin = 0f;
    float Fmax = 0f;
    float Smin = 0f;
    float Smax = 0f;
    for (int i = 0; i < dataSts.size(); i++)
    {
        DataSt dataSt = dataSts.get(i);
        float a = dataSt.getA();
        float b = dataSt.getB();
        if(i == 0)
        {
            Fmin = a;
            Fmax = a;
            Smin = b;
            Smax = b;
            continue;
        }

        if(a < Fmin )
            Fmin = a;

        if(b < Smin )
            Smin = b;

        if(a > Fmax)
            Fmax = a;

        if(b > Smax)
            Smax = b;

    }
    System.out.println(Fmin +": "+Fmax+" : "+Smin+" : "+Smax);