Java 使用两个迭代器进行迭代

我有两个数组列表，其中的项目数不同。 第一个迭代运行得很好，但是当它继续下一个迭代时，没有发生任何事情，我怀疑这是因为第二个迭代器没有下一个。有没有办法重置它

Iterator<Integer> itID = ID.iterator();
    Iterator<String> itTable = Table.iterator();
    Iterator<String> itColumn = Column.iterator();
    while(itID.hasNext()){
        int i = itID.next();
        System.out.println(i);
        while(itTable.hasNext()){
            String SQL = "select " + itColumn.next() + " from " +  itTable.next() + " where id=" + i;
            System.out.println(SQL);
        }
    }

Iterator itID=ID.Iterator（）；
迭代器itTable=Table.Iterator（）；
迭代器itColumn=Column.Iterator（）；
while（itID.hasNext（））{
int i=itID.next（）；
系统输出打印LN（i）；
while（itTable.hasNext（））{
String SQL=“从“+itTable.next（）+”中选择“+itColumn.next（）+”，其中id=“+i；
System.out.println（SQL）；
}
}

我认为问题在于您必须在第一个周期内移动迭代器

itTable

和

itColumn

的实例化

Iterator<Integer> itID = ID.iterator();
while (itID.hasNext()) {
    // Every time you ask for an iterator, you obtain a new one.
    Iterator<String> itTable = Table.iterator();
    Iterator<String> itColumn = Column.iterator();
    int i = itID.next();
    System.out.println(i);
    while(itTable.hasNext()){
        String SQL = "select " + itColumn.next() + " from " +  itTable.next() + " where id=" + i;
        System.out.println(SQL);
    }
}

Iterator itID=ID.Iterator（）；
while（itID.hasNext（））{
//每次请求迭代器时，都会得到一个新的迭代器。
迭代器itTable=Table.Iterator（）；
迭代器itColumn=Column.Iterator（）；
int i=itID.next（）；
系统输出打印LN（i）；
while（itTable.hasNext（））{
String SQL=“从“+itTable.next（）+”中选择“+itColumn.next（）+”，其中id=“+i；
System.out.println（SQL）；
}
}

---

因此，“重置”迭代器的最佳方法是向聚合请求迭代器本身的新实例。

我认为问题在于，您必须在第一个周期内移动迭代器的实例化

itTable

和

itColumn

Iterator<Integer> itID = ID.iterator();
while (itID.hasNext()) {
    // Every time you ask for an iterator, you obtain a new one.
    Iterator<String> itTable = Table.iterator();
    Iterator<String> itColumn = Column.iterator();
    int i = itID.next();
    System.out.println(i);
    while(itTable.hasNext()){
        String SQL = "select " + itColumn.next() + " from " +  itTable.next() + " where id=" + i;
        System.out.println(SQL);
    }
}

Iterator itID=ID.Iterator（）；
while（itID.hasNext（））{
//每次请求迭代器时，都会得到一个新的迭代器。
迭代器itTable=Table.Iterator（）；
迭代器itColumn=Column.Iterator（）；
int i=itID.next（）；
系统输出打印LN（i）；
while（itTable.hasNext（））{
String SQL=“从“+itTable.next（）+”中选择“+itColumn.next（）+”，其中id=“+i；
System.out.println（SQL）；
}
}

---

因此，“重置”迭代器的最佳方法是向聚合请求迭代器本身的新实例。

我认为问题在于，您必须在第一个周期内移动迭代器的实例化

itTable

和

itColumn

Iterator<Integer> itID = ID.iterator();
while (itID.hasNext()) {
    // Every time you ask for an iterator, you obtain a new one.
    Iterator<String> itTable = Table.iterator();
    Iterator<String> itColumn = Column.iterator();
    int i = itID.next();
    System.out.println(i);
    while(itTable.hasNext()){
        String SQL = "select " + itColumn.next() + " from " +  itTable.next() + " where id=" + i;
        System.out.println(SQL);
    }
}

Iterator itID=ID.Iterator（）；
while（itID.hasNext（））{
//每次请求迭代器时，都会得到一个新的迭代器。
迭代器itTable=Table.Iterator（）；
迭代器itColumn=Column.Iterator（）；
int i=itID.next（）；
系统输出打印LN（i）；
while（itTable.hasNext（））{
String SQL=“从“+itTable.next（）+”中选择“+itColumn.next（）+”，其中id=“+i；
System.out.println（SQL）；
}
}

---

因此，“重置”迭代器的最佳方法是向聚合请求迭代器本身的新实例。

我认为问题在于，您必须在第一个周期内移动迭代器的实例化

itTable

和

itColumn

Iterator<Integer> itID = ID.iterator();
while (itID.hasNext()) {
    // Every time you ask for an iterator, you obtain a new one.
    Iterator<String> itTable = Table.iterator();
    Iterator<String> itColumn = Column.iterator();
    int i = itID.next();
    System.out.println(i);
    while(itTable.hasNext()){
        String SQL = "select " + itColumn.next() + " from " +  itTable.next() + " where id=" + i;
        System.out.println(SQL);
    }
}

Iterator itID=ID.Iterator（）；
while（itID.hasNext（））{
//每次请求迭代器时，都会得到一个新的迭代器。
迭代器itTable=Table.Iterator（）；
迭代器itColumn=Column.Iterator（）；
int i=itID.next（）；
系统输出打印LN（i）；
while（itTable.hasNext（））{
String SQL=“从“+itTable.next（）+”中选择“+itColumn.next（）+”，其中id=“+i；
System.out.println（SQL）；
}
}

---

因此，“重置”迭代器的最佳方法是向聚合请求迭代器本身的新实例。

嵌套循环中使用的迭代器应在第一个循环内部初始化，以便在外部循环每次迭代时重置

但是您可以（也应该）使用for循环来迭代

ArrayList

：

for (int i = 0; i < myList.size(); i++) {
    // use myList.get(i)
}

---

对于每个循环，第二个循环称为

。它是为遍历列表和数组而设计的。出于您的目的，这一个将不起作用，因为您正在迭代2个列表，但我认为无论如何我都会提出它。您应该使用第一个for循环。
嵌套循环中使用的迭代器应该在第一个循环内部初始化，以便在外部循环每次迭代时重置

但是您可以（也应该）使用for循环来迭代
ArrayList
：

for (int i = 0; i < myList.size(); i++) {
    // use myList.get(i)
}

对于每个

循环，第二个循环称为

。它是为遍历列表和数组而设计的。出于您的目的，这一个将不起作用，因为您正在迭代2个列表，但我认为无论如何我都会提出它。您应该使用第一个for循环。
嵌套循环中使用的迭代器应该在第一个循环内部初始化，以便在外部循环每次迭代时重置

但是您可以（也应该）使用for循环来迭代
ArrayList
：

for (int i = 0; i < myList.size(); i++) {
    // use myList.get(i)
}

对于每个

循环，第二个循环称为

。它是为遍历列表和数组而设计的。出于您的目的，这一个将不起作用，因为您正在迭代2个列表，但我认为无论如何我都会提出它。您应该使用第一个for循环。
嵌套循环中使用的迭代器应该在第一个循环内部初始化，以便在外部循环每次迭代时重置

但是您可以（也应该）使用for循环来迭代
ArrayList
：

for (int i = 0; i < myList.size(); i++) {
    // use myList.get(i)
}

对于每个

循环，第二个循环称为

。它是为遍历列表和数组而设计的。出于您的目的，这一个将不起作用，因为您正在迭代2个列表，但我认为无论如何我都会提出它。您应该使用第一个for循环。
稍微超出了问题的范围，但这是我的想法。
迭代两个您认为大小相同的列表会带来麻烦。如果这两个值应该耦合在一起，那么。。把他们结合在一起。下面的类可以做到这一点：

class SQLField 
{
    private String tableName;
    private String columnName;
    public SQLField(String tableName, String columnName) {
        this.tableName = tableName;
        this.columnName = columnName;
    }

    public getSelect() {
        return "select " + this.columnName + " from " + this.tableName
    }
}

这使得使用代码：

Iterator<Integer> itID = ID.iterator();
while (itID.hasNext()) {
    // Every time you ask for an iterator, you obtain a new one.
    Iterator<SQLField> fields = SQLFields.iterator();
    int i = itID.next();
    System.out.println(i);
    for(SQLField field : fields) {
        String SQL = field.getSelect() + " where id = " + i;
        System.out.println(SQL);
    }
}

Iterator itID=ID.Iterator（）；
而(it d.ha)