Java 嵌套循环模式

如果我有n个数字，最大数字是6，最大字母是F，那么最好的方法是什么

A1 
A2
A3
A4
A5 
A6 
B1
B2 
etc..

int numList = 36; 

         char letter;

        for (int i=1; i<=36; ++i){
            int a = numList/6;
            letter = 'A';
          for (int j=0; j<= a; j++){
            System.out.println(letter +"" + i);
            letter++;
          } 
    }

A1
A2
A3
A4
A5
A6
地下一层
地下二层
等
int numList=36；
字符字母；
对于（int i=1；i这将是代码：

    int[] array_of_ints; // declare and add the values into it - 1-6
    String[] array_of_alphabtes; // declare and add the values into it - A-F

    for (int i = 0; i < array_of_alphabtes.length; i++) {
        for (int j = 0; j < array_of_ints.length; j++) {
            System.out.println(array_of_alphabtes[i] + "" + array_of_ints[j]);
        }
    }

int[]array\u of_ints；//声明并向其中添加值-1-6
String[]数组\u of_alphabtes；//声明并将值添加到其中-A-F
for（int i=0；i
这将是代码：

    int[] array_of_ints; // declare and add the values into it - 1-6
    String[] array_of_alphabtes; // declare and add the values into it - A-F

    for (int i = 0; i < array_of_alphabtes.length; i++) {
        for (int j = 0; j < array_of_ints.length; j++) {
            System.out.println(array_of_alphabtes[i] + "" + array_of_ints[j]);
        }
    }

int[]array\u of_ints；//声明并向其中添加值-1-6
String[]数组\u of_alphabtes；//声明并将值添加到其中-A-F
for（int i=0；i
简而言之：

public static void main(String[] args) {
        for (int i = 0; i < 6; i++) {
            char c = (char) (i + 65);
            for (int j = 1; j <= 6; j++) {
                System.out.println("" + c + j);
            }
        }
    }

你们看到了。第一个循环不是真的（语法）。所以我们应该学习新的东西：Java中的char只是一个整数。（这在大多数语言中都是真的，比如C#，javascript…）但不是全部。所以我在这里查找。我看到
A
到
F
从65、66、67开始，所以我可以用6个元素开始循环。每个元素我添加到65中。例如：

0 -> 65 -> A
1 -> 66 -> B
2 -> 67 -> C

正如您所猜测的，这将成为我在上面发布的最后一段代码。希望这对您有所帮助：）
简而言之：

public static void main(String[] args) {
        for (int i = 0; i < 6; i++) {
            char c = (char) (i + 65);
            for (int j = 1; j <= 6; j++) {
                System.out.println("" + c + j);
            }
        }
    }

你看。第一个循环不正确（语法）。所以我们应该学习新的东西：Java中的char只是一个整数。（这在大多数语言中都是正确的，如C#、javascript……），但并非所有语言都是如此。所以我在这里查找。我看到
A
到
F
从65,66,67开始。。。所以我可以用6个元素开始循环。我加进去的每一个元素都是65。例如：

0 -> 65 -> A
1 -> 66 -> B
2 -> 67 -> C

正如你所猜测的，这将成为我在上面发布的最后一个代码。希望这对您有所帮助：）
当您有一个嵌套循环时，每次运行外部循环时，都会运行整个内部循环以及外部循环体的其余部分

在这里，每次运行

的内部

，内部循环的主体将执行6次，这意味着您将打印6行

按照您编写的方式：外部循环执行36次，每次外部循环运行时，内部循环执行6次。这意味着内部循环总共执行36*6=216次，导致打印216行。那不是你想要的。您希望外部循环只运行6次，因此您的第一个
for
需要更改

嵌套循环的另一个特性是：内部循环的重复速度比外部循环快。在您的例子中，当外部循环的第一次迭代运行时，内部循环执行6次。然后我们进入外循环的下一次迭代，内循环再执行6次；只有这样，我们才能第三次执行外部循环，以此类推

根据所需的输出，您希望数字的变化速度快于字母。这意味着在内环中数字需要增加1，而在外环中字母需要增加1。不过，你是在反向操作——你在增加内循环中的字母，在外循环中增加数字（
i
）

我不想给你代码——我希望我已经给了你足够的信息，你可以自己修复它。在查看其他人给您的代码之前，请尝试这样做。
当您有一个嵌套循环时，每次运行外部循环时，都会运行整个内部循环以及外部循环体的其余部分

在这里，每次运行

的内部

，内部循环的主体将执行6次，这意味着您将打印6行

按照您编写的方式：外部循环执行36次，每次外部循环运行时，内部循环执行6次。这意味着内部循环总共执行36*6=216次，导致打印216行。那不是你想要的。您希望外部循环只运行6次，因此您的第一个
for
需要更改

嵌套循环的另一个特性是：内部循环的重复速度比外部循环快。在您的例子中，当外部循环的第一次迭代运行时，内部循环执行6次。然后我们进入外循环的下一次迭代，内循环再执行6次；只有这样，我们才能第三次执行外部循环，以此类推

根据所需的输出，您希望数字的变化速度快于字母。这意味着在内环中数字需要增加1，而在外环中字母需要增加1。不过，你是在反向操作——你在增加内循环中的字母，在外循环中增加数字（
i
）

我不想给你代码——我希望我已经给了你足够的信息，你可以自己修复它。请在查看其他人提供给您的代码之前尝试执行此操作。
如下更改您的代码：

int numList = 36 / 6;
    char letter = 'A';
    for (int i = 1; i <= numList; ++i) {
        for (int j = 1; j <= numList; j++) {
            System.out.println(letter + "" + j);
        }
        letter++;
    }

int numList=36/6；
字符字母='A'；
对于（int i=1；i请按以下方式更改代码：

int numList = 36 / 6;
    char letter = 'A';
    for (int i = 1; i <= numList; ++i) {
        for (int j = 1; j <= numList; j++) {
            System.out.println(letter + "" + j);
        }
        letter++;
    }

int numList=36/6；
字符字母='A'；
因为（inti=1；我知道你和它有什么关系？最好的办法是去做。@宪兵歇斯底里了+1@Gendarme太好了+1你和它有什么关系？最好的办法是去做。@宪兵歇斯底里+1@Gendarme太好了+1我喜欢这个答案，因为它明确了每个“数字”的结构OP想要的。我喜欢这个答案，因为它明确了OP想要的每个“数字”的结构。请查看我更新的答案。我认为这将帮助你提高思维技能。请查看我更新的答案。我认为这将帮助你提高思维技能。