嵌套 for 循环答案

【问题标题】：Nested for loops嵌套 for 循环
【发布时间】：2011-10-27 06:31:31
【问题描述】：

我对常规 for 循环有很好的初学者理解，但我无法理解 Java 中的嵌套 for 循环。

在我正在处理的问题中，我有一个常量整数，它是一个最大数，然后我要求用户输入 4 个不同的数字。从这 4 个输入中，我试图确定我可以将它们中的哪一个放入我声明的常量整数“内部”。

IE：如果常量整数是 30，并且用户输入 5、9、3 和 21，它会告诉他们只能使用 5、9 和 3，因为 21 太大而无法相加。

故事形式的问题是，用户有一个背包，可以承受一定的重量。该程序要求用户输入 4 种不同的物品重量，然后决定哪些物品可以放入包中。

这是一个学校项目，所以我需要使用嵌套的 for 循环。

【问题讨论】：

你真的需要一个循环吗？不是简单的加法吗？
他们不能同时添加 5、3 和 21 (=29) 或 9 和 21 (=30) 吗？
如果您能解释一下您不明白的地方或您遇到困难的方面，我们可以更直接地回答您的问题。
是否按顺序处理用户输入？就像你从5开始，加9得到14，3得到17，然后发现你不能加21？如果是这样，我不明白你需要什么嵌套的 for 循环......
不，除了我提到的常量整数之外，这些数字不是静态的。问题基本上是一个人有一个可以容纳这么多重量/物品的背包。用户输入 4 个不同项目的重量，然后程序决定它可以拿 4 个项目中的哪一个。如果重量允许，可以携带多件物品。

标签： java loops for-loop nested

【解决方案1】：

考虑嵌套 for 循环的任何简单方法都是忽略它们是嵌套的事实。按照惯例，您通常将i 用于外部循环的增量计数器，将j 用于内部循环，这是在开始时保持直线的最重要的事情。如果这让您感到困惑，那么为您的增量变量使用比字母“i”和“j”更具描述性的名称可能对您有利，例如outer 和inner。

在任何给定时间，当您尝试构建程序逻辑时，您只需关注您最直接在其中工作的 for 循环 - 至少在您开始并第一次了解它们时.

【讨论】：

其实刚开始的时候你可能会考虑使用更具描述性的名字。
我不确定这是个好主意。嵌套循环的规模非常大，您需要首先确定它们是否是您在这种情况下真正需要的。

【解决方案2】：

我没有做过任何 JAVA，但我知道 C# 几乎相同。

我会这样做：

int max = 30;
int value = 0;
int counter = 0;
int[] input[4] = new int[5, 9, 3, 21];
bool[] canAddInput[4] = new bool[false, false, false, false];

for(value; value <= max; )
{
    for(counter; counter < 4; counter++)
    {
         value += input[i];
         if(value<=max)
             canAddInput[i] = true;
    }

    if(counter >= 4)
        Break;
}

【讨论】：

对不起。刚刚将代码更新为反向布尔印象数。否则可能会出现错误值。
有没有办法在没有数组的情况下做到这一点，而是通过用户输入（对话框）接收变量的值？现在我只声明了整数，然后通过用户输入分配值，但我不确定如何正确使用它们。
是的，当然他们是，但我不知道如何在 JAVA 中接收这些。在 C# WPF 中，您将使用 input[x] = int.Parse(TextBlock.text)，而在 C++ 中，您将使用 cin >> input[x]

【解决方案3】：

要了解嵌套循环，您可以从简单的示例开始，然后再尝试更努力的示例。例如，假设您要制作一个计数器。

int i, j;
for (i=0; i <= 9; i++)
{
    for (j=0; j <= 9; j++)
    {
        System.out.println(i+""+j)
    }
}

输出是从 00 到 99 的数字。您可以将循环的输出写在纸上或其他东西上，看看它是如何工作的。让我们以这个循环为例，你有这样的输出：

00 //here your program entered the outer loop, i has now the value 0, after that, you enter to the inner loop, i remains 0, but j will change in the next iteration
01 // you are still in the first iteration of the outer loop, but the inner loop is on the second
02 // and so on ....
03
04
05
06
07
08
09 // ... until the inner loop finished looping
10 // once the inner loop finished looping, the outer loop changes again, and we are back to the inner loop

一旦您清楚所有这些，您就可以决定嵌套循环的样子。外循环需要使用哪些变量，内循环需要使用哪些变量。

【讨论】：

【解决方案4】：

package com.examplehub.basics;

public class ForNestedLoop {
    public static void main(String[] args) {

        /*
         * ####
         * ####
         * ####
         */
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 4; j++) {
                System.out.print("#");
            }
            System.out.println("\n");
        }

        /*
         * Outer loop iteration 1
         * i = 1; j = 1
         * i = 1; j = 2
         * i = 1; j = 3
         * i = 1; j = 4
         * Outer loop iteration 2
         * i = 2; j = 1
         * i = 2; j = 2
         * i = 2; j = 3
         * i = 2; j = 4
         * Outer loop iteration 3
         * i = 3; j = 1
         * i = 3; j = 2
         * i = 3; j = 3
         * i = 3; j = 4
         */
        for (int i = 1; i <= 3; ++i) {

            System.out.println("Outer loop iteration " + i);

            for (int j = 1; j <= 4; ++j) {
                System.out.println("i = " + i + "; j = " + j);
            }
        }

        /*
         * 1
         * 12
         * 123
         * 1234
         * 12345
         */
        for (int i = 1; i <= 5; ++i) {
            for (int j = 1; j <= i; j++) {
                System.out.print("" + j);
            }
            System.out.println();
        }

        /*
         * 1*1=1
         * 1*2=2    2*2=4
         * 1*3=3    2*3=6   3*3=9
         * 1*4=4    2*4=8   3*4=12  4*4=16
         * 1*5=5    2*5=10  3*5=15  4*5=20  5*5=25
         * 1*6=6    2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
         * 1*7=7    2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
         * 1*8=8    2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
         * 1*9=9    2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81
         */
        for (int i = 1; i <= 9; ++i) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }

        /*
         * A
         * AB
         * ABC
         * ABCD
         * ABCDE
         */
        for (int i = 1; i <= 5; i++) {
            char letter = 'A';
            for (int j = 1; j <= i; j++) {
                System.out.print(letter++);
            }
            System.out.println();
        }

        /*
         * 1 2 3
         * 4 5 6
         * 7 8 9
         */
        int[][] array = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

        /*
         * 1 2 3
         * 4 5 6
         * 7 8 9
         */
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }
}

source

【讨论】：