Java动态获取和

我对每个类和每个方法都有一个forloop，以获取特定的度量值，并将其导出为csv，如下所示

ClassName MethodName  No of Nodes
One       One.One      4
One       Two.One      2  
ClassName MethodName  No of Nodes
Three    Three.One     4
Three    Four.One      1

但是，在将每个类导出到csv之前，我希望获得每个类的所有节点的总和。像这样

 ClassName MethodName  No of Nodes    Total Nodes
    One       One.One      4
    One       Two.One      2            6
    ClassName MethodName  No of Nodes
    Three    Three.One     4
    Three    Four.One      1           5

这就是我到目前为止所做的

int numNodes;

for(Class cl : classes){
    for(Method m : cl.getMethod){
       numNodes = getNodeCount(m);
   }
 System.out.print(sum(numNodes));//this doesnt work.
}
 public int getNodeCount(Graph g){
     return g.getNodes().size();
 }

我已经创建了一个sepreate方法来获取sum

public int sum(int...numbers){

        int result = 0;
        for(int i = 0 ; i < numbers.length; i++) {
            result += numbers[i];
        } 
        return result;
    }

公共整数和（整数…数字）{
int结果=0；
for（int i=0；i

---

我的问题是，在将每个类导出到csv之前，如何获取每个类的所有节点的总和。

您需要的是每个类的

总和

计数器，因此您可以创建 String=>Integer存储类名及其各自的和，如下所示

Map<String, Integer> sumPerClass = new HashMap<>();

for(Class cl : classes){
    int numNodes = 0;
    for(Method m : cl.getMethod){
       numNodes += getNodeCount(m);
    }

    System.out.print("Class = " + cl.getName() + ", Sum = " + numNodes);
    sumPerClass.put(cl.getName(), numNodes)
}

Map sumPerClass=newhashmap（）；
对于（类别cl：类别）{
整数节点=0；
对于（方法m:cl.getMethod）{
numNodes+=getNodeCount（m）；
}
System.out.print（“Class=“+cl.getName（）+”，Sum=“+numNodes”）；
sumPerClass.put（cl.getName（），numNodes）
}

这里，

sum（numNodes）

使用

numNodes

，它只包含最后一个方法和当前迭代类的

getNodeCount（m）

的最后一个结果：

for(Class cl : classes){
    for(Method m : cl.getMethod){
       numNodes = getNodeCount(m);
   }
 System.out.print(sum(numNodes));//this doesnt work.
}

应通过将每个迭代类的

sumNodes

初始化为

0

，并将当前迭代类的每个方法的

getNodeCount（m）

结果相加，计算每个类的总和：

for(Class cl : classes){ 
    int sumNodes = 0;
    for(Method m : cl.getMethod){
       sumNodes += getNodeCount(m);
   }
  System.out.print("sumNodes="+sumNodes)
}

---

您是否考虑过一个对象来存储每个类的数据并处理您的输出？比如说

public class ClassMetrics {

    private Class clazz;

    private Map<String, Integer> methodNodeCount;

    private int totalNodeCount;

    // getters and setters

    public ClassMetrics(Class clazz) {
        this.clazz = clazz;
        this.methodNodeCount = new HashMap<>();
        this.totalNodeCount = 0;

        for (Method method : this.clazz.getDeclaredMethods()) {
            int curNodeCount = getNodeCount(method);
            this.methodNodeCount.put(method.getName(), curNodeCount); // <-- your getNodeCount method here
            this.totalNodeCount += curNodeCount;
        }

        public void printToFile(File file) {
            // implement your logic here...
        }

        public int getNodeCount(Graph g) {
            // your method
        }
    }
}

---

通过这种方式，您可以将问题分解为更小的部分，并让对象（ClassMetrics实例）执行工作（打印到文件）。

您的问题是什么？我已经编辑了问题，您一直在为循环中的当前方法分配

节点

，最终将成为最后一个方法的节点。你确定这就是你想做的吗。

File file = new File("somewhere");
for (Class clazz : classes) {
    new ClassMetrics(clazz).printToFile(file);
}