0

我有这个二维数组

**Client| Status** 

    FAI | deferred
    SDE | Bounced
    FAI | Bounced
    SDE | Bounced
    SDE | deferred
    FAI | deferred

我想要做的是创建一个函数，它会产生某种统计输出：EX：

FAI --> Deferred 66 % , Bounced 34 %
SDE --> Deferred 34 % , Bounced 66%

注意对于第一列，有很多可能的客户，但对于第二列，我只有这两个状态。

我要创建的函数是一个计算第一列元素出现次数的函数，然后对于每个客户端查看每次出现的状态（如果它被退回或引用），并为客户端进行统计。

在这里我真的不知道如何开始我的功能，所以欢迎任何想法，任何建议，并将帮助我。谢谢！

4

2 回答 2

0

您必须列出所有客户。然后您可以计算每个客户拥有的延迟和退回的数量。这是我的解决方案。它不是最好的方法，但它有效！输出是：

FAI --> 延期 67 % ，反弹 33%

SDE --> 延迟 33%，反弹 67%

  public static void main(String[] args) throws InterruptedException {

      String[][] client_status = new String[6][2];
      client_status[0][0] = "FAI";
      client_status[0][1] = "deffered";
      client_status[1][0] = "SDE";
      client_status[1][1] = "Bounced";
      client_status[2][0] = "FAI";
      client_status[2][1] = "Bounced";
      client_status[3][0] = "SDE";
      client_status[3][1] = "Bounced";
      client_status[4][0] = "SDE";
      client_status[4][1] = "deffered";
      client_status[5][0] = "FAI";
      client_status[5][1] = "deffered";


      List<String> clients = new ArrayList<String>();

      int allDeffered = 0;
      int allBounced = 0;

      for(int i = 0; i < client_status.length; i++) {
          if(!clients.contains(client_status[i][0])) {
              clients.add(client_status[i][0]);
          }  
      }

      Integer[] clientDeffered = new Integer[clients.size()];
      Integer[] clientBounced = new Integer[clients.size()];

      int k = 0;
      for(String client : clients) {
          for(int j = 0; j<client_status.length; j++) {
              if(client_status[j][0].equals(client)&&client_status[j][1].equals("deffered")) {
                  if(clientDeffered[k]==null) {
                      clientDeffered[k]=1;
                  }
                  else {
                      clientDeffered[k]++;
                  }
                  allDeffered ++;
              }
              if(client_status[j][0].equals(client)&&client_status[j][1].equals("Bounced")) {
                  if(clientBounced[k]==null) {
                      clientBounced[k]=1;
                  }
                  else {
                      clientBounced[k]++;
                  }
                  allBounced ++;

              }
          }
          k++;
      }
      for(int l = 0; l<clients.size(); l++) {
          double a = clientDeffered[l];
          double b = allDeffered;
          double c = clientBounced[l];
          double d = allBounced; 
          System.out.println(clients.get(l) +" --> Deffered " +Math.round((a/b)*100) + " % , Bounced " +Math.round((c/d)*100) + "%");
      }   
  }
于 2013-10-09T10:13:23.733 回答
0

使用 HashMap（或 Map 接口的任何其他实现）来有效地解决您的问题（@kai 解决方案是可以的，但它是 O(N^2)）。这个例子不是通用的，它只有在网格（数据矩阵）的第二列中有两个可能的值（延迟和反弹）时才有效。解决方案以这种方式工作：我们遍历数据矩阵中的行并检查当前实体（按名称表示 - 网格的第一列）是否已经在 hashmap 中。如果是，只需增加该实体百分比（实体类的inc方法），否则我们必须首先创建实体的新实例，将其添加到hashmap然后增加百分比。打印是类似的（因为我们需要以它们在矩阵中出现的相同顺序打印名称）：我们再次迭代数据并打印实体对象（这就是 toString 方法被覆盖的原因）。

import java.util.HashMap;

public class HelloWorld{
 static class Entity {
    private String name;
    private int countFirst;
    private int countSecond;
    private boolean isVisitedMember; // because we want to print in same order as in original matrix

    public Entity(String name) {
        this.name = name;
        countFirst = 0;
        countSecond = 0;
        isVisitedMember = false;
    }

    public void inc(String status) {
        if (status.toLowerCase().equals("deferred")) {
            ++countFirst;
        }
        else {
            ++countSecond;   
        }
    }

    public boolean isVisited() {
        return isVisitedMember;
    }

    public void setIsVisited(boolean value) {
        isVisitedMember = value;
    }

    public float getFirstPercent() {
        return (float)countFirst / (countFirst + countSecond) * 100;
    }

    public float getSecondPercent() {
        return (float)countSecond / (countFirst + countSecond) * 100;
    }

    @Override
    public String toString() {
        if (countFirst <= countSecond) {
            int first = (int)Math.ceil(getFirstPercent());
            return String.format("%s --> Deferred %d %% , Bounced %d %%", name, first, 100 - first);
        }

        int second = (int)Math.ceil(getSecondPercent());
        return String.format("%s --> Deferred %d %% , Bounced %d %%", name, 100 - second, second);
    }
 }


 public static void main(String []args){
    String[][] data = {
        { "FAI", "deferred" },
        { "SDE", "Bounced" },
        { "FAI", "Bounced" },
        { "SDE", "Bounced" },
        { "SDE", "deferred" },
        { "FAI", "deferred" },
    };

    HashMap<String, Entity> map = new HashMap<String, Entity>();
    for (int i = 0; i < data.length; ++i) {
        String name = data[i][0];
        String value = data[i][1];
        Entity entity = map.get(name);
        if (entity == null) {
            entity = new HelloWorld.Entity(name);
            map.put(name, entity);
        }

        entity.inc(value);
    }

    // print in same order as in original matrix
    for (int i = 0; i < data.length; ++i) {
        String name = data[i][0];
        Entity entity = map.get(name);
        if (entity.isVisited()) {
            continue;
        }

        entity.setIsVisited(true);
        System.out.println(entity);
    }        
 }

}

于 2013-10-09T11:11:06.667 回答