Question

我有两个不同的数组ArrayList的双精度数和一个数组的数组

 public class tester {

        private final static String TIME[]={ "8:00", "9:00", "10:00", "11:00", 
            "12:00", "13:00", "14:00", "15:00", "16:00", "17:00", "18:00", "19:00"  };


        public static void main(String[] args){
            ArrayList<Double> stat = new ArrayList<>();
            stat.add(1.0);
            stat.add(2.0);
            stat.add(3.0);
            stat.add(4.0);
            stat.add(5.0);
            stat.add(6.0);
            stat.add(7.0);
            stat.add(8.0);
            stat.add(9.0);
            stat.add(10.0);
            stat.add(11.0);
            stat.add(12.0);
            int i = 0;
            for (String time : TIME) {
                System.out.println(time+" "+stat.get(i));
                i++;
            }

我的问题很简单，如果我想让每个数组的相同位置匹配，这是循环遍历每个数组的最佳方法吗？那么stat.get(0) ==TIME.get(0)？

更新

首先，谢谢大家的快速回复，我喜欢创建课程的想法，但有些事情你需要知道。

你看到的是我用来测试我的数据的测试类。

我知道这两个数组总是大小相同，因为stat ArrayList通常定义如下：

stat是从数据库获得的数据的计算值，stat的值基于时间，然后发送回GUI以放入图表和表格。

这意味着每个TIME都有一个exisiting值，因此stat.get（0）总是等于TIME.get（0）==“8:00”。

考虑到这一点，您是否仍然认为我应该创建一个类，或者我应该保持下面显示的类，然后添加一个包含数据的HashMap，然后迭代该地图以在我的GUI中插入数据？

public class Statistics {
    private ArrayList<CallQueue> queues = new ArrayList<CallQueue>();
    private ArrayList<Double> averageData = new ArrayList<Double>();
    private Provider p;

    public Statistics(){
         try {
            this.p = new Provider();
        } catch (DopeDBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * This recursive method calculates the average of each time table and then adds its to the arrayList in the following order:
     * 8.00  = 0
     * 9.00  = 1
     * 10.00 = 2
     * 11.00 = 3
     * 12.00 = 4
     * 13.00 = 5
     * 14.00 = 6
     * ect.
     * @param time
     */
    public void calculateAverage(){
        int data = 0;
        for (int i = 8; i < 20; i++) {
            for (CallQueue cq : queues) {
                data += cq.getCallsByTime(i);
            }
            if (data == 0) {
                Main.createErrorMessage("Fejl i dataen! \r\n kontakt venligst ansvarlige i Dope");
            }
            averageData.add((double) data/11);
        }
    }
    /**
     * @author MRCR
     * This method recives the object list from the database and sets the currentlist to the list recived.
     */
    public void setQueues(Calendar start, Calendar end){
        try {
            queues = p.getInformation(start, end, queues);
        } catch (DopeDBException e) {
            // TODO Auto-generated catch block
            Main.createErrorMessage("Message");
        } catch (DopeResultSetException e) {
            // TODO Auto-generated catch block
            Main.createErrorMessage("Message");
        }

    }
    /**
     * This method returns the calculated DataList list.
     * @author MRCR
     * @return averageData
     */
    public ArrayList<Double>getData(Calendar start, Calendar end){
        setQueues(start, end);
        calculateAverage();
        return averageData;
    }



}


import java.util.HashMap;


public class CallQueue {
    private String type;
    private HashMap<Integer, Integer> data = new HashMap<Integer,Integer>();
    public CallQueue(String type){
        this.type = type;
    }
    public String getType(){
        return type;
    }
    public int getCallsByTime(int time){
        return data.get(time);

    }
    public void addCallsByTime(int hourOfDay, int callAmount) {
        data.put(hourOfDay, callAmount);

    }

}

Answer 1

我首先检查两个数组的长度是否相同。然后使用for循环迭代：

final int timeLength = TIME.length;
if (timeLength != stat.size()) {
    //something may not be right
}
for (int i = 0; i < timeLength; i++) {
    System.out.println(time[i]+" "+stat.get(i));
}

Answer 2

for (int i = 0; i < TIME.length; i++) {
  // use i to access TIME[i] and stat.get(i)
}

但您必须确保这些数组具有相同的长度

Answer 3

您还需要考虑长度部分。您只需要迭代到覆盖数组和列表的最大可能长度。

因此，您可以先找到它们之间较短的长度。然后迭代直到那个长度： -

int lower = TIME.length < stat.size()? TIME.length: stat.size();

for (int i = 0; i < lower; i++) {
    System.out.println(TIME[i] + " : " + stat.get(i);
}

现在这是迭代两个数组的一部分。

现在我想说，如果你必须同时迭代两个数组，只需用属性创建一个class，你就已经创建了数组。

因此，创建一个包含属性的类： - time和stats。然后创建一个List<YourClass>。并迭代类实例列表。

Answer 4

if (TIME.length!=stat.size()) {
    // handle error
}

int count = stat.size();
for (int i=0; i<count; ++i) {
    double d = stat.get(i);
    String s = TIME[i];
}

然而

正如评论中所指出的，您应该定义一个将收集两个数组信息的类。

例如：

public class MyTime { 私人双重价值; 私有字符串标签; }

或

在这种特殊情况下，我怀疑你可以使用时间格式化函数来替换你的字符串数组。

String.format("%1$d:00", (int) myDouble);

循环通过两个数组

4 个答案:

然而

或