在Java中访问嵌套数组列表时遇到问题

Question

对于笨重的标题，英语不是我的第一语言。

我有问题控制嵌套for循环是如何绕过列表的列表。

例如：我有字母{A，B，C，D，E，F，G，H，I}。他们在这样的二维列表中：

List<List<Character>> alphabet = new ArrayList<List<Character>>(3); 
alphabet.get(0).add('A'); 
alphabet.get(1).add('B'); 
alphabet.get(2).add('C'); 
alphabet.get(0).add('D'); 
alphabet.get(1).add('E'); 
alphabet.get(2).add('F'); 
alphabet.get(0).add('G'); 
alphabet.get(1).add('H'); 
alphabet.get(2).add('I'); 

因此，字母表中的每个第三个字母都在同一个列表中。 我有一些问题，使循环将通过字母表列表，并按正确的顺序重建字母表。任何帮助，将不胜感激。

这将是最好的解决方案，跨越去弄的字母按顺序A然后B然后C，然后D.

还是第一次下井每个列表，弄了那么d则G，当我移动到下一个列表，然后插入所需的位置？

谢谢

//改写

试想3个列表，在列表中。这3个列表代表了字母列。

alphabet = [[a, d, g, j], [b, e, h], [c, f, i]] 

什么是通过嵌套列表循环的最佳方式，并重建字母按正确的顺序？

然后我将结果放入一个字符串并写入一个文件。

这是我的for循环。

for(int k = 0, i = 0; k < decryptedtextColumns.get(i).size(); k++) 
{ 
    for(i = 0; i < decryptedtextColumns.size(); i++) 
    { 
     if(k <= decryptedtextColumns.get(i).size()) 
     { 
      Character letter = decryptedtextColumns.get(i).get(k); 
      decryptedtext.add(letter); 
     } 
    } 
} 

Answer 1

您必须使用MOD运算符并对char进行运算。

这里是一个可能的解决方案：

 for (int i = 0 ; i < 26 ; i++){ 
     alphabet.get(i%3).add((char) ('A' + i)); 
    } 

• 你实际使用i%3的MOD从0系统去2每一次加char'A' + i值你循环。

Answer 2

您基本上只需要mergesort算法中的合并函数的多维形式。

请查看以下代码IdeOne。

class Ideone 
{ 
    public static void main (String[] args) throws java.lang.Exception 
    { 
     List<List<Character>> alphabet = new ArrayList<List<Character>>(3); 
     List<Character> first = new ArrayList<Character>(); 
     first.add('a'); 
     first.add('d'); 
     first.add('g'); 
     first.add('i'); 
     List<Character> second = new ArrayList<Character>(); 
     second.add('b'); 
     second.add('e'); 
     second.add('h'); 
     List<Character> third = new ArrayList<Character>(); 
     third.add('c'); 
     third.add('f'); 
     third.add('j'); 
     alphabet.add(first); 
     alphabet.add(second); 
     alphabet.add(third); 

     List<Character> mergedSoFar = new ArrayList<Character>(); 
     for(int i = 0; i < alphabet.size(); ++i) { 
      List<Character> sortedLetters = alphabet.get(i); 
      mergedSoFar = merge(mergedSoFar, sortedLetters); 
     } 
     System.out.println(mergedSoFar); 
    } 

    private static List<Character> merge(List<Character> left, List<Character> right) { 
     List<Character> merged = new ArrayList<Character>(left.size() + right.size()); 
     int i = 0; 
     int j = 0; 
     while (i < left.size() && j < right.size()) { 
      char leftLetter = left.get(i); 
      char rightLetter = right.get(j); 
      int comparison = Character.compare(leftLetter, rightLetter); 
      if (comparison < 0) { 
       merged.add(leftLetter); 
       ++i; 
      } else if (comparison > 0) { 
       merged.add(rightLetter); 
       ++j; 
      } else { 
       // letters are same, add both 
       merged.add(leftLetter); 
       ++i; 
       merged.add(rightLetter); 
       ++j; 
      } 
     } 
     while(i < left.size()) { 
      merged.add(left.get(i)); 
      ++i; 
     } 
     while(j < right.size()) { 
      merged.add(right.get(j)); 
      ++j; 
     } 
     return merged; 
    } 
} 

Answer 3

的Java 8有一个简单的和短期的方式来做到这一点。

List<Character> sortedAlphabets= alphabet.stream().flatMap(list->list.stream()).sorted(). 
       collect(Collectors.toList()); 

产生输出

[A, B, C, D, E, F, G, H, I] 

Answer 4

设法得到它的工作。作为一个非常具体的事情，我不知道它会有多大的用处，但一般情况是如上所述。

for(int k = 0, i = 0; k < decryptedtextColumns.get(i%5).size(); k++) 
    {   
     i = 0; 
     while(i < decryptedtextColumns.size() && k < decryptedtextColumns.get(i).size()) 
     { 
      if(k <= decryptedtextColumns.get(i).size()) 
      { 
       Character letter = decryptedtextColumns.get(i).get(k); 
       decryptedtext.add(letter); 
      } 
      i++; 
     } 
    }