ජාවා හි කැදැලි වළළු ඉවත් කරන්නේ කෙසේද?


1822

මට මේ වගේ කැදැලි ලූපයක් තියෙනවා:

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

දැන් මම ලූප දෙකෙන්ම ඉවත් වන්නේ කෙසේද? මම සමාන ප්‍රශ්න දෙස බැලුවෙමි, නමුත් කිසිවෙකු ජාවා ගැන විශේෂයෙන් සැලකිලිමත් නොවේ. බොහෝ විට භාවිතා කරන ලද ගොටෝස් නිසා මට මෙම විසඳුම් යෙදීමට නොහැකි විය.

අභ්‍යන්තර ලූපය වෙනත් ක්‍රමයකට දැමීමට මට අවශ්‍ය නැත.

මට ලූප නැවත ධාවනය කිරීමට අවශ්‍ය නැත. කැඩෙන විට මම ලූප් බ්ලොක් ක්‍රියාත්මක කිරීම අවසන් කර ඇත්තෙමි.

Answers:


2438

වෙනත් answerers මෙන්, මම අනිවාර්යයෙන්ම කැමතියි කැමති ඔබ සම්පූර්ණයෙන්ම එල්ලාවල මහතා නතර කිරීමට නැවත හැකි අවස්ථාවක දී වෙනස් ක්රමයක්, දී වළළු දමා. මෙම පිළිතුර මඟින් ප්‍රශ්නයේ අවශ්‍යතා සපුරාලිය හැකි ආකාරය පෙන්වයි.

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

289
මෙම කරන්නේ සෘජුවම පුඩුවක් පසු වෙත පනින්න. උත්සහ කරන්න! ඔව්, ලේබලය ලූපයට පෙර පැමිණේ, නමුත් එයට හේතුව එය ඔබට පිටවීමට අවශ්‍ය ස්ථානයට වඩා ලූපය ලේබල් කිරීමයි. (ඔබට ලේබලයක් සමඟද ඉදිරියට යා හැකිය.)
ජෝන් ස්කීට්

2
පර්ල් ද තමන්ගේම ලේබල් පද්ධතියට අවසර දෙයි. මම හිතන්නේ බොහෝ භාෂාවන් එසේ කරයි - එය ජාවාහි තිබීම පුදුමයක් නොවේ.
ඉවාන් කැරොල්

9
@ ඊවාන් - එම ප්‍රකාශය පැහැදිලිවම සත්‍යයකි - එය සත්‍ය යැයි පොරොන්දු වන භාෂාවලින්. නමුත් ජාවා ඒ පොරොන්දුව දෙන්නේ නැහැ. භාෂාවක් ඔබගේ උපකල්පන සමඟ ගැටෙන්නේ නම්, එය ඔබගේ උපකල්පන වැරදියි. මේ අවස්ථාවේ දී, මම හිතන්නේ ඔබ තවමත් අර්ධ වශයෙන් නිවැරදියි - අවම වශයෙන් පුදුමයට පත් කිරීමේ මූලධර්මය WRT බොහෝ විට එම ස්වරූපය ගැන අසා නැති (හෝ අමතක වී නැති) බොහෝ දෙනෙක් break. එසේ වුවද, ව්‍යතිරේකයන් යනු වඩාත් හොඳින් දන්නා තවත් ව්‍යතිරේකයකි (සමාවෙන්න). නමුත් එය පැහැදිලිව පෙනෙන්නට නොතිබුණි නම් මම තවමත් ඒ ගැන නොසතුටින් සිටිමි (කුඩා ලූප, ලේබලය / බිඳීම තවමත් ප්‍රමාණවත් නොවේ නම් අනතුරු ඇඟවීමේ අදහස්).
ස්ටීව් 314

7
U මුහම්මද්බබාර්: outerloopලේබලයකි. ඔබ උත්සාහ කළේ කුමන කේතයදැයි මම හරියටම නොදනිමි, නමුත් මගේ පිළිතුරේ කේතය සම්පාදනය කර හොඳින් ක්‍රියාත්මක වේ.
ජෝන් ස්කීට්

5
IsNisargPatil එය සෝනාර්ලින්ට් හි ඇති නිසා එය කේත සුවඳක් ඇති නොකරයි. එහි අර්ථය වන්නේ මෙය සීරීමට පුද්ගලික කැසීමකින් සෝනාර් ලින්ට් වෙත එකතු කළ සංවර්ධකයෙකු සිටි අතර එය අපයෝජනය කළ විට පමණක් අර්ථවත් වන මෙම නීති රීති වලින් පිරී ඇති අතර හෝ සමහර සංවර්ධකයින්ට එරෙහිව පුද්ගලික වෛරී කුරුස යුද්ධයක් ඇති බැවිනි. ලේබල් කරන ලද විවේක සහ අඛණ්ඩව ඔබට කිරීමට අවශ්‍ය දේ විස්තර කිරීමට ඉතා අලංකාර ක්‍රමයකි.
john16384

404

තාක්ෂණික වශයෙන් නිවැරදි පිළිතුර වන්නේ පිටත ලූපය ලේබල් කිරීමයි. ප්‍රායෝගිකව ඔබට අභ්‍යන්තර ලූපයක් තුළ ඕනෑම වේලාවක පිටවීමට අවශ්‍ය නම් කේතය ක්‍රමයකට බාහිරකරණය කිරීම වඩා හොඳ වනු ඇත (අවශ්‍ය නම් ස්ථිතික ක්‍රමයක්) පසුව එය අමතන්න.

එය කියවීමේ හැකියාව සඳහා ගෙවනු ඇත.

කේතය එවැනි දෙයක් බවට පත්වේ:

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);
            }
        }
    }
}

31
සමහර විට ඔබ අභ්‍යන්තර පුඩුවෙන් පිටත ඇති දේශීය විචල්‍යයන් කිහිපයක් භාවිතා කරයි.
Haoest

1
ඉතින් පිළිගත් පිළිතුරෙහි මෙන් මෙම විසඳුම “සිදු විය” මුද්‍රණය කරන්නේ කෙසේද?
JohnDoe

1
@ ජෝන් ඩෝ ඔබ එය අමතා System.out.println ("කර ඇත") මුද්‍රණය කරයි; සෙවුම් ක්‍රමය තුළ {} අවසානයේ {try උත්සාහ කරන්න ද විකල්පයකි.
Zo72

2
මෙය මම අනුමාන කරන වඩා හොඳ පුහුණුවකි, නමුත් ඔබට කඩාවැටීම වෙනුවට ඉදිරියට යාමට අවශ්‍ය නම් කුමක් සිදුවේද? ලේබල් එක හා සමානව (හෝ නරක ලෙස!) සහය දක්වයි, නමුත් මෙම තර්කනය දිගටම කරගෙන යන්නේ කෙසේදැයි මට විශ්වාස නැත.
රොබ් ග්‍රාන්ට්

Ob රොබට් ග්‍රාන්ට් ඔබට විවේකයක් වෙනුවට ඉදිරියට යාමට අවශ්‍ය නම්, පිටත ලූපය loopක්‍රමයෙන් පිටත ගෙන ගොස් ක්‍රමයෙන් ආපසු ඉදිරියට යන්න.
මුහ්ඩ්

216

ඔබට ලූප වටා නම් කළ බ්ලොක් එකක් භාවිතා කළ හැකිය:

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

41
ලේබලයක් භාවිතා කිරීම සඳහා ඔබට නව බ්ලොක් එකක් සෑදීමට අවශ්‍ය නොවේ.
ජෝන් ස්කීට්

82
නැත, නමුත් එය අභිප්‍රාය වඩාත් පැහැදිලි කරයි. පිළිගත් පිළිතුර පිළිබඳ පළමු අදහස බලන්න.
බොම්බේ

2
එය ඇත්ත වශයෙන්ම නම් කරන ලද බ්ලොක් එකක් නොවේ, ලේබලය පසු ඔබට ඕනෑම ජාවා ප්‍රකාශනයක් ලේබලය නොමැතිව ලිවිය හැකිය, name: if(...){...}නම් කළ කොන්දේසියක් තිබේද? :)
La VloZ Merrill

4
මෙම ඉදිකිරීම forකෙලින්ම ලේබල් කිරීමට වඩා විශාල වාසියක් ඇත . අවසන් වරට }ක්‍රියාත්මක කිරීමට පෙර ඔබට කේතයක් එක් කළ හැක්කේ කොන්දේසිය කිසි විටෙකත් සපුරා නොමැති නම් පමණි.
ෆ්ලෝරියන් එෆ්

2
එය නම් කරන ලද බ්ලොක් එකක් මිස නම් කරන ලද ලූපයක් නොවේ. ඔබට එම ලූපය තුළ "සෙවීම දිගටම කරගෙන යාමට" නොහැකි විය. ලූපය සෙවීම ලෙස නම් කර ඇත්නම් එය සම්පූර්ණයෙන්ම නීතිමය වාක්‍ය ඛණ්ඩයකි. ඔබට එය බිඳ දැමිය හැකිය, නමුත් ඔබට එය දිගටම කරගෙන යා නොහැක.
ටැටරීස් කරන්න

133

මම කිසි විටෙක ලේබල භාවිතා නොකරමි. එයට ඇතුල් වීම නරක පුරුද්දක් සේ පෙනේ. මෙන්න මම කරන්නෙ:

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ඇයි?
ගන්ඩල්ෆ්

5
මම භාවිතා breakකරන්නේ අත්තනෝමතික ලෙස ලූපයෙන් පිටවීමටයි. එම වාරණයෙන් පසුව කේතයක් තිබේ නම් if, breakඑය ක්‍රියාත්මක කිරීමට පෙර ඔබට එය කළ හැකිය . නමුත් ඔබ හරි &&. එය සවි කර ඇත.
එලී මුන්ඩි

2
හොඳ විසඳුමක්! කිසියම් හේතුවක් නිසා එය අතිරේක ශ්‍රිතයකට දැමීම වඩා සුදුසු නොවේ නම් මම එය ප්‍රායෝගිකව කරන්නේ එයයි.
බෙන්රෝත්

6
අභ්‍යන්තර පුඩුවට පසුව යම් තර්කනයක් තිබේ නම් විභව ගැටළුවක් පවතී ... එය දිගටම ක්‍රියාත්මක වන අතර පිටත පුඩුවක් කැඩී යන්නේ නව ක්‍රියාකාරීත්වය ආරම්භ වූ විට පමණි ...
කාර්තික් කරුප්පන්නන්

7
යමෙක් එසේ කළ යුත්තේ මන්දැයි මට තේරෙන්නේ නැත. කේතය සමඟ වැඩ කරන පුද්ගලයින්ට භාෂාවක සියලුම අංග භාවිතා කළ හැකිය. අනෙක් අයට තේරුම් ගත හැකි කේත ලිවීම වැදගත් බව මට වැටහී ඇත, නමුත් භාෂාවක් මගින් සපයනු ලබන නිල මෙවලම් භාවිතය සීමා කිරීමෙන් සහ එකම ක්‍රියාකාරීත්වය සඳහා විසඳුම් සොයා ගැනීමෙන් නොවේ. නැතහොත් “නරක පුරුදු” මගින් ඔබ වෙනත් දෙයක් අදහස් කළාද?
codepleb

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
අතිරේක තත්වයක් සෑම අවස්ථාවකදීම ලූපය හරහා පරීක්ෂා කළ යුතුද? නැ ස්තුතියි.
ryandenki

15

ඔබ breaks සහ gotos වලට අකමැති නම් , අතිරේක ගබ්සා කිරීමේ කොන්දේසියක් සහිතව, for-in වෙනුවට "සාම්ප්‍රදායික" ලූපයක් භාවිතා කළ හැකිය:

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
@ ජෝන් එම් සී ක්ලේන් අවුරුදු 9+ කට වඩා පැරණි ප්‍රශ්නයකට ඔබ මෙය බොහෝ පිළිතුරු මත අයාචිත තැපැල් කරන්නේ ...?
Quintec

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 හැසිරවීම සමඟ කොටස ලැබුණේ නැත. නමුත් ප්‍රමාණයෙන් නියෝජනය වන්නේ ඒ ආකාරයේ නරක විලාසිතාවක් බව මට පෙනේ. එවිට මම පැහැදිලි වර්ඩ්ස් සහිත ddyer වෙතින් පිළිතුරට කැමතියි: stackoverflow.com/a/25124317/15108
boutta

outboutta ඔබට sවඩා අඩු iහෝ iවඩා වැඩි හෝ සමාන අගයකට වෙනස් කළ හැකිය s, දෙදෙනාම කළ යුත්තේ උපක්‍රමයයි. වෙනස් කිරීම ගැන ඔබ නිවැරදියි s, මන්ද එය පසුව වෙනත් තැනක භාවිතා කළ හැකි නමුත් වෙනස් කිරීම iහානියක් නොවනු ඇත, පළමුවැන්න forදිගින් දිගටම ලූප නොකිරීමට වග බලා ගනී .
සොල්ටි

9

ලූප් පරීක්ෂණ සඳහා පැහැදිලි "පිටවීමක්" එක් කිරීමට මම කැමැත්තෙමි. ඕනෑම අනියම් පා er කයෙකුට එය පැහැදිලි කරයි, ලූපය කලින් අවසන් විය හැකි බව.

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
V 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

කිසිදු ලේබලයක් භාවිතා නොකර ඔබට සියලු ලූප වලින් බිඳී යා හැකිය: සහ කොඩි.

එය හුදෙක් උපක්‍රමශීලී විසඳුමකි.

මෙහි condition1 යනු K සහ J ලූප වලින් කැඩීමට භාවිතා කරන කොන්දේසිය වන අතර condition2 යනු K, J සහ I පුඩුවෙන් කැඩීමට භාවිතා කරන කොන්දේසියයි.

උදාහරණයක් වශයෙන්:

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;
         }
    }
}

මම මේ රටාවට කැමතියි. එය බොහෝ විට මට ලූප වෙනම ශ්‍රිතයක් බවට පත් කිරීමට හේතු වී තිබේ. එසේ කිරීමෙන් පසු මගේ කේතය සෑම විටම වඩා හොඳය, එබැවින් මෙම හේතුව නිසා මම මෙම පිළිතුරට ඇත්තෙන්ම කැමතියි.
බිල් කේ

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
බිඳීම පිළිබඳ මෙම උදාහරණ ඉතා ප්‍රයෝජනවත් නොවේ, මන්ද ලේබලය නොමැතිව වුවද ඒවා එකම වේලාවක කැඩී යනු ඇත. අභ්‍යන්තර ලූපයට කිසි විටෙකත් ළඟා විය නොහැකි බැවින් ඔබට සැබවින්ම ක්‍රියාත්මක කළ හැකි කේතයක් තිබීම සැමවිටම සතුටක් ..
නියුරෝන්

මම එකම දේ ටයිප් කරන්නයි ගියේ. මෙම අවස්ථාවේදී ලේබල තරමක් නිෂ් less ල ය.
තස්ලිම් ඔසේනි

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 . එය කාර්යය ඉටු කරනු ඇත, නමුත් එය ඉතා නරක ක්‍රමලේඛ පුහුණුවකි ...
vefthym

ඇත්ත වශයෙන්ම. කෙසේ වෙතත්, මම එවැනි උරුම කේතය දුටුවෙමි - බිඳෙන කොන්දේසි කිහිපයක් සහිත 4-මට්ටම් කැදැලි වළළු. එය පේළිගත කේතයට වඩා ව්‍යතිරේකයන් සමඟ කියවිය හැකි විය. -23 ඡන්ද බොහෝ දුරට චිත්තවේගීය ඇගයීමකි, නමුත් ඔව් - මෙම ප්‍රවේශය ප්‍රවේශමෙන් භාවිතා කළ යුතුය.
ursa

1
එය කේන්ද්‍රීය ප්‍රතිලාභයක් සහිත වෙනම ශ්‍රිත ඇමතුමකට වෙන් කර ඇත්නම් එය ඊටත් වඩා කියවිය හැකිව තිබුණි. බොහෝ විට කුඩා ප්‍රතික්‍රියාකාරකයක් මඟින් වඩාත් හොඳ කර ඇති අතර එමඟින් එය තනිවම (බොහෝ විට නැවත භාවිතා කළ හැකි) ශ්‍රිතයක් ලෙස අර්ථවත් කරයි.
බිල් කේ

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

00 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

එය නව ක්‍රියාත්මක කිරීමක් නම්, ඔබට තර්කනය-else_if-else ප්‍රකාශ ලෙස නැවත ලිවීමට උත්සාහ කළ හැකිය.

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

සඳහා Demo 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මෙහි ලූප effectively ලදායී ලෙස භාවිතා කළ හැකිය .

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ඔබ සැකසූ පසු ධජයක් ලෙස භාවිතා කරන්න . එවිට අභ්‍යන්තර ලූපය දිගටම පවතින්නේ කොන්දේසිය සපුරා නොමැති අතර පමණි. කෙසේ හෝ පිටත ලූපය චග්ජින් දිගටම පවතිනු ඇත.

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.