हम लूप के लिए 4 आंतरिक से कैसे बाहर जा सकते हैं?

Question

हाय मैं जावा में शुरुआत हूँ और मेरा कार्यक्रम छोरों के लिए 4 है: मेरा कार्यक्रम इस तरह से काम करता है कि अगर btrue है, तत्व pointList से निकाल दिया जाएगा और nn-- हो जाएगा और मैं सभी से बाहर जाने के लिए चाहते हैं लूप के लिए और लूप के लिए पहले से फिर से आते हैं तो ll++ होगा, मैं यह कैसे कर सकता हूं? ब्रेक स्टेटमेंट के साथ?

for (int l = 0; l < n; l++) { 
    for (int i = 1; i < (n - 2); i++) { 
     for (int j = i + 1; j < (n - 1); j++) { 
      for (int k = j + 1; k < n; k++) { 
       if (l != i && l != j && l != k) { 
        boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
        System.out.println(b); 
        if (b == true) { 
         pointList.remove(pointList.get(l); 
         n--; 
         break; 
        } 
        else 
         System.out.println(b); 
       } 
      } 
     } 
    } 
} 

Answer 1

आप के रूप में एक लेबल को तोड़ने का उपयोग कर सकते हैं:

 for (int l = 0; l < n; l++) { 
foo: for (int i = 1; i < (n - 2); i++) { 
      for (int j = i + 1; j < (n - 1); j++) { 
       for (int k = j + 1; k < n; k++) { 
        if (l != i && l != j && l != k) { 
         boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
         System.out.println(b); 
         if (b == true) { 
          pointList.remove(pointList.get(l); 
          n--; 
          break foo; 
         } 
         else 
          System.out.println(b); 
        } 

       } 

      } 
     } 
    } 

Answer 2

लेबल तोड़ बयान

उदाहरण यहाँ

पर एक नज़र डालें: Branching Statements

Answer 3

String valueFromObj2 = null; 
String valueFromObj4 = null; 
OUTERMOST: for(Object1 object1: objects){ 
    for(Object2 object2: object1){ 
    //I get some value from object2 
    valueFromObj2 = object2.getSomeValue(); 
    for(Object3 object3 : object2){ 
     for(Object4 object4: object3){ 
     //Finally I get some value from Object4. 
     valueFromObj4 = object4.getSomeValue(); 
     //Compare with valueFromObj2 to decide either to break all the foreach loop 
     if(compareTwoVariable(valueFromObj2, valueFromObj4)) { 
      break OUTERMOST; 
     } 
     }//fourth loop ends here 
    }//third loop ends here 
    }//second loop ends here 
}//first loop ends here 

Answer 4

एक पहले 'त्वरित और गंदा' समाधान stay_into_loops चर का उपयोग करना होगा औरसंशोधित करना होगा 210 loops जैसे:

boolean stay_into_loops = true 
// here goes the first for loop 
for (int i = 1; i < (n - 2) && stay_into_loops ; i++) { 
      for (int j = i + 1; j < (n - 1) && stay_into_loops ; j++) { 
       for (int k = j + 1; k < n && stay_into_loops ; k++) { 
        if (l != i && l != j && l != k) { 
         boolean b = isOK(pointList.get(l), `pointList.get(i), pointList.get(j), pointList.get(k));` 
         System.out.println(b); 
         if (b == true) { 
          pointList.remove(pointList.get(l); 
          n--; 
          stay_into_loops = false; 
          break; 

हालांकि यह आमतौर पर एक कोड गंध होता है जब आप इन चीजों का सामना करते हैं। कोड को दोबारा प्रतिक्रिया देने पर विचार करें क्योंकि यह किसी बिंदु पर गड़बड़ी में बढ़ जाएगा।

Answer 5

एक लूप में break कथन आंतरिक लूप को समाप्त करता है जबकि continue अगले पुनरावृत्ति पर छोड़ देता है। इन दो कथनों के लिए आंतरिक लूप पर एक अलग लूप पर काम करने के लिए आपको labels का उपयोग करने की आवश्यकता है। कुछ इस तरह काम करना चाहिए:

outerloop:  
     for (int l = 0; l < n; l++) { 
      for (int i = 1; i < (n - 2); i++) { 
       for (int j = i + 1; j < (n - 1); j++) { 
        for (int k = j + 1; k < n; k++) { 
         if (l != i && l != j && l != k) { 
          boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
          System.out.println(b); 
          if (b == true) { 
           pointList.remove(pointList.get(l); 
           n--; 
           continue outerloop; 
          } 
          else 
           System.out.println(b); 
         } 

        } 

       } 
      } 
     } 

Answer 6

for (int l = 0; l < n; l++) { 
    loopa: 
    for (int i = 1; i < (n - 2); i++) { 
     for (int j = i + 1; j < (n - 1); j++) { 
      for (int k = j + 1; k < n; k++) { 
       if (l != i && l != j && l != k) { 
        boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
        System.out.println(b); 
        if (b == true) { 
         pointList.remove(pointList.get(l); 
         n--; 
         break loopa; 
        } 
        else 
         System.out.println(b); 
       } 

      } 

     } 
    } 
} 

एक लेबल पाश का उपयोग करें और फिर लेबल पाश

Answer 7

से तोड़ने के पाश के लिए प्रत्येक भीतरी में खुद के लिए एक निकास बनाएँ।
यहां एक त्वरित और दर्द रहित समाधान है।

bool breakout; 
    for (int l = 0; l < n; l++) 
    { 
     breakout = false; 
     for (int i = 1; i < (n - 2) && !breakout; i++) 
      for (int j = i + 1; j < (n - 1) && !breakout; j++) 
       for (int k = j + 1; k < n && !breakout; k++) 
       { 
        if(b == true) 
         breakout = true;        
       } 
    } 

तो आप देख breakout बूलियन coz यह हर for घोषणा में जाँच हो जाता है, प्रत्येक भीतरी लूप से बाहर अपने टिकट है। और यह हर बार पहली for पुनरावृत्त रीसेट हो जाता है।

Answer 8

again: 
for (int l = 0; l < n; l++) { 
     for (int i = 1; i < (n - 2); i++) { 
      for (int j = i + 1; j < (n - 1); j++) { 
       for (int k = j + 1; k < n; k++) { 
        if (l != i && l != j && l != k) { 
         boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
         System.out.println(b); 
         if (b == true) { 
          pointList.remove(pointList.get(l); 
          n--; 
          break again; 
         } 
         else 
          System.out.println(b); 
        } 

       } 

      } 
     } 
    } 

Answer 9

मैं अन्य सभी उत्तरों से सहमत हूं। हालांकि, मैं यह इंगित करना चाहता हूं कि exit का विकल्प केवल उस कोड को अपने दिनचर्या में रखना होगा और पूरी चीज़ को तोड़ने के लिए return कथन का उपयोग करना होगा। आपका क्वाड-नेस्टेड लूप स्वयं इतना जटिल है कि संभवतः यह संभवतः अपने स्वयं के दिनचर्या में होने का हकदार है।

मैंने डीओडी नौकरियों पर काम किया है जिसके लिए किसी भी एक दिनचर्या (कुछ अपवादों के साथ) के लिए 6 से अधिक की cyclomatic complexity की आवश्यकता है। अकेले लूप की यह श्रृंखला 4 है। यदि आपको ऐसा करने का एक आसान तरीका नहीं मिल रहा है, तो आपको वास्तव में उन गरीब schmucks की स्वच्छता को संरक्षित रखने के लिए उन्हें अपने नियमित रूप से चकना चाहिए जिन्हें इस कोड को बनाए रखना है।