Java में नेस्टेड लूप से बाहर निकलने के 4 तरीके

नेस्टेड लूप में उलझ गए? आप अकेले नहीं हैं!

एक स्थिति की कल्पना करें: आप दो-आयामी ऐरे में सर्च कर रहे हैं, मैट्रिक्स प्रोसेस कर रहे हैं, या लिस्ट के अंदर लिस्ट में डुप्लिकेट ढूंढ रहे हैं। और अचानक आपको एहसास होता है — आपको सिर्फ अंदरूनी लूप को ही नहीं, बल्कि दोनों लूप को एक साथ तोड़ना है। यह दर्द आप जानते हैं? अगर आपने कभी गूगल पर "how do I break out of nested loops in Java" सर्च किया है — तो आप अकेले नहीं हैं। इस सवाल ने Stack Overflow पर लाखों व्यूज पाए हैं, और इसकी वजह है: Java में इस समस्या का कोई एक सरल single-keyword समाधान नहीं है।

इस लेख में हम Java में नेस्टेड लूप से बाहर निकलने के 4 विश्वसनीय तरीके समझेंगे। आप जानेंगे कि सामान्य break क्यों काम नहीं करता, लेबल (labels) का उपयोग कैसे करें, और कब लूप को छोड़कर ज़्यादा स्मार्ट समाधान अपनाना चाहिए। चलिए शुरू करते हैं!

सामान्य break समस्या का समाधान क्यों नहीं है?

आइए सीधे मुद्दे पर आते हैं। यहाँ शुरुआती लोगों द्वारा लिखा गया एक सामान्य कोड है:

int[][] matrix = {\n    {1, 2, 3},\n    {4, 5, 6},\n    {7, 8, 9}\n};\n\nint target = 5;\nboolean found = false;\n\nfor (int i = 0; i < matrix.length; i++) {\n    for (int j = 0; j < matrix[i].length; j++) {\n        if (matrix[i][j] == target) {\n            found = true;\n            break; // यह सिर्फ अंदरूनी लूप से बाहर निकलता है!\n        }\n    }\n    // बाहरी लूप चलता रहता है!\n}

समस्या स्पष्ट है: Java में break कीवर्ड केवल उसी लूप को तोड़ता है जिसमें वह मौजूद है। बाहरी लूप अपना काम जारी रखता है, और आप लॉजिक पर नियंत्रण खो देते हैं। यह सबसे आम गलतियों में से एक है, जिस पर "how to break nested loops in Java" के जवाबों में चर्चा की जाती है।

तरीका नंबर 1: लेबल वाले break (labeled break) का उपयोग

सबसे सीधा और नेटिव तरीका है — लेबल (labels)। हाँ, Java में goto-जैसा मैकेनिज्म है, लेकिन यह सिर्फ लूप के साथ काम करने तक सीमित है। यह इस तरह दिखता है:

int[][] matrix = {\n    {1, 2, 3},\n    {4, 5, 6},\n    {7, 8, 9}\n};\n\nint target = 5;\nboolean found = false;\n\nouterLoop: // ← बाहरी लूप के लिए लेबल\nfor (int i = 0; i < matrix.length; i++) {\n    for (int j = 0; j < matrix[i].length; j++) {\n        if (matrix[i][j] == target) {\n            found = true;\n            break outerLoop; // ← बाहरी लूप से बाहर निकलता है!\n        }\n    }\n}\n\nSystem.out.println("मिल गया: " + found); // true

यह कैसे काम करता है:

\n
• हम बाहरी लूप के पहले outerLoop: लेबल लगाते हैं (नाम कुछ भी हो सकता है, लेकिन कन्वेंशन के अनुसार camelCase या snake_case)।
\n
• जब break outerLoop; निष्पादित होता है, तो कंट्रोल बाहरी लूप के तुरंत बाद वाली लाइन पर चला जाता है।
\n

नुकसान: कुछ डेवलपर्स लेबल को "गंदी ट्रिक" मानते हैं जो पढ़ने में मुश्किल पैदा करती है। लेकिन व्यवहार में, सरल नेस्टेड लूप के लिए यह बिल्कुल सामान्य तरीका है। Stack Overflow पर "how do I break out of nested loops in Java" के लिए यह सबसे लोकप्रिय जवाब है।

तरीका नंबर 2: फ्लैग-वेरिएबल (boolean guard)

अगर लेबल आपको बहुत अजीब लगते हैं, तो क्लासिक फ्लैग का उपयोग करें। विचार सरल है: एक बूलियन वेरिएबल बनाएं जो बाहर निकलने का संकेत देता है।

int[][] matrix = {\n    {1, 2, 3},\n    {4, 5, 6},\n    {7, 8, 9}\n};\n\nint target = 5;\nboolean found = false;\n\nfor (int i = 0; i < matrix.length && !found; i++) { // ← शर्त में फ्लैग की जाँच\n    for (int j = 0; j < matrix[i].length; j++) {\n        if (matrix[i][j] == target) {\n            found = true;\n            break; // अंदरूनी लूप से बाहर निकलें\n        }\n    }\n    // बाहरी लूप भी खत्म हो जाएगा, क्योंकि found == true\n}\n\nSystem.out.println("मिल गया: " + found);

फायदे: कोड शुरुआती लोगों के लिए भी समझ में आता है, लेबल के ज्ञान की आवश्यकता नहीं है।

नुकसान: बाहरी लूप अभी भी एक अतिरिक्त इटरेशन करता है (शर्त की जाँच)