从受保护的java方法获取hashmap值

我不熟悉java的复杂概念，我也知道这不是一个困难的问题，但我知道我犯了一些错误，我的类中有一个方法，我在我的主方法中提取它的值，但它显示了

NaN

这是一种方法：

protected static Map<String, Double> getSlaMetrics(List<Vm> vms) {
        Map<String, Double> metrics = new HashMap<String, Double>();
        List<Double> slaViolation = new LinkedList<Double>();
        double totalAllocated = 0;
        double totalRequested = 0;
        double totalUnderAllocatedDueToMigration = 0;

    for (Vm vm : vms) {
        double vmTotalAllocated = 0;
        double vmTotalRequested = 0;
        double vmUnderAllocatedDueToMigration = 0;
        double previousTime = -1;
        double previousAllocated = 0;
        double previousRequested = 0;
        boolean previousIsInMigration = false;

        for (VmStateHistoryEntry entry : vm.getStateHistory()) {
            if (previousTime != -1) {
                double timeDiff = entry.getTime() - previousTime;
                vmTotalAllocated += previousAllocated * timeDiff;
                vmTotalRequested += previousRequested * timeDiff;

                if (previousAllocated < previousRequested) {
                    slaViolation.add((previousRequested - previousAllocated) / previousRequested);
                    if (previousIsInMigration) {
                        vmUnderAllocatedDueToMigration += (previousRequested - previousAllocated)
                                * timeDiff;
                    }
                }
            }

            previousAllocated = entry.getAllocatedMips();
            previousRequested = entry.getRequestedMips();
            previousTime = entry.getTime();
            previousIsInMigration = entry.isInMigration();
        }

        totalAllocated += vmTotalAllocated;
        totalRequested += vmTotalRequested;
        totalUnderAllocatedDueToMigration += vmUnderAllocatedDueToMigration;
    }

    metrics.put("overall", (totalRequested - totalAllocated) / totalRequested);
    if (slaViolation.isEmpty()) {
        metrics.put("average", 0.);
    } else {
        metrics.put("average", MathUtil.mean(slaViolation));
    }
    metrics.put("underallocated_migration", totalUnderAllocatedDueToMigration / totalRequested);
    // metrics.put("sla_time_per_vm_with_migration", slaViolationTimePerVmWithMigration /
    // totalTime);
    // metrics.put("sla_time_per_vm_without_migration", slaViolationTimePerVmWithoutMigration /
    // totalTime);

    return metrics;
}

受保护的静态映射getSlaMetrics（列出虚拟机）{
Map metrics=newhashmap（）；
List SLAPRICTION=新建LinkedList（）；
双总分配=0；
要求的双总=0；
双重总分配不足的UETOMIGRION=0；
用于（虚拟机：虚拟机）{
双vmTotalAllocated=0；
双vmTotalRequested=0；
双vmUnderAllocatedDueToMigration=0；
双上一次时间=-1；
双前分配=0；
双前请求=0；
布尔值PreviousInMigration=false；
for（VmStateHistoryEntry:vm.getStateHistory（））{
如果（上一次！=-1）{
double-timeDiff=entry.getTime（）-previousTime；
vmTotalAllocated+=先前分配的*时间差；
vmTotalRequested+=previousRequested*timeDiff；
如果（先前分配<先前请求）{
添加（（previousRequested-previousAllocated）/previousRequested）；
如果（以前的迁移）{
vmUnderAllocatedDueToMigration+=（上一次请求-上一次分配）
*时间差；
}
}
}
previousAllocated=entry.getAllocatedMips（）；
previousRequested=entry.getRequestedMips（）；
previousTime=entry.getTime（）；
previousIsInMigration=entry.isInMigration（）；
}
totalAllocated+=vmTotalAllocated；
totalRequested+=vmTotalRequested；
totalUnderAllocatedDueToMigration+=vmUnderAllocatedDueToMigration；
}
度量值。put（“总体”，（totalRequested-totalAllocated）/totalRequested）；
if（slavalition.isEmpty（））{
指标。投入（“平均”，0）；
}否则{
metrics.put（“平均”，MathUtil.mean（slavillance））；
}
metrics.put（“未分配的_迁移”，totalUnderAllocatedDueToMigration/totalRequested）；
//metrics.put（“sla_time_per_vm_with_migration”，slavolationtimepervmwith migration/
//总时间）；
//metrics.put（“sla_time_per_vm_，不迁移”），slaviorationtimepervm，不迁移/
//总时间）；
回报指标；
}

我试图通过以下代码打印其值：

Map<String, Double> results = getSlaMetrics(vmList);
System.out.println("Overall Violations:" + results.get("overall"));

Map results=getSlaMetrics（vmList）；
System.out.println（“总体违规：+results.get（“总体”））；

我知道这是一个基本问题，但请不要介意。

得到“不是一个数字”意味着我们试图用零除以零。将非零数字除以零将得到

-无穷大

或

无穷大

。 我会看一看这行，确保不要把数字除以零

metrics.put（“总体”（totalRequested-totalAllocated）/ 总需求量）

正如Ivan在下面的评论中提到的，让我们来演示一下

NaN

、

-Infinity

和

Infinity

System.out.println(0.0/0.0);
System.out.println(0/0.0);
System.out.println(-1/0.0);
System.out.println(1/0.0);

它产生以下输出：

NaN
NaN
-Infinity
Infinity

---

这里的实际问题不在于Map及其方法，而在于代码。 如果执行此代码，则控件永远不会执行以下操作

if (previousTime != -1) {
                double timeDiff = entry.getTime() - previousTime;
                vmTotalAllocated += previousAllocated * timeDiff;
                vmTotalRequested += previousRequested * timeDiff;

                if (previousAllocated < previousRequested) {
                    slaViolation.add((previousRequested - previousAllocated) / previousRequested);
                    if (previousIsInMigration) {
                        vmUnderAllocatedDueToMigration += (previousRequested - previousAllocated)
                                * timeDiff;
                    }
                }

因此，Map中的以下值为0.0/0.0，即NaN

 metrics.put("overall", (totalRequested - totalAllocated) / totalRequested); 

   // Value in Map for Key "overall" is ==> 0.0 - 0.0/0.0 = NaN

---

因此，如果您在输出中得到NaN，这并不奇怪。

您是否尝试过通过代码进行调试？错误发生在哪一行？没有错误，只需获取Nan您使用过调试器吗？NaN表示您在代码中的某些位置执行了0.0/0.0

Double。NaN

将仅在

0.0/0.0

情况下出现。如果将某个非零数字除以0.0，则将得到

无穷大

或

-无穷大

 metrics.put("overall", (totalRequested - totalAllocated) / totalRequested); 

   // Value in Map for Key "overall" is ==> 0.0 - 0.0/0.0 = NaN