मैं जावा में नेस्टेड लूप्स को कैसे तोड़ूं?


1818

मुझे इस तरह एक नेस्टेड लूप निर्माण मिला है:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             break; // Breaks out of the inner loop
         }
    }
}

अब मैं दोनों छोरों को कैसे तोड़ सकता हूं? मैंने ऐसे ही सवालों पर ध्यान दिया है, लेकिन कोई भी विशेष रूप से जावा की चिंता नहीं करता है। मैं इन समाधानों को लागू नहीं कर सका क्योंकि अधिकांश इस्तेमाल किया गया गोटो।

मैं आंतरिक लूप को अलग तरीके से नहीं रखना चाहता।

मैं छोरों को फिर से नहीं करना चाहता हूं। तोड़ते समय मैं लूप ब्लॉक के निष्पादन के साथ समाप्त हो गया हूं।

जवाबों:


2427

अन्य उत्तरदाताओं की तरह, मैं निश्चित रूप से छोरों को एक अलग विधि में रखना पसंद करूंगा , जिस बिंदु पर आप पूरी तरह से पुनरावृत्ति को रोकने के लिए वापस आ सकते हैं। यह उत्तर बताता है कि प्रश्न में आवश्यकताओं को कैसे पूरा किया जा सकता है।

आप breakबाहरी लूप के लिए एक लेबल के साथ उपयोग कर सकते हैं । उदाहरण के लिए:

public class Test {
    public static void main(String[] args) {
        outerloop:
        for (int i=0; i < 5; i++) {
            for (int j=0; j < 5; j++) {
                if (i * j > 6) {
                    System.out.println("Breaking");
                    break outerloop;
                }
                System.out.println(i + " " + j);
            }
        }
        System.out.println("Done");
    }
}

यह प्रिंट:

0 0
0 1
0 2
0 3
0 4
1 0
1 1
1 2
1 3
1 4
2 0
2 1
2 2
2 3
Breaking
Done

286
यह है पाश के बाद सीधे के लिए कूद। कोशिश करो! हां, लेबल लूप से पहले आता है, लेकिन ऐसा इसलिए है क्योंकि यह लूप को लेबल कर रहा है, बजाय उस जगह के जिसे आप बाहर निकलना चाहते हैं। (आप एक लेबल के साथ भी जारी रख सकते हैं।)
जॉन स्कीट

2
पर्ल अपने स्वयं के लेबल सिस्टम को भी इसकी अनुमति देता है। मुझे लगता है कि बहुत सारी भाषाएं करती हैं - यह शायद ही मुझे आश्चर्यचकित करता है कि यह जावा में है।
इवान कैरोल

9
@ इवान - यह दावा स्पष्ट रूप से सच है - उन भाषाओं में जो वादा करती हैं कि यह सच है। लेकिन जावा वह वादा नहीं करता है। यदि कोई भाषा आपकी मान्यताओं के विरोध में है, तो संभव है कि यह आपकी धारणाएं हैं जो गलती पर हैं। इस मामले में, मुझे लगता है कि आप अभी भी आंशिक रूप से सही हैं - कम से कम आश्चर्य की बात यह है कि उन लोगों के बारे में जो कभी नहीं सुना (या भूल गए थे) break। फिर भी, अपवाद एक और बेहतर ज्ञात अपवाद (क्षमा) हैं। लेकिन मैं अभी भी इस बारे में दुखी हूँ अगर यह स्पष्ट नहीं था (छोटे छोरों, चेतावनी टिप्पणी अगर लेबल / ब्रेक अभी भी पर्याप्त दिखाई नहीं दे रहे हैं)।
स्टीव 314

6
@ मुहम्मदबाबर: outerloopएक लेबल है। मुझे ठीक से पता नहीं है कि आपने कौन सा कोड आज़माया है, लेकिन मेरे उत्तर का कोड संकलन और ठीक चलता है।
जॉन स्कीट

4
@NisargPatil सिर्फ सोनारलिंट में होने के कारण यह इसे कोड गंध नहीं बनाता है। इसका मतलब यह है कि एक डेवलपर था जिसने इसे सोनारलिंट में एक व्यक्तिगत खुजली के साथ जोड़ा था, और यह इस प्रकार के नियमों से भरा है जो केवल दुर्व्यवहार करने पर समझ में आता है, या क्योंकि कुछ डेवलपर के पास उनके खिलाफ व्यक्तिगत घृणा धर्मयुद्ध है। लेबल टूटता है और जारी रखता है कि आप क्या करना चाहते हैं, इसका वर्णन करने के लिए एक बहुत ही सुंदर तरीका है।
जॉन 16384

402

बाहरी लूप को लेबल करने के लिए तकनीकी रूप से सही उत्तर है। अभ्यास में यदि आप किसी आंतरिक लूप के अंदर किसी भी बिंदु पर बाहर निकलना चाहते हैं तो आप कोड को एक विधि में स्थिर करना बेहतर होगा (यदि आवश्यक हो तो एक स्थिर विधि) और फिर उसे कॉल करें।

यह पठनीयता के लिए भुगतान करेगा।

कोड कुछ इस तरह बन जाएगा:

private static String search(...) 
{
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition) {
                // Do something and break...
                return search;
            }
        }
    }
    return null; 
}

स्वीकृत उत्तर के लिए उदाहरण से मिलान करना:

 public class Test {
    public static void main(String[] args) {
        loop();
        System.out.println("Done");
    }

    public static void loop() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (i * j > 6) {
                    System.out.println("Breaking");
                    return;
                }
                System.out.println(i + " " + j);
            }
        }
    }
}

30
कभी-कभी आप कई स्थानीय चरों का उपयोग करते हैं जो आंतरिक लूप के बाहर होते हैं, उन सभी को पास करते हुए क्लंकी महसूस कर सकते हैं।
होएस्ट

1
तो इस समाधान को स्वीकार किए गए उत्तर में "पूर्ण" कैसे माना जाता है?
जॉनडॉ डे

1
@JohnDoe आप इसे कॉल करते हैं और फिर आप System.out.println ("किया") प्रिंट करते हैं; कोशिश {} अंत में {} खोज विधि के भीतर भी एक विकल्प है।
Zo72

2
यह बेहतर अभ्यास है जो मुझे लगता है, लेकिन क्या होता है अगर आप तोड़ने के बजाय जारी रखना चाहते हैं? लेबल या तो समान रूप से (या बुरी तरह से) समर्थन करते हैं, लेकिन मुझे यकीन नहीं है कि इस तर्क को कैसे जारी रखा जाए।
रोब ग्रांट

@RobertGrant यदि आप ब्रेक के बजाय जारी रखना चाहते हैं, तो बाहरी लूप को loopविधि से बाहर ले जाएं और जारी रखने के लिए विधि से वापस लौटें।
मुहम्मद

215

आप छोरों के चारों ओर नामित ब्लॉक का उपयोग कर सकते हैं:

search: {
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition) {
                // Do something and break...
                break search;
            }
        }
    }
}

40
लेबल का उपयोग करने के लिए आपको एक नया ब्लॉक बनाने की आवश्यकता नहीं है।
जॉन स्कीट

81
नहीं, लेकिन यह इरादे को बहुत स्पष्ट करता है। स्वीकृत उत्तर पर पहली टिप्पणी देखें।
बॉम्बे

2
इसका वास्तव में नामांकित ब्लॉक नहीं है, लेबल के बाद आप किसी भी जावा एक्सप्रेशन को लेबल के बिना लिख ​​सकते हैं, क्या name: if(...){...}नाम दिया गया है? :)
ला व्लोज़ मेरिल

4
इस निर्माण में forसीधे लेबल लगाने का बड़ा फायदा है । आप अंतिम से पहले कोड जोड़ सकते हैं }जिसे केवल तभी निष्पादित किया जाएगा यदि शर्त कभी पूरी नहीं हुई थी।
फ्लोरियन एफ

2
यह एक नामित ब्लॉक है न कि नामित लूप। आप उस लूप के भीतर नहीं "खोज जारी रख सकते हैं;" जो पूरी तरह से एक कानूनी वाक्यविन्यास है अगर लूप का नाम खोज है। आप इसे तोड़ सकते हैं, लेकिन आप इसे जारी नहीं रख सकते।
तांत्रिक करें

132

मैं कभी भी लेबल का उपयोग नहीं करता। यह एक बुरा अभ्यास की तरह लगता है। यहाँ मैं क्या करूँगा:

boolean finished = false;
for (int i = 0; i < 5 && !finished; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 6) {
            finished = true;
            break;
        }
    }
}

4
&& !finishedइसके बजाय यह नहीं होना चाहिए || !finished? और फिर आंतरिक लूप के लिए भी उपयोग क्यों breakन करें && !finished?
गंडालफ

4
मैं breakमनमाने ढंग से पाश से बाहर निकलने में सक्षम होने के लिए उपयोग करता हूं । यदि उस ifब्लॉक के बाद कोड है , तो आप breakइसे निष्पादित करने से पहले कर सकते हैं । लेकिन तुम सही हो &&। ठीक कर दिया।
एले मुंडी

2
अच्छा समाधान! अगर वास्तव में इसे किसी अतिरिक्त कार्य में लगाना किसी कारण से बेहतर नहीं है, तो मैं वास्तव में ऐसा कैसे करूँगा।
बेनोर्थ

6
एक संभावित मुद्दा है अगर भीतर के लूप के बाद कुछ तर्क है ... जो निष्पादित होना जारी रहेगा और बाहरी लूप केवल तभी टूटता है जब नया चलना शुरू होता है ...
कार्तिक करुप्पन्नन

7
मुझे समझ नहीं आता कि किसी को ऐसा क्यों करना चाहिए। कोड के साथ काम करने वाले लोगों को किसी भाषा की सभी विशेषताओं का उपयोग करने में सक्षम होना चाहिए। मुझे लगता है कि यह कोड लिखना महत्वपूर्ण है जिसे अन्य लोग समझ सकते हैं, लेकिन एक भाषा द्वारा प्रदान किए गए आधिकारिक टूल के उपयोग को प्रतिबंधित करके और समान कार्यक्षमता के लिए वर्कअराउंड नहीं ढूंढ सकते हैं। या "बुरी प्रथा" से आपका कुछ और मतलब था?
कोडप्लेब

107

आप लेबल का उपयोग कर सकते हैं:

label1: 
for (int i = 0;;) {
    for (int g = 0;;) {
      break label1;
    }
}

4
मेरे से +1 है। इस बिंदु पर सरल, प्रश्न का उत्तर देता है। किसी मौजूदा उत्तर को दोहराने का आरोप नहीं लगाया जा सकता क्योंकि आपने उसी समय उत्तर दिया था।
हेमडाल

40

एक समारोह का उपयोग करें:

public void doSomething(List<Type> types, List<Type> types2){
  for(Type t1 : types){
    for (Type t : types2) {
      if (some condition) {
         // Do something and return...
         return;
      }
    }
  }
}

20

आप एक अस्थायी चर का उपयोग कर सकते हैं:

boolean outerBreak = false;
for (Type type : types) {
   if(outerBreak) break;
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             outerBreak = true;
             break; // Breaks out of the inner loop
         }
    }
}

आपके कार्य के आधार पर, आप आंतरिक लूप से बाहर निकल सकते हैं / लौट सकते हैं:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             return;
         }
    }
}

7
मैं इस तरह से बरबाद हो गया।
बट्टा

11
लूप के माध्यम से हर बार एक अतिरिक्त स्थिति की जांच करें? जी नहीं, धन्यवाद।
रयांडेंकी

15

अगर आपको breakएस और gotoएस पसंद नहीं है , तो आप अतिरिक्त गर्भपात की स्थिति के साथ फॉर-इन के बजाय लूप के लिए "पारंपरिक" का उपयोग कर सकते हैं:

int a, b;
bool abort = false;
for (a = 0; a < 10 && !abort; a++) {
    for (b = 0; b < 10 && !abort; b++) {
        if (condition) {
            doSomeThing();
            abort = true;
        }
    }
}

2
लूप्स को फोरच करने के लिए उपयुक्त नहीं है।
जॉन मैकक्लेन

1
@JohnMcClane और आप 9+ वर्ष पुराने प्रश्न पर कई उत्तरों पर इसे स्पैम कर रहे हैं क्योंकि ...?
क्विंटेक

12

मुझे एक समान काम करने की आवश्यकता थी, लेकिन मैंने इसे करने के लिए लूप के लिए बढ़ाया का उपयोग नहीं करने का विकल्प चुना।

int s = type.size();
for (int i = 0; i < s; i++) {
    for (int j = 0; j < t.size(); j++) {
        if (condition) {
            // do stuff after which you want 
            // to completely break out of both loops
            s = 0; // enables the _main_ loop to terminate
            break;
        }
    }
}

मुझे हालत खराब होने के बाद सभी वस्तुओं को पुनरावृत्त करने के लिए अच्छा नहीं लगता। इस प्रकार मैं अन्य मामले में एक विराम जोड़ूंगा।
बट्टटा

@boutta मुझे यकीन नहीं है कि आप इस निष्कर्ष पर कैसे पहुँच रहे हैं। एक बार स्थिति सही होने के बाद, दोनों छोरों को बाहर कर दिया जाता है।
स्विफ्टी मैकस्वीफ्टरटन

ठीक है, मुझे 's' var के हेरफेर के साथ भाग नहीं मिला। लेकिन मुझे लगता है कि एस के आकार का प्रतिनिधित्व करने के बाद से उस तरह की बुरी शैली है। फिर मैं स्पष्ट var के साथ ddyer से जवाब पसंद करता हूं: stackoverflow.com/a/25124317/15108
betta

@boutta आप sऐसे मान में बदल सकते हैं जो कम से कम हो iया iकिसी मान से अधिक या उसके बराबर में परिवर्तित हो s, दोनों को चाल चलनी चाहिए। आप बदलने के बारे में सही हैं s, क्योंकि इसे बाद में कहीं और इस्तेमाल किया जा सकता है, लेकिन बदलने iसे कोई नुकसान नहीं होगा, बस यह सुनिश्चित कर देगा कि पहला forलूपिंग जारी नहीं रखेगा।
जसोलती

9

मैं लूप परीक्षणों में एक स्पष्ट "निकास" जोड़ना पसंद करता हूं। यह किसी भी आकस्मिक पाठक को स्पष्ट करता है कि लूप जल्दी समाप्त हो सकता है।

boolean earlyExit = false;
for(int i = 0 ; i < 10 && !earlyExit; i++) {
     for(int j = 0 ; i < 10 && !earlyExit; j++) { earlyExit = true; }
}

लूप्स को फोरच करने के लिए उपयुक्त नहीं है।
जॉन मैकक्लेन

8

जावा 8 Streamसमाधान:

List<Type> types1 = ...
List<Type> types2 = ...

types1.stream()
      .flatMap(type1 -> types2.stream().map(type2 -> new Type[]{type1, type2}))
      .filter(types -> /**some condition**/)
      .findFirst()
      .ifPresent(types -> /**do something**/);

1
@ Tvde1 और अन्य उपयोगकर्ताओं के लिए अभी भी उपयोगी है, इसलिए नए तरीकों और समाधानों का हमेशा स्वागत है
आंद्रेई सुवर्कोव

वाह, यह बदसूरत है।
डी.एस.

7

आमतौर पर ऐसे मामलों में, यह अधिक सार्थक तर्क के दायरे में आ रहा है, आइए हम कहते हैं कि प्रश्न में कुछ 'for'- ऑब्जेक्ट्स पर कुछ खोज या हेरफेर करना, इसलिए मैं आमतौर पर कार्यात्मक दृष्टिकोण का उपयोग करता हूं:

public Object searching(Object[] types) { // Or manipulating
    List<Object> typesReferences = new ArrayList<Object>();
    List<Object> typesReferences2 = new ArrayList<Object>();

    for (Object type : typesReferences) {
        Object o = getByCriterion(typesReferences2, type);
        if(o != null) return o;
    }
    return null;
}

private Object getByCriterion(List<Object> typesReferences2, Object criterion) {
    for (Object typeReference : typesReferences2) {
        if(typeReference.equals(criterion)) {
             // here comes other complex or specific logic || typeReference.equals(new Object())
             return typeReference;
        }
    }
    return null;
}

प्रमुख विपक्ष:

  • लगभग दो बार अधिक लाइनें
  • कंप्यूटिंग चक्रों की अधिक खपत, जिसका अर्थ है कि यह एल्गोरिदमिक दृष्टिकोण से धीमा है
  • अधिक टाइपिंग का काम

गुण:

  • कार्यात्मक ग्रैन्युलैरिटी के कारण चिंताओं को अलग करने का उच्च अनुपात
  • पुन: प्रयोज्य और बिना तर्क के खोज / हेरफेर के नियंत्रण का उच्च अनुपात
  • तरीके लंबे नहीं हैं, इस प्रकार वे अधिक कॉम्पैक्ट और समझने में आसान हैं
  • पठनीयता का उच्च अनुपात

तो यह सिर्फ एक अलग दृष्टिकोण के माध्यम से मामले को संभाल रहा है।

मूल रूप से इस प्रश्न के लेखक के लिए एक प्रश्न: आप इस दृष्टिकोण पर क्या विचार करते हैं?


6

आप किसी भी लेबल का उपयोग किए बिना सभी छोरों से तोड़ सकते हैं: और झंडे।

यह सिर्फ मुश्किल समाधान है।

यहाँ कंडीशन 1 वह स्थिति है जो लूप के और जे से टूटने के लिए उपयोग की जाती है और कंडिशन 2 वह स्थिति है जिसका उपयोग लूप के, जे और आई से तोड़ने के लिए किया जाता है।

उदाहरण के लिए:

public class BreakTesting {
    public static void main(String[] args) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                for (int k = 0; k < 9; k++) {
                    if (condition1) {
                        System.out.println("Breaking from Loop K and J");
                        k = 9;
                        j = 9;
                    }
                    if (condition2) {
                        System.out.println("Breaking from Loop K, J and I");
                        k = 9;
                        j = 9;
                        i = 9;
                    }
                }
            }
        }
        System.out.println("End of I , J , K");
    }
}

2
मैं प्रत्येक लूप के लिए इसका उपयोग कैसे करूंगा? ;)
विल्ली मेंजेल

5
यदि आपके पास अधिक परिष्कृत लूप स्थिति है, तो यह काम नहीं करता है, जैसे list.size ()> 5। इसके अलावा यह वास्तव में सिर्फ एक हैक है। यह पढ़ना मुश्किल है और बुरा अभ्यास!
न्यूरॉन

यह त्रुटि-प्रवण है। कल्पना कीजिए कि आपने आंतरिक लूप को बदल दिया है (int k = 0; k < 10; k++)और आपने सभी को ठीक नहीं किया k = 9है k = 10। आप एक अनंत लूप में आ सकते हैं।
फ्लोरियन एफ

5

लेबल तोड़ अवधारणा का उपयोग जावा में नेस्टेड छोरों को तोड़ने के लिए किया जाता है, लेबल ब्रेक का उपयोग करके आप किसी भी स्थिति में छोरों के घोंसले को तोड़ सकते हैं। उदाहरण 1:

loop1:
 for(int i= 0; i<6; i++){
    for(int j=0; j<5; j++){
          if(i==3)
            break loop1;
        }
    }

मान लीजिए कि 3 लूप हैं और आप लूप 3 को समाप्त करना चाहते हैं: उदाहरण 2:

loop3: 
for(int i= 0; i<6; i++){
loop2:
  for(int k= 0; k<6; k++){
loop1:
    for(int j=0; j<5; j++){
          if(i==3)
            break loop3;
        }
    }
}

4
boolean broken = false; // declared outside of the loop for efficiency
for (Type type : types) {
    for (Type t : types2) {
        if (some condition) {
            broken = true;
            break;
        }
    }

    if (broken) {
        break;
    }
}

4

यदि यह किसी फ़ंक्शन के अंदर है तो आप इसे वापस क्यों नहीं करते हैं:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
            return value;
         }
    }
}

मुझे यह पैटर्न पसंद है। यह अक्सर मुझे एक अलग फ़ंक्शन में छोरों को तोड़ने का कारण बना है। ऐसा करने के बाद मेरा कोड हमेशा बेहतर रहा है, इसलिए इस कारण से मुझे वास्तव में यह उत्तर पसंद है।
बिल K

4

सबसे अच्छा और आसान तरीका ।।

outerloop:
for(int i=0; i<10; i++){
    // here we can break Outer loop by 
    break outerloop;

    innerloop:
    for(int i=0; i<10; i++){
        // here we can break innerloop by 
        break innerloop;
     }
}

4
तोड़ने के ये उदाहरण बहुत उपयोगी नहीं हैं, क्योंकि लेबल के बिना भी वे एक ही बिंदु पर टूटेंगे। यह भी हमेशा कोड के लिए अच्छा है जिसे आप वास्तव में निष्पादित कर सकते हैं, जो आपके कोड के साथ नहीं है, क्योंकि इनरलूप कभी नहीं पहुंच सकता है ..
न्यूरॉन

मैं वही टाइप करने जा रहा था। इस मामले में लेबल कुछ बेकार हैं।
तस्लीम ओसेनी

4

असामान्य दृष्टिकोण के बजाय, लेकिन कोड लंबाई ( प्रदर्शन नहीं ) के संदर्भ में यह सबसे आसान काम है जो आप कर सकते हैं:

for(int i = 0; i++; i < j) {
    if(wanna exit) {
        i = i + j; // if more nested, also add the 
                   // maximum value for the other loops
    }
}


4

एक और एक समाधान, उदाहरण के बिना उल्लेख किया गया (यह वास्तव में उत्पाद कोड में काम करता है)।

try {
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition #1) {
                // Do something and break the loop.
                throw new BreakLoopException();
            }
        }
    }
}
catch (BreakLoopException e) {
    // Do something on look breaking.
}

बेशक BreakLoopExceptionआंतरिक, निजी और बिना स्टैक-ट्रेस के साथ त्वरित होना चाहिए:

private static class BreakLoopException extends Exception {
    @Override
    public StackTraceElement[] getStackTrace() {
        return new StackTraceElement[0];
    }
}

1
यह वास्तव में उल्लेख किया गया है, एक जवाब में -23 वोट मिल रहे हैं ... stackoverflow.com/a/886980/2516301 । यह काम करेगा, लेकिन यह एक बहुत बुरा प्रोग्रामिंग अभ्यास है ...
14

वास्तव में। हालाँकि मैंने इस तरह की विरासत कोड - 4-स्तरों वाले नेस्टेड छोरों को कई टूटने वाली स्थितियों के साथ देखा। और यह इनबिल्ट कोड के बजाय अपवादों के साथ अधिक पठनीय था। -23 वोट ज्यादातर भावनात्मक रेटिंग है, लेकिन हां - इस दृष्टिकोण का उपयोग सावधानी से किया जाना चाहिए।
ursa

1
अगर केंद्र-रिटर्न के साथ एक अलग फ़ंक्शन कॉल में इसे तोड़ दिया गया होता तो यह और भी अधिक पठनीय होता। अक्सर थोड़ा रिफ्लेक्टर द्वारा इसे और भी बेहतर बनाया जाता है, इसलिए यह स्टैंड-अलोन (अक्सर पुन: प्रयोज्य) फ़ंक्शन के रूप में समझ में आता है।
बिल K

2

for (int j = 0; j < 5; j++) //inner loopके साथ प्रतिस्थापित किया जाना चाहिए for (int j = 0; j < 5 && !exitloops; j++)

यहाँ, इस स्थिति में पूर्ण नेस्टेड छोरों को बाहर निकलना चाहिए यदि स्थिति है True। लेकिन अगर हम exitloopsकेवल ऊपरी का उपयोग करते हैं loop

 for (int i = 0; i < 5 && !exitloops; i++) //upper loop

तब आंतरिक लूप जारी रहेगा, क्योंकि कोई अतिरिक्त ध्वज नहीं है जो इस आंतरिक लूप को बाहर निकलने के लिए सूचित करता है।

उदाहरण: यदि i = 3और j=2फिर स्थिति है false। लेकिन आंतरिक लूप के अगले पुनरावृत्ति में j=3 तब स्थिति (i*j)बन 9जाती है जो है, trueलेकिन आंतरिक लूप jबनने तक जारी रहेगा 5

तो, यह exitloopsआंतरिक छोरों के लिए भी उपयोग करना चाहिए ।

boolean exitloops = false;
for (int i = 0; i < 5 && !exitloops; i++) { //here should exitloops as a Conditional Statement to get out from the loops if exitloops become true. 
    for (int j = 0; j < 5 && !exitloops; j++) { //here should also use exitloops as a Conditional Statement. 
        if (i * j > 6) {
            exitloops = true;
            System.out.println("Inner loop still Continues For i * j is => "+i*j);
            break;
        }
        System.out.println(i*j);
    }
}

2

जैसे @ 1800 सूचना सुझाव, बाहरी लूप पर एक शर्त के रूप में आंतरिक लूप को तोड़ने वाली स्थिति का उपयोग करें:

boolean hasAccess = false;
for (int i = 0; i < x && hasAccess == false; i++){
    for (int j = 0; j < y; j++){
        if (condition == true){
            hasAccess = true;
            break;
        }
    }
}

2

यदि यह एक नया कार्यान्वयन है, तो आप तर्क को फिर से लिखने का प्रयास कर सकते हैं जैसे कि if-if_if-अन्यथा कथन।

while(keep_going) {

    if(keep_going && condition_one_holds) {
        // Code
    }
    if(keep_going && condition_two_holds) {
        // Code
    }
    if(keep_going && condition_three_holds) {
        // Code
    }
    if(keep_going && something_goes_really_bad) {
        keep_going=false;
    }
    if(keep_going && condition_four_holds) {
        // Code
    }
    if(keep_going && condition_five_holds) {
        // Code
    }
}

अन्यथा आप उस झंडे को स्थापित करने का प्रयास कर सकते हैं जब उस विशेष स्थिति में आपके प्रत्येक लूप-स्थिति में उस ध्वज की जाँच और जाँच हो।

something_bad_has_happened = false;
while(something is true && !something_bad_has_happened){
    // Code, things happen
    while(something else && !something_bad_has_happened){
        // Lots of code, things happens
        if(something happened){
            -> Then control should be returned ->
            something_bad_has_happened=true;
            continue;
        }
    }
    if(something_bad_has_happened) { // The things below will not be executed
        continue;
    }

    // Other things may happen here as well, but they will not be executed
    //  once control is returned from the inner cycle.
}

यहाँ! इसलिए, जबकि एक साधारण ब्रेक काम नहीं करेगा, इसका उपयोग करके काम किया जा सकता है continue

यदि आप बस एक प्रोग्रामिंग भाषा से तर्क को जावा में पोर्ट कर रहे हैं और केवल उस चीज को प्राप्त करना चाहते हैं जिसे आप लेबल का उपयोग करके देख सकते हैं


2

डेमो के लिए break, continueऔर label:

जावा कीवर्ड breakऔरcontinue एक डिफ़ॉल्ट मान है। यह "निकटतम लूप" है, और आज, जावा का उपयोग करने के कुछ वर्षों के बाद, मुझे बस मिल गया!

ऐसा लगता है कि यह दुर्लभ है, लेकिन उपयोगी है।

import org.junit.Test;

/**
 * Created by cui on 17-5-4.
 */

public class BranchLabel {
    @Test
    public void test() {
        System.out.println("testBreak");
        testBreak();

        System.out.println("testBreakLabel");
        testBreakLabel();

        System.out.println("testContinue");
        testContinue();
        System.out.println("testContinueLabel");
        testContinueLabel();
    }

    /**
     testBreak
     a=0,b=0
     a=0,b=1
     a=1,b=0
     a=1,b=1
     a=2,b=0
     a=2,b=1
     a=3,b=0
     a=3,b=1
     a=4,b=0
     a=4,b=1
     */
    public void testBreak() {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                if (b == 2) {
                    break;
                }
                System.out.println("a=" + a + ",b=" + b);
            }
        }
    }

    /**
     testContinue
     a=0,b=0
     a=0,b=1
     a=0,b=3
     a=0,b=4
     a=1,b=0
     a=1,b=1
     a=1,b=3
     a=1,b=4
     a=2,b=0
     a=2,b=1
     a=2,b=3
     a=2,b=4
     a=3,b=0
     a=3,b=1
     a=3,b=3
     a=3,b=4
     a=4,b=0
     a=4,b=1
     a=4,b=3
     a=4,b=4
     */
    public void testContinue() {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                if (b == 2) {
                    continue;
                }
                System.out.println("a=" + a + ",b=" + b);
            }
        }
    }

    /**
     testBreakLabel
     a=0,b=0,c=0
     a=0,b=0,c=1
     * */
    public void testBreakLabel() {
        anyName:
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    if (c == 2) {
                        break anyName;
                    }
                    System.out.println("a=" + a + ",b=" + b + ",c=" + c);
                }
            }
        }
    }

    /**
     testContinueLabel
     a=0,b=0,c=0
     a=0,b=0,c=1
     a=1,b=0,c=0
     a=1,b=0,c=1
     a=2,b=0,c=0
     a=2,b=0,c=1
     a=3,b=0,c=0
     a=3,b=0,c=1
     a=4,b=0,c=0
     a=4,b=0,c=1
     */
    public void testContinueLabel() {
        anyName:
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    if (c == 2) {
                        continue anyName;
                    }
                    System.out.println("a=" + a + ",b=" + b + ",c=" + c);
                }
            }
        }
    }
}

2

डेमो

public static void main(String[] args) {
    outer:
    while (true) {
        while (true) {
            break outer;
        }
    }
}

1

आप निम्न कार्य कर सकते हैं:

  1. के लिए एक स्थानीय चर सेट करें false

  2. उस चर trueको पहले लूप में सेट करें , जब आप तोड़ना चाहते हैं

  3. फिर आप बाहरी लूप में जांच कर सकते हैं कि क्या हालत सेट है या नहीं, बाहरी लूप से भी टूट सकता है।

    boolean isBreakNeeded = false;
    for (int i = 0; i < some.length; i++) {
        for (int j = 0; j < some.lengthasWell; j++) {
            //want to set variable if (){
            isBreakNeeded = true;
            break;
        }
    
        if (isBreakNeeded) {
            break; //will make you break from the outer loop as well
        }
    }

1

कुछ मामलों के लिए, हम whileयहाँ प्रभावी रूप से लूप का उपयोग कर सकते हैं।

Random rand = new Random();
// Just an example
for (int k = 0; k < 10; ++k) {
    int count = 0;
    while (!(rand.nextInt(200) == 100)) {
       count++;
    }

    results[k] = count;
}

1

जावा में गोटो फीचर नहीं है जैसे C ++ में है। लेकिन फिर भी, gotoजावा में एक आरक्षित कीवर्ड है। वे भविष्य में इसे लागू कर सकते हैं। आपके प्रश्न के लिए, इसका उत्तर यह है कि जावा में लेबल नाम की कोई चीज है जिससे आप एक continueऔर breakस्टेटमेंट लगा सकते हैं। नीचे कोड खोजें:

public static void main(String ...args) {
    outerLoop: for(int i=0;i<10;i++) {
    for(int j=10;j>0;j--) {
        System.out.println(i+" "+j);
        if(i==j) {
            System.out.println("Condition Fulfilled");
            break outerLoop;
        }
    }
    }
    System.out.println("Got out of the outer loop");
}

1

यहां तक ​​कि बाहरी लूप के लिए एक झंडा बनाना और यह जांचना कि आंतरिक लूप के प्रत्येक निष्पादन के बाद उत्तर हो सकता है।

ऐशे ही:

for (Type type : types) {
    boolean flag=false;
    for (Type t : types2) {
        if (some condition) {
            // Do something and break...
            flag=true;
            break; // Breaks out of the inner loop
        }
    }
    if(flag)
        break;
}

1
boolean condition = false;
for (Type type : types) {
    for (int i = 0; i < otherTypes.size && !condition; i ++) {
        condition = true; // If your condition is satisfied
    }
}

conditionजब आप प्रसंस्करण कर रहे हों तो ध्वज के रूप में उपयोग करें । तब आंतरिक लूप केवल जारी रहता है, जबकि स्थिति पूरी नहीं हुई है। किसी भी तरह से, बाहरी लूप chuggin पर रखेंगे। '

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.