# Unterschied zwischen break und continue in einer Schleife



## kossy (19. Feb 2012)

Hallo zusammen !

Ich wollte mal nachfragen, ob zwischen den Schlüsselwörtern break und continues innerhalb einer beliebigen Schleife eigentlich ei signifikanter Unterschied besteht?

ich habe da eben mal innerhalb einer For- und While Schleife getestet und keinen festgestellt. Ich wollte mich aber trotzdem nochmals vergewissern?

Grüße
Kossy


----------



## pl4gu33 (19. Feb 2012)

Break unterbricht die Schleife

Contine nur den Durchlauf


```
public static void main(String[] args) {
		// TODO Auto-generated method stub
		 for(int i=0;i<10;i++){
			 if(i==2){
				 continue;
			 }
			 if(i==5){
				 break;
			 }
			 System.out.println(i);
		 }
		
	}
```

hier dazu die Ausgabe:

0
1
3
4

man sieht, dass nach einem Continue alls normal weiter läuft ... bei 5 dann abgebrochen wird


----------



## bygones (19. Feb 2012)

beides sachen die man meiner Ansicht nach nicht braucht und nicht nutzen sollte.

break ist ein return in einer ausgelagerten methoden und bei continue invertiert man die if bedingung und laesst den code dann dort laufen.


----------



## pl4gu33 (19. Feb 2012)

bygones hat gesagt.:


> beides sachen die man meiner Ansicht nach nicht braucht und nicht nutzen sollte.
> 
> break ist ein return in einer ausgelagerten methoden und bei continue invertiert man die if bedingung und laesst den code dann dort laufen.



mm ich weiß nicht ich finde es kann schon sinnvoll sein .... 

wenn man z.b. zwei schleifen hat und zwei sachen von 2 Schleifen vergleichen will....

schleife 1{
    schleife2{
         if(suche irgendwas)
            ... tue dann was
            break;


und dann wird wieder gesucht in der nächsten Schleife2 sowas kann schon sinnvoll sein finde ich 

ich hoffe ich hab das jetzt einigermaßen erklärt, was ich damit meine... daher wollte ich jetzt nur mal wissen, warum das schlecht sein soll/würde 

klar könnte man das auch anders lösen ... aber ist ja z.b. eine Möglichkeit


----------



## faetzminator (19. Feb 2012)

pl4gu33 hat gesagt.:


> klar könnte man das auch anders lösen ... aber ist ja z.b. eine Möglichkeit



Eben, auslagern 

Statt 
	
	
	
	





```
Element foundElement = null;
for (Element element : elements) {
    if (element.getId() == someId) {
        foundElement = element;
        break;
    }
}
```
kann man es einfach in eine Methode auslagern:

```
public Element findElement(int someId) {
    for (Element element : elements) {
        if (element.getId() == someId) {
            return element;
        }
    }
    return null;
}
```


----------



## pl4gu33 (19. Feb 2012)

okay, bei einer Schleife is das ja klar 

Mein Beispiel bezog sich eher darauf, dass man z.b. 2 Container hat und nur etwas bestimmtes ändern will. 

doofes Beispiel: 
sagen wir 2 Arrays mit Zahlen.... 

jeweils die erste Zahl die gleich ist wie im ArrayList1 soll geändert werden. Ist jetzt ein doofes Beispiel aber mir fällt gerade kein kleines ein 


```
ArrayList<Integer> arraylist1=new  ArrayList<Integer>();
		 ArrayList<Integer> arraylist2=new  ArrayList<Integer>();
		
		 for(int i=0;i<arraylist1.size();i++){
			 for(int y=0;y<arraylist1.size();y++){
				 if(i==y){
					 y=4;
					 break;
				 }
			 }
		 }
```


----------



## faetzminator (19. Feb 2012)

Wir sprechen von Schleifen:


kossy hat gesagt.:


> Ich wollte mal nachfragen, ob zwischen den Schlüsselwörtern break und continues innerhalb einer beliebigen Schleife eigentlich ei signifikanter Unterschied besteht?


Und dein Code kann auch problemlos so geschrieben werden, auch wenn der Sinn dahinter nicht gerade ersichtlich ist 

```
public static void printNumbers() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            return;
        }
        if (i != 2) {
            System.out.println(i);
        }
    }
}
```


----------



## pl4gu33 (19. Feb 2012)

faetzminator hat gesagt.:


> Wir sprechen von Schleifen:
> 
> Und dein Code kann auch problemlos so geschrieben werden, auch wenn der Sinn dahinter nicht gerade ersichtlich ist
> 
> ...



jaa klar, verstehe schon dass das so geht  
das war ja auch nur ein Beispiel, dass Break und Continue nicht das Gleiche machen  

aber es geht mir eher darum, warum man es nicht anwenden soll, wenn es so klappt ich mein für irgendwas muss es ja da sein )

mir ist schon klar, dass es alles auch anders geht  

ps. ich habe oben noch ein anderes Bsp gemacht


----------



## bygones (19. Feb 2012)

gebs auf - jedes deiner bsp laesst sich einfacher und uebersichtlicher in einer ausgelagerten Methode ausdruecken ;-)


----------



## bERt0r (19. Feb 2012)

Also beim continue geb ich dir recht, aber ob man jetzt ein break macht oder das mit einem return löst ist dann auch schon egal. Das kommt nämlich aufs gleiche raus und ist beides gegen Djikstras Vorgaben für eine strukturierte Programmierung (D-Diagramme, Strukturierte Programmierung ? Wikipedia).
Wobei ich aber noch dazusagen muss, dass besonders ein break bei so kurzem Code sehr viel übersichtlicher, eleganter und effizienter ist, als das ganze über zusätzliche Abfrage zu lösen.


----------



## faetzminator (19. Feb 2012)

... mal ganz abgesehen davon, dass dieser Code überhaupt nicht nach deiner Beschreibung arbeitet 



pl4gu33 hat gesagt.:


> jeweils die erste Zahl die gleich ist wie im ArrayList1 soll geändert werden. Ist jetzt ein doofes Beispiel aber mir fällt gerade kein kleines ein


Öhm, aber das würde ich eher so lösen:


```
public static int replaceFirstFound(List<Integer> list1, List<Integer> list2) {
    Set<Integer> set = new HashSet<Integer>(list1);
    for (int i = 0; i < list2.size(); i++) {
        if (set.contains(list2.get(i))) {
            list2.set(i, 4);
            return i;
        }
    }
    return -1;
}
```

Natürlich kann der Rückgabetyp auch [c]void[/c] sein, je nach dem ob man den Index braucht oder nicht.


----------



## pl4gu33 (19. Feb 2012)

faetzminator hat gesagt.:


> ... mal ganz abgesehen davon, dass dieser Code überhaupt nicht nach deiner Beschreibung arbeitet



joa schon  habe ich gerade nur  runtergetippt zwischen TV und ICQ  aber ich denke ihr wisst was damit gemeint ist. Sry wenn der Code gerade Schrott war^^ 

und klar verstehe ich auch eure Lösungsansätze und das auslagern .... aber ihr stellt es so dar, als ob es falsch wäre, so habe ich den Eindruck, aber es ist ja nur ein anderer Weg ... ich will hier keinem auf den Schlips treten ... ich lerne gern dazu  aber ich meine falsch wäre Break und Continue ja nicht ... klar kommt es auf den Codeumfang und ich verstehe auch, dass eine Auslagerung in vielen Fällen auch sinnvoll ist


----------



## HimBromBeere (19. Feb 2012)

Ich versuche, diese Diskussion mal wieder zum Wesentlichen, nämlich zum Unterschied zwischen break und continue, zurückzuführen. Wie Pl4gu33 ja bereits erwähnt hat, brichst du mit break komplett aus einer Schleife aus (endgültig), wohingegen bei continue nur der aktuelle Durchlauf (mit dem aktuellen Element) abgebrochen und mit dem nächsten fortgefahren wird. D.h. du bleibst innerhalb dieser Schleife, jedoch werden die Anweisungen hinter continue für den aktuellen Druchlauf nicht mehr ausgeführt, oder noch einfacher: mit continue springst du zum Kopf der Schleife (bzw. zum Fuß bei do-while-Konstrukten).


----------



## truesoul (20. Feb 2012)

Hallo.

Also ich bin auch für das Auslagern in Methoden anstatt breaks zu verwenden aber es gibt noch eine Art diese zu verwenden. 


```
int index = 5;
		z: for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 10; j++) {
				if (index == j) {
					System.out.println("Ersten beiden Schleifen: " + index);
					index += 4;
					break z;
				}
			}
			System.out.println("Nach der Inneren Schleife ( Ersten beiden Schleifen )");
		}
		System.out.println("---------------------");
		index = 5;

		y: for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 10; j++) {
				if (index == j) {
					System.out.println("Letzten beiden Schleifen: " + index);
					index += 4;
					continue y;
				}
			}
			System.out.println("Nach der Inneren Schleife ( Letzten beiden Schleifen ) ");
		}
```

Also für den fall das man zwei ineinander verschachtelte Schleifen hat, und das 
	
	
	
	





```
break;
```
 wäre in der innere Schleife, würde man auch nur die Innere abbrechen aber mit 
	
	
	
	





```
break z;
```
 ( Siehe Code ) kann man auch veranlassen das beide abgebrochen werden. Und das zweite Beispiel soll nur verdeutlichen das ein 
	
	
	
	





```
continue y;
```
 zur äußere Schleife springt und nicht raus wie bei break z;.

Wenn man diese nicht in Methoden auslagern möchte kann man auch einfach dafür sorgen, das die Bedingung der Schleifen nicht mehr 
	
	
	
	





```
true
```
 ergibt


----------



## bERt0r (20. Feb 2012)

Und da sind wir wieder beim Thema GOTO und wieso man sowas grundsätztlich nicht machen sollte. Also weder breaks, continues oder methoden die mittendrin was returnen.


----------

