آموزش حلقه‌های تکرار تو در تو (Nested Loop) در جاوا

حلقه تو در تو چیست؟

در برنامه‌نویسی جاوا، زمانی که یک حلقه درون حلقه دیگری قرار می‌گیرد، به آن حلقه تو در تو (Nested Loop) می‌گویند.
حلقه بیرونی یک بار اجرا می‌شود و به ازای هر بار اجرای آن، حلقه درونی به طور کامل اجرا می‌شود.
این مفهوم یکی از قدرتمندترین ابزارها برای کار با ماتریس‌ها، جداول، الگوهای ستاره‌ای، مرتب‌سازی، جستجو و پردازش داده‌های دوبعدی است.

ساختار کلی یک حلقه تو در تو در جاوا به شکل زیر است:

for (int i = 0; i < 5; i++) {        // حلقه بیرونی
    for (int j = 0; j < 3; j++) {    // حلقه درونی
        // کد داخلی هر بار اجرا می‌شود
    }
}

در این مثال، حلقه درونی ۳ بار به ازای هر بار اجرای حلقه بیرونی اجرا می‌شود.
در نتیجه مجموعاً ۵×۳ = ۱۵ بار بدنه داخلی اجرا خواهد شد.

آموزش Nested Loop در جاوا (از صفر تا صد)

۱.۱ تعریف و مفهوم پایه

حلقه تو در تو می‌تواند ترکیبی از هر نوع حلقه‌ای باشد: for داخل for، while داخل for، do-while داخل while و هر ترکیب دیگری.
رایج‌ترین شکل آن، for تو در تو است.

// مثال بسیار ساده
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 2; j++) {
        System.out.println("i = " + i + " , j = " + j);
    }
}

خروجی:

i = 1 , j = 1
i = 1 , j = 2
i = 2 , j = 1
i = 2 , j = 2
i = 3 , j = 1
i = 3 , j = 2

۱.۲ توضیح گام به گام اجرای حلقه تو در تو

مراحل اجرای کد بالا:

• مرحله ۱: i=1 → وارد حلقه بیرونی می‌شود
• مرحله ۲: j از ۱ تا ۲ اجرا می‌شود (دو بار)
• مرحله ۳: i=2 → دوباره حلقه درونی کامل اجرا می‌شود
• مرحله ۴: i=3 → یک بار دیگر حلقه درونی اجرا می‌شود
• مرحله ۵: i=4 → شرط حلقه بیرونی نقض می‌شود و پایان

۱.۳ حلقه تو در تو با while

int i = 1;
while (i <= 3) {
    int j = 1;
    while (j <= 2) {
        System.out.print("* ");
        j++;
    }
    System.out.println();
    i++;
}

خروجی:

* *
* *
* *

۱.۴ ترکیب حلقه for و while

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

خروجی:

1
1 2
1 2 3

این مثال نشان می‌دهد که تعداد اجرای حلقه درونی می‌تواند به متغیر حلقه بیرونی وابسته باشد.

 

🚀 از صفر تا قهرمان جاوا، فقط با یک دوره!
به دنبال یه فرصت طلایی برای شروع برنامه‌نویسی می‌گردی؟
دوره آموزشی جاوا ما، همون چیزیه که نیاز داری!

✨ چرا این دوره رو انتخاب می‌کنی؟
🎯 از مبتدی تا حرفه‌ای
بدون پیش‌زمینه شروع می‌کنی و به یه برنامه‌نویس جاوا تبدیل می‌شی که بازار کار منتظرته!

🛠 پروژه‌محور و عملی
با انجام پروژه‌های واقعی، کدنویسی رو یاد می‌گیری، نه فقط تئوری!

👨‍🏫 پشتیبانی همیشگی
هرجا گیر کنی، تیم پشتیبانی کنارته تا مشکلت حل بشه.

🔓 دسترسی مادام‌العمر
هر وقت خواستی به محتوا دسترسی داری، برای همیشه!

 

🔥 همین حالا ثبت‌نام کن 

حلقه‌های تکرار تو در تو در جاوا (کاربردها و اصول)

۲.۱ چرا به حلقه تو در تو نیاز داریم؟

بسیاری از مسائل دنیای واقعی بدون حلقه تو در تو قابل حل نیستند یا کد بسیار پیچیده‌ای خواهند داشت.
موارد کاربرد عبارتند از:

• پردازش آرایه‌های دو بعدی (ماتریس‌ها) – مثلاً جمع دو ماتریس، ضرب ماتریس، چاپ ماتریس
• جستجو در داده‌های دوبعدی – پیدا کردن یک عدد در جدول
• مرتب‌سازی پیشرفته – مثل مرتب‌سازی حبابی (Bubble Sort)
• تولید الگوهای گرافیکی – مثل مثلث ستاره‌ای، الماس، جدول ضرب
• مقایسه همه جفت‌های یک آرایه – مثلاً پیدا کردن جفتی که مجموعشان مشخص است

۲.۲ آنالیز تعداد اجراها (پیچیدگی زمانی)

اگر حلقه بیرونی n بار و حلقه درونی m بار اجرا شود، کد داخلی n × m بار اجرا می‌شود. پیچیدگی زمانی از مرتبه O(n×m) است.

مثال با n=1000 و m=1000 یعنی یک میلیون بار اجرا. پس در حلقه‌های تو در تو باید به عملکرد (Performance) توجه کرد.

۲.۳ نکات مهم در نوشتن حلقه تو در تو

از نام‌گذاری مناسب برای متغیرها استفاده کنید: معمولاً i, j, k برای حلقه‌های اول، دوم و سوم

• از break و continue با احتیاط استفاده کنید، زیرا فقط روی نزدیک‌ترین حلقه تأثیر می‌گذارند
• برای خروج از همه حلقه‌ها می‌توانید از برچسب (Label) استفاده کنید
• سعی کنید عمق تو رفتگی بیش از ۳ سطح نباشد، در غیر این صورت کد غیرقابل خواندن می‌شود

۲.۴ استفاده از برچسب (Label) برای کنترل حلقه‌های تو در تو

outer: for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (i == 2 && j == 2) {
            break outer; // از هر دو حلقه خارج می‌شود
        }
        System.out.println("i=" + i + " j=" + j);
    }
}

خروجی:

i=1 j=1
i=1 j=2
i=1 j=3
i=2 j=1

با رسیدن به i=2 و j=2، حلقه بیرونی هم متوقف می‌شود.

 مثال حلقه تو در تو در جاوا (سناریوهای متنوع)

۳.۱ مثال ۱: چاپ ماتریس اعداد

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

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

خروجی:

1 2 3
4 5 6
7 8 9

۳.۲ مثال ۲: جمع دو ماتریس

int[][] a = {{1, 2}, {3, 4}};
int[][] b = {{5, 6}, {7, 8}};
int[][] sum = new int[2][2];

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 2; j++) {
        sum[i][j] = a[i][j] + b[i][j];
        System.out.print(sum[i][j] + " ");
    }
    System.out.println();
}

خروجی:

6 8
10 12

۳.۳ مثال ۳: جدول ضرب کامل (۱ تا ۱۰)

for (int i = 1; i <= 10; i++) {
    for (int j = 1; j <= 10; j++) {
        System.out.printf("%4d", i * j);
    }
    System.out.println();
}

این کد جدول ضرب ۱۰×۱۰ را به صورت مرتب چاپ می‌کند.

۳.۴ مثال ۴: الگوی مثلث ستاره‌ای

int rows = 5;
for (int i = 1; i <= rows; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

خروجی:

*
* *
* * *
* * * *
* * * * *

۳.۵ مثال ۵: مثلث معکوس

for (int i = 5; i >= 1; i--) {
    for (int j = 1; j <= i; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

۳.۶ مثال ۶: اعداد اول بین ۱ تا ۵۰ (دو حلقه تو در تو)

for (int num = 2; num <= 50; num++) {
    boolean isPrime = true;
    for (int divisor = 2; divisor <= num / 2; divisor++) {
        if (num % divisor == 0) {
            isPrime = false;
            break;
        }
    }
    if (isPrime) {
        System.out.print(num + " ");
    }
}

۳.۷ مثال ۷: جستجوی عدد در ماتریس

int[][] matrix = {
    {10, 20, 30},
    {40, 50, 60},
    {70, 80, 90}
};
int target = 50;
boolean found = false;

outer: for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        if (matrix[i][j] == target) {
            System.out.println("عدد " + target + " در سطر " + i + " و ستون " + j + " پیدا شد");
            found = true;
            break outer;
        }
    }
}
if (!found) {
    System.out.println("عدد یافت نشد");
}

۳.۸ مثال ۸: ضرب ماتریس‌ها (پیشرفته)

ضرب دو ماتریس ۲×۲:

int[][] A = {{1, 2}, {3, 4}};
int[][] B = {{5, 6}, {7, 8}};
int[][] C = new int[2][2];

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 2; j++) {
        for (int k = 0; k < 2; k++) {
            C[i][j] += A[i][k] * B[k][j];
        }
        System.out.print(C[i][j] + " ");
    }
    System.out.println();
}

این مثال سه حلقه تو در تو دارد. حلقه سوم (k) برای ضرب سطر در ستون استفاده می‌شود.

۳.۹ مثال ۹: حذف المان‌های تکراری از آرایه (مقایسه زوج به زوج)

int[] arr = {1, 2, 2, 3, 4, 4, 5};
System.out.print("آرایه اصلی: ");
for (int n : arr) System.out.print(n + " ");

System.out.print("\nتکراری‌ها: ");
for (int i = 0; i < arr.length; i++) {
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[i] == arr[j]) {
            System.out.print(arr[i] + " ");
            break;
        }
    }
}

۳.۱۰ مثال ۱۰: مرتب‌سازی حبابی (Bubble Sort) با دو حلقه تو در تو

int[] arr = {64, 34, 25, 12, 22, 11, 90};
int n = arr.length;

for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

System.out.print("آرایه مرتب شده: ");
for (int num : arr) System.out.print(num + " ");

خروجی:

 آرایه مرتب شده: 11 12 22 25 34 64 90
 

اشتباهات رایج حلقه‌های تکرار تو در تو 

اشتباه ۱: استفاده از متغیر یکسان در حلقه‌های تو در تو

for (int i = 0; i < 3; i++) {
    for (int i = 0; i < 2; i++) { // خطا: i قبلاً تعریف شده
        // کد
    }
}

هر متغیر حلقه باید نام متفاوت داشته باشد مثل i و j.

اشتباه ۲: فراموشی آکولاد

for (int i = 0; i < 3; i++)
    for (int j = 0; j < 2; j++)
        System.out.println("داخلی");
    System.out.println("بیرونی"); // این خط فقط یک بار اجرا می‌شود

تنها اولین عبارت بعد از for جزو حلقه است. برای چند دستور باید از {} استفاده کرد.

اشتباه ۳: ایجاد حلقه بی‌نهایت

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 10; j--) { // j-- باعث می‌شود j همیشه کمتر از ۱۰ بماند
        // حلقه درونی بی‌نهایت
    }
}

نتیجه‌گیری

حلقه‌های تو در تو یکی از ستون‌های اصلی برنامه‌نویسی در جاوا هستند.
مسلط شدن به آنها شما را قادر می‌سازد هر نوع داده ساختار دوبعدی یا چندبعدی را پردازش کنید و الگوریتم‌های پیچیده‌تری را پیاده‌سازی نمایید.
پیشنهاد می‌کنم حتماً همه مثال‌ها را در IDE اجرا کنید و با تغییر اعداد، الگوهای جدید تولید کنید.
تسلط بر این مبحث پایه‌ای برای یادگیری مباحث پیشرفته‌تر مانند recursion، dynamic programming و الگوریتم‌های گراف است.