Kan iemand mij het verschil vertellen tussen breaken continuestatements?
Antwoord 1, autoriteit 100%
breaklaat een lus achter, continuespringt naar de volgende iteratie.
Antwoord 2, autoriteit 19%
Zie Vertakkingsverklaringenvoor meer details en codevoorbeelden:
break
De break-instructie heeft twee vormen: gelabeld en ongelabeld. Je zag de
ongelabelde vorm in de vorige bespreking van de switch-instructie. Jij
kan ook een niet-gelabelde pauze gebruiken om een for, while of do-while te beëindigen
lus […]Een niet-gelabelde break-instructie beëindigt de binnenste schakeloptie, voor,
while, of do-while statement, maar een gelabelde break beëindigt een outer
verklaring.
continue
Het continue statement slaat de huidige iteratie van een for over, while ,
of doe-terwijl-lus. Het niet-gelabelde formulier springt naar het einde van de binnenste
loop’s body en evalueert de booleaanse expressie die de . bestuurt
lus. […]Een gelabelde continue instructie slaat de huidige iteratie van een buitenste lus die is gemarkeerd met het gegeven label over.
Antwoord 3, autoriteit 13%
System.out.println ("starting loop:");
for (int n = 0; n < 7; ++n)
{
System.out.println ("in loop: " + n);
if (n == 2) {
continue;
}
System.out.println (" survived first guard");
if (n == 4) {
break;
}
System.out.println (" survived second guard");
// continue at head of loop
}
// break out of loop
System.out.println ("end of loop or exit via break");
Dit leidt tot de volgende uitvoer:
starting loop:
in loop: 0
survived first guard
survived second guard
in loop: 1
survived first guard
survived second guard
in loop: 2
in loop: 3
survived first guard
survived second guard
in loop: 4
survived first guard
end of loop or exit via break
Je kunt een blok labelen, niet alleen een for-loop, en vervolgens breken/doorgaan van een genest blok naar een buitenste blok. In enkele gevallen kan dit nuttig zijn, maar in het algemeen zult u proberen dergelijke code te vermijden, behalve dat de logica van het programma veel beter te begrijpen is dan in het volgende voorbeeld:
first:
for (int i = 0; i < 4; ++i)
{
second:
for (int j = 0; j < 4; ++j)
{
third:
for (int k = 0; k < 4; ++k)
{
System.out.println ("inner start: i+j+k " + (i + j + k));
if (i + j + k == 5)
continue third;
if (i + j + k == 7)
continue second;
if (i + j + k == 8)
break second;
if (i + j + k == 9)
break first;
System.out.println ("inner stop: i+j+k " + (i + j + k));
}
}
}
Omdat het mogelijk is, betekent dit niet dat je het moet gebruiken.
Als je je code op een grappige manier wilt verdoezelen, kies je geen gemene naam, maar http: en volg je het met een opmerking, die er vreemd uitziet, zoals een webadres in de broncode:
http://stackoverflow.com/questions/462373
for (int i = 0; i < 4; ++i)
{
if (i == 2)
break http;
Ik denk dat dit uit een quiz van Joshua Bloch komt. 🙂
Antwoord 4, autoriteit 6%
Break verlaat de lus volledig en voert de instructies na de lus uit.
Terwijl Continue de huidige iteratie verlaat en wordt uitgevoerd met de volgende waarde in de lus.
Deze code legt alles uit:
public static void main(String[] args) {
for(int i=0;i<10;i++)
{
if (i==4)
{
break;
}
System.out.print(i+"\t");
}
System.out.println();
for(int i=0;i<10;i++)
{
if (i==4)
{
continue;
}
System.out.print(i+"\t");
}
}
Uitvoer:
0 1 2 3
0 1 2 3 5 6 7 8 9
Antwoord 5, autoriteit 5%
breakverlaat de lus volledig. continueslaat de instructies na de continue-instructie over en blijft herhalen.
Antwoord 6, autoriteit 2%
Breakverklaring
Soms is het nodig om een lus te verlatenvoordat de lus volledig is afgelopen itereren over alle stapwaarden. U kunt bijvoorbeeld een lijst met getallen doorlopen totdat u een getal vindt dat aan een bepaalde voorwaarde voldoet. Of een reeks tekens uit een bestand doorlopen totdat een bepaald teken is gelezen.
In het volgende voorbeeld gebruiken we een eenvoudige for-lus om waarden van 0 tot 9 af te drukken:
for(int i=0; i<10; i++) {
System.out.println(i);
}
Uitvoer:
0
1
2
3
4
5
6
7
8
9
Als we nu een break-statement toevoegen wanneer i==4, zal onze code uit de lus breken zodra i gelijk is aan 4. Je kunt het break-statement gebruiken om uit for-lussen te breken, while-lussen en do-while-lussen. De break-instructie zal alleen uit de huidige lus breken. Om uit een buitenste lus te breken vanuit een geneste binnenste lus, moet u labels gebruiken met de break-instructie.
for(int i=0; i<10; i++) {
System.out.println(i);
if(i==4) {
break;
}
}
Uitvoer:
0
1
2
3
4
Vervolgverklaring
Java’s continue statementslaat de huidige iteratie van een lus over en gaat direct naar de volgende iteratie. Na het aanroepen van de continue-instructie in een for-lus, voert de lusuitvoering de stapwaarde uit en evalueert de booleaanse voorwaarde voordat verder wordt gegaan met de volgende iteratie. In het volgende voorbeeld drukken we alle waarden van 0 tot 9 in een lus af, maar we slaan het afdrukken van 4 over.
for(int i=0; i<10; i++) {
if(i==4) {
continue;
}
System.out.println(i);
}
Uitvoer:
0
1
2
3
5 <---- SKIPPED OVER 4 and continued with next loop iteration
6
7
8
9
Labellabel – Break-statement
U kunt labels binnen geneste lussengebruiken door op te geven waar u wilt dat de uitvoering wordt voortgezet nadat het is uitgebroken van een binnenlus. Normaal gesproken breekt de break-instructie alleen uit de binnenste lus, dus als u uit een buitenste lus wilt breken, kunt u labels gebruiken om dit te bereiken, in wezen iets dat lijkt op een goto-instructie.
Het volgende voorbeeld gebruikt 3 lussen, allemaal in elkaar genest. Aangezien er geen manier is om de buitenste lus volledig te doorbreken vanuit de binnenste lus, kunnen we het label outer1 gebruiken om dit te bereiken en het label naast het break-statement te specificeren.
outer1:
for(int i=0; i<5; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<2; k++) {
System.out.println("[" + i + "][" + j + "][" + k + "]");
if(j == 3) {
break outer1;
}
}
}
}
Uitvoer:
[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0]
Zie hoe de laatste regel die wordt weergegeven 0[0] is, waar j == 3 en daar hebben we break outer1; aangeroepen om uit de buitenste lus te breken.
Lussenlabels – Verklaring doorgaan
U kunt ook labels gebruiken met het sleutelwoord doorgaan om door te gaan met herhalen vanaf een specifiek punt. Door het vorige voorbeeld te nemen en slechts één regel te wijzigen om continue outer1;op te geven in plaats van break outer1;zal de lus doorgaan met herhalen vanaf de outer1label in plaats van uit de lus te breken. Merk op hoe elke keer dat continue outer1;wordt aangeroepen, de code verdergaat vanaf de buitenste lus nadat de lusindex i met 1 is verhoogd.
outer1:
for(int i=0; i<5; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<2; k++) {
System.out.println("[" + i + "][" + j + "][" + k + "]");
if(j == 3) {
continue outer1;
}
}
}
[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[1][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[1][0][1]
[1][1][0]
[1][1][1]
[1][2][0]
[1][2][1]
[1][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[2][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[2][0][1]
[2][1][0]
[2][1][1]
[2][2][0]
[2][2][1]
[2][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[3][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[3][0][1]
[3][1][0]
[3][1][1]
[3][2][0]
[3][2][1]
[3][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[4][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[4][0][1]
[4][1][0]
[4][1][1]
[4][2][0]
[4][2][1]
[4][3][0]
Bron: Loops in Java Ultieme gids
Antwoord 7
Een break-instructie resulteert in de beëindiging van de instructie waarop deze van toepassing is (switch, for, do, of while).
Een continue-instructie wordt gebruikt om de huidige lus-iteratie te beëindigen en de controle terug te geven aan de lus-instructie.
Antwoord 8
Uitstekend antwoordeenvoudig en nauwkeurig.
Ik zou een codevoorbeeld toevoegen.
C:\oreyes\samples\java\breakcontinue>type BreakContinue.java
class BreakContinue {
public static void main( String [] args ) {
for( int i = 0 ; i < 10 ; i++ ) {
if( i % 2 == 0) { // if pair, will jump
continue; // don't go to "System.out.print" below.
}
System.out.println("The number is " + i );
if( i == 7 ) {
break; // will end the execution, 8,9 wont be processed
}
}
}
}
C:\oreyes\samples\java\breakcontinue>java BreakContinue
The number is 1
The number is 3
The number is 5
The number is 7
Antwoord 9
continueslaat de huidige loopover en MOVES TOde volgende loopterwijl breakMOVES OUTvan de lusen voert de volgende instructie nade lus uit.
Ik heb het verschil geleerd met behulp van de volgende code. Bekijk de verschillende uitgangen. Ik hoop dat dit helpt.
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
if (i == 3) {
continue;
}
System.out.print(i);
}
}//prints out 0124, continue moves to the next iteration skipping printing 3
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
if (i == 3) {
break;
}
System.out.print(i);
}
}//prints out 012, break moves out of the loop hence doesnt print 3 and 4
Antwoord 10
Denk aan het volgende:
int n;
for(n = 0; n < 10; ++n) {
break;
}
System.out.println(n);
breakzorgt ervoor dat de lus wordt beëindigd en de waarde van nis 0.
int n;
for(n = 0; n < 10; ++n) {
continue;
}
System.out.println(n);
continuezorgt ervoor dat de programmateller terugkeert naar de eerste regel van de lus (de voorwaarde is gecontroleerd en de waarde van n is increment) en de uiteindelijke waarde van nis 10.
Er moet ook worden opgemerkt dat breakalleen de uitvoering van de lus beëindigt waarin het zich bevindt:
int m;
for(m = 0; m < 5; ++m)
{
int n;
for(n = 0; n < 5; ++n) {
break;
}
System.out.println(n);
}
System.out.println(m);
Zal iets uitvoeren met het effect van
0
0
0
0
0
5
Antwoord 11
De break-instructie breekt uit de lus (de volgende uit te voeren instructie is de eerste na de afsluitende accolade), terwijl continuede lus opnieuw begint bij de volgende iteratie.
Antwoord 12
De break-instructie bestaat uit de huidige looping-besturingsstructuur en springt erachter terwijl de continueook wordt afgesloten, maar terugspringt naar de looping-voorwaarde.
Antwoord 13
Eenvoudig voorbeeld:
breakverlaat de lus.
int m = 0;
for(int n = 0; n < 5; ++n){
if(n == 2){
break;
}
m++;
}
System.out.printl("m:"+m); // m:2
continuegaat terug naar de startlus.
int m = 0;
for(int n = 0; n < 5; ++n){
if(n == 2){
continue; // Go back to start and dont execute m++
}
m++;
}
System.out.printl("m:"+m); // m:4
Antwoord 14
Om te voorkomen dat iets wordt uitgevoerd als aan een voorwaarde wordt voldaan, moet je de continue gebruiken en om uit de lus te komen als aan een voorwaarde wordt voldaan, moet je de break gebruiken.
Bijvoorbeeld in de onderstaande code.
for(int i=0;i<5;i++){
if(i==3){
continue;
}
System.out.println(i);
}
De bovenstaande code drukt het resultaat af: 0 1 2 4
Overweeg NU deze code
for(int i=0;i<5;i++){
if(i==3){
break;
}
System.out.println(i);
}
Deze code wordt 0 1 2 afgedrukt
Dat is het fundamentele verschil in doorgaan en breken.
Antwoord 15
hier is de semantiek van pauze:
int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// find 9
for(int i = 0; i < a.Length; i++)
{
if (a[i] == 9)
goto goBreak;
Console.WriteLine(a[i].ToString());
}
goBreak:;
hier is de semantiek van doorgaan:
int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// skip all odds
for(int i = 0; i < a.Length; i++)
{
if (a[i] % 2 == 1)
goto goContinue;
Console.WriteLine(a[i].ToString());
goContinue:;
}
Antwoord 16
Ten eerste denk ik dat je moet weten dat er twee soorten pauzes en doorgaan in Java zijn, genaamd break, unlabeled break, label continue en unlabel continue. Nu zal ik het hebben over het verschil tussen beide.
class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts =
{ 32, 87, 3, 589,
12, 1076, 2000,
8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;//this is an unlabeled break,an unlabeled break statement terminates the innermost switch,for,while,do-while statement.
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " + i);
} else {
System.out.println(searchfor + " not in the array");
}
}
Een niet-gelabelde break-instructie beëindigt de binnenste schakeloptie ,for,while,do-while-instructie.
public class BreakWithLabelDemo {
public static void main(String[] args) {
search:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println(i + " - " + j);
if (j == 3)
break search;//this is an labeled break.To notice the lab which is search.
}
}
}
Een gelabelde pauze beëindigt een buitenste instructie. Als u javac en java deze demo gebruikt, krijgt u:
0 - 0
0 - 1
0 - 2
0 - 3
class ContinueDemo {
public static void main(String[] args) {
String searchMe = "peter piper picked a " + "peck of pickled peppers";
int max = searchMe.length();
int numPs = 0;
for (int i = 0; i < max; i++) {
// interested only in p's
if (searchMe.charAt(i) != 'p')
continue;//this is an unlabeled continue.
// process p's
numPs++;
}
System.out.println("Found " + numPs + " p's in the string.");
}
Een niet-gelabelde continue-instructie slaat de huidige iteratie van een for,while,do-while-instructie over.
public class ContinueWithLabelDemo {
public static void main(String[] args) {
search:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println(i + " - " + j);
if (j == 3)
continue search;//this is an labeled continue.Notice the lab which is search
}
}
}
Een gelabelde continue instructie slaat de huidige iteratie van een buitenste lus over die is gemarkeerd met het gegeven label, als u javac en java de demo geeft, krijgt u:
0 - 0
0 - 1
0 - 2
0 - 3
1 - 0
1 - 1
1 - 2
1 - 3
2 - 0
2 - 1
2 - 2
2 - 3
Als je vragen hebt, kun je de Java-tutorial hiervan bekijken:voer hier de linkbeschrijving in
Antwoord 17
Simpel gezegd: break beëindigt de huidige lus en gaat door met de uitvoering op de eerste regel nadat de lus is afgelopen. continue springt terug naar de lusconditie en blijft de lus uitvoeren.
Antwoord 18
for (int i = 1; i <= 3; i++) {
if (i == 2) {
continue;
}
System.out.print("[i:" + i + "]");
probeer deze code in netbeans, dan begrijp je het verschil tussen pauze en doorgaan
for (int i = 1; i <= 3; i++) {
if (i == 2) {
break;
}
System.out.print("[i:" + i + "]");
Antwoord 19
Eenvoudig programma om het verschil tussen doorgaan en pauze te begrijpen
Als continuewordt gebruikt
public static void main(String[] args) {
System.out.println("HelloWorld");
for (int i = 0; i < 5; i++){
System.out.println("Start For loop i = " + i);
if(i==2){
System.out.println("Inside if Statement for i = "+i);
continue;
}
System.out.println("End For loop i = " + i);
}
System.out.println("Completely out of For loop");
}
OutPut:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Start For loop i = 3
End For loop i = 3
Start For loop i = 4
End For loop i = 4
Completely out of For loop
Wanneer breakwordt gebruikt
public static void main(String[] args) {
System.out.println("HelloWorld");
for (int i = 0; i < 5; i++){
System.out.println("Start For loop i = " + i);
if(i==2){
System.out.println("Inside if Statement for i = "+i);
break;
}
System.out.println("End For loop i = " + i);
}
System.out.println("Completely out of For loop");
}
Output:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Completely out of For loop
Antwoord 20
Vervolg Verklaring stop de itratie en start de volgende ittratie
Bijv.:
System.out.println("continue when i is 2:");
for (int i = 1; i <= 3; i++) {
if (i == 2) {
System.out.print("[continue]");
continue;
}
System.out.print("[i:" + i + "]");
}
en Break Statment stopt de lus of verlaat de lus
Antwoord 21
je zit dus in een for- of while-lus. Pauze gebruiken; zal je buiten de lus plaatsen. Zoals in, het zal eindigen. Doorgaan met; zal het vertellen om de volgende iteratie uit te voeren.
Het heeft geen zin om continue in if-statement te gebruiken, maar break; is nuttig.
Gebruik in switch…geval altijd break; om een zaak te beëindigen, zodat er geen andere zaak wordt uitgevoerd.