Java 计算模式

我正在尝试编写一个方法来计算一组数据的模式并返回它。如果没有模式或有多个模式（例如：If4&2返回的次数最多），我希望函数返回Double.NaN。我能够获得模式，但如果有多个模式，我的代码返回双NaN时遇到问题

这是我的密码

public double mode() {

    if (data == null) {
        double mode;
        mode = Double.NaN;
        return mode; // returns no value if array is null
    }

    double mode = 0;
    double modeCounter = 0;

    for (int c = 0; c < data.length; ++c) {
        int count = 0;
        for (int i = 0; i < data.length; ++i) {
            if (data[i] == data[i])
                ++count;
        }
        if (count > modeCounter) {
            modeCounter = count;
            mode = data[c];
        }
    }
    if (!(modeCounter > 1)) {
        return Double.NaN;
    }

    return mode;

}

公共双模式（）{
如果（数据==null）{
双模式；
mode=Double.NaN；
返回模式；//如果数组为空，则不返回值
}
双模式=0；
双模式计数器=0；
对于（int c=0；c模式计数器）{
模式计数器=计数；
模式=数据[c]；
}
}
如果（！（modeCounter>1））{
返回Double.NaN；
}
返回模式；
}

我假设您使用的是Java

我们可以通过简单地创建一个

Map

找到模式（以及您对返回

Double.NaN

的限制），其中键是各个数据点，值是它们在数据数组中的对应计数

Stream

s对于编写可读且简洁的代码非常有用

如果您有数组/数组列表中每个成员的计数，您只需使用此计数即可根据您的需求得出结论

请参阅实现上述说明的以下代码：

public static Double mode(List<Double> data) {
    if (data.isEmpty()) {
        // returning NaN if the input arraylist is empty 
        return Double.NaN;
    }

    Map<Double, Integer> count = new HashMap<>();
    data.forEach(
            i -> {
                count.putIfAbsent(i, 1);
                count.put(i, count.get(i) + 1);
            }
    );
    int maxCount = count.values().stream().max(Integer::compare).get(); // this assumes that the data is not empty
    if (count.values().stream().filter(i -> i == maxCount).count() > 1) {
        // more than one mode present
        return Double.NaN;
    }

    // here we'll be sure that only one mode exists
    return count
            .entrySet()
            .stream()
            .filter(e -> e.getValue() == maxCount)
            .findFirst() // as we've only one mode
            .get()
            .getKey();
}

公共静态双模式（列表数据）{
if（data.isEmpty（））{
//如果输入arraylist为空，则返回NaN
返回Double.NaN；
}
映射计数=新的HashMap（）；
data.forEach(
我->{
计数。putIfAbsent（i，1）；
count.put（i，count.get（i）+1）；
}
);
int maxCount=count.values（）.stream（）.max（Integer:：compare）.get（）；//这假设数据不是空的
if（count.values（）.stream（）.filter（i->i==maxCount.count（）>1）{
//存在多个模式
返回Double.NaN；
}
//在这里，我们将确保只有一种模式存在
返回计数
.entrySet（）
.stream（）
.filter（e->e.getValue（）==maxCount）
.findFirst（）//因为我们只有一种模式
.get（）
.getKey（）；
}

什么是数据？阵列？什么时候没有模式？对于[1,2,3]这样的数组，模式是什么？如果（data[i]==data[i]）-这总是正确的