# Array reverse



## Alibistudent (13. Mrz 2011)

Hallo alle zusammen,
ich habe in dem Fach Einführung in die Programmierung Hausaufgaben aufbekommen
und versuche sie gerade zu lösen. Sie lautet:

_Schreiben Sie eine Klasse ArrayOperation und implementieren Sie folgende statische Methoden:

• Eine Methode void reverse(int[] a), die die Zahlen innerhalb des Arrays tauscht (der
erste Wert wird der letzte, der letzte Wert der erste usw.).
• Eine Methode int[] replicate(int[] a, int n), die den Eingabe-Array n-mal
hintereinander anfügt.
(Bsp: replicate({1, 4, -2}, 3) erzeugt den Array {1,4,-2,1,4,-2,1,4,-2}
• Eine Methode int plateau(int[] a), die in einem Array von absteigend sortierten
ganzen Zahlen das längste Plateau berechnet und als Ergebnis zurückgibt. Der Array a soll dabei
aber nur einmal durchlaufen werden.
Hinweis: Ein Plateau ist eine Folge von gleichen Werten.
Für den Array a = {8, 8, 7, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1} soll die Methode
das Ergebnis 4 liefern.
• Eine Methode print(int[]a) zur Ausgabe eines Arrays in der Form {a0,a1,a2,…,an-1}

Erweitern Sie die Klasse um die main-Methode und testen Sie die Methoden, indem Sie verschiedene
Testarrays erzeugen und für diese die Methoden aufrufen._

Ich habe schon ein paar ideen und mein quelltext lässt sich sogar compilieren nur wenn ich es ausführen will treten Fehler auf. Ich habe die ersten drei Teilaufgaben verstanden und soweit gelöst denke ich mal nur komm ich jetzt mit dem Zusammenspiel zwischen der main-Methode und den anderen Methoden nicht klar und ich weiß nicht was ich als Rückgabewert(return) verwenden muss! Könnt ihr mir vielleicht weiterhelfen sodass ich die Aufgabe zu ende lösen kann.
Danke im voraus!

Quelltext:

```
class ArrayOperation{

	public static void main(String[] arg){
		int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
        reverse(array1);
		
		int[] array2 = {1, 4, -2};
		int n2=3;
        replicate(array2,n2);
		
		int[] array3 = {8, 8, 7, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1};
        plateau(array3);
	}
	
	public static void reverse(int[] a){
		int k = a.length;
		int i = 0;
		while(i<k){
			int h = a[i];
			a[i] = a[k-1];
			a[k-1] = h;
			i++;
			k--;
		}
		System.out.println("reverse(array1):"+a);
	}
	
	public static int[] replicate(int[] a, int n){
		int v = a.length;
		int t = v*n;
		int z = 0;
		int[] array = new int[t];
		
		while(z<=n){
			int w = 0;
			while(w<=v){
				array[t]=array[w];
				w++;
				t++;
			}
			z++;
		}
		System.out.println("replicate(array2,n2):"+array);
		return a;
	}
	
	public static int plateau(int[] a){
		int num=1;
		int i;
		for(i=1; i<=a.length; i++){
			if(a[i-1]==a[i]){
				num++;
			}
			else{
				num=1;
			}
		}
		System.out.println("laengste Plateau"+num);
		return num;
	}
	
/*	public static print(int[]a){
		
	}*/
	
}
```


----------



## nrg (13. Mrz 2011)

hier vllt kleine Anregungen:


```
public class ArrayOperation {

	public static void main(String[] arg) {
		int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
		System.out.println(arrayToString(reverse(array1)));

		int[] array2 = {1, 4, -2};
		System.out.println(arrayToString(replicate(array2, 3)));

		int[] array3 = {8, 8, 7, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1};
		System.out.println(arrayToString(array3) + " laengstes Plateau = " + plateau(array3));
	}

	// hätte ich weng anders gemacht aber funktioniert so doch ganz gut :)
	public static int[] reverse(int[] a) {
		int k = a.length;
		int i = 0;
		while(i<k){
			int h = a[i];
			a[i] = a[k-1];
			a[k-1] = h;
			i++;
			k--;
		}
		return a;
	}

	// hier eine kleine Anregung
	public static int[] replicate(int[] a, int n) {
		int[] rep = new int[a.length * n];
		int i = 0;
		while (i < rep.length) {
			for (int j : a) {
				rep[i++] = j;
			}
		}
		return rep;
	}

	public static int plateau(int[] a) {
		// Das kannste dir selbst nochmal anschauen. Alles möchte ich dir ja nicht machen.
		return 0;
	}

	// So könntest du das z.B. ausgeben
	public static String arrayToString(int[]a) {
		StringBuilder sb = new StringBuilder("Values:");
		for (int i : a)
			sb.append(" ").append(i);
		return sb.toString();
	}

}
```

edit: dein Problem ist, dass du auf Arraybereiche zugreifst, die nicht existieren > ArrayIndexOutOfBoundsException. Das sind alles Programmierfehler und  du solltest deine Schleifen/Abbruchbedingungen überprüfen. Ein Index darf niemals < 0 und auch niemals >= array.length sein


----------



## Alibistudent (14. Mrz 2011)

ich hab mich jetzt nochmal hingesetzt und hab mir nochmal die einzelnen methoden angeguckt und auch was dazugeschrieben. Manches ist noch bissl zu hoch für mich wie zum beispiel die letzte methode mit dem print aber ich werd mich hinsetzen und auch das versuchen zu lösen vllt auf meine eigene art falls ich deinen lösungsweg nicht verstehe^^ aber trotzdem danke nochmals!

```
public class ArrayOperation{
	/*ArrayToString funktioniert hier nicht hab ich auch bisher noch nicht
	verwendet fehlt da vllt noch etwas? kannst du mir es auch kurz erklären?*/
	public static void main(String[] arg){
		int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(arrayToString(reverse(array1)));
 
        int[] array2 = {1, 4, -2};
		int n2 = 3;
        System.out.println(arrayToString(replicate(array2, n2)));
 
        int[] array3 = {8, 8, 7, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1};
        System.out.println(arrayToString(array3) + " laengstes Plateau = " + plateau(array3));

	}
	/*das hier klappt ja denk ich mal wenn arraytostring funktioniert
	es wird mir ja auch so schon was ausgegeben nur sind das nur symbole*/
	public static int[] reverse(int[] a){
		int k = a.length;
		int i = 0;
		while(i<k){
			int h = a[i];
			a[i] = a[k-1];
			a[k-1] = h;
			i++;
			k--;
		}
		return a;
	}
	
	/*ich glaube das hier klappt jetzt auch was er mir was ausgibt
	nur symbole halt aber trotzdem^^ */
	public static int[] replicate(int[] a, int n){
		int[] array = new int[a.length*n];
		int i = 0;
		int j = 0;
		while(i < n){
			int k = 0;
			while(k < a.length){
				array[j]=array[k];
				k++;
				j++;
			}
			i++;
		}
		return array;
	}
	
	/*hier hab ich bisschen probleme ich dachte es klappt wenn ich
	das array einmal durchgehe und jedesmal wenn der vorgänger dem nachfolger
	ist geht er mit dem zähler hoch ich hab nur vergessen das höchste plateau zu speichern
	oder? jetzt hab ich k hinzugefügt der das höchste plateau bis zum zeitpunkt zwischenspeichert
	eigtl müsste es doch jetzt gehen*/
	public static int plateau(int[] a){
		int j=1;
		int i;
		int k=1;
		for(i=1; i<=a.length; i++){
			if(a[i-1]==a[i]){
				j++;
				if(k<j){
					k=j;
				}
			}
			else{
				j=1;
			}
		}
		return 0;
	}
}
```


----------



## Firephoenix (14. Mrz 2011)

Hi,
wer sich auch selbst hinsetzt dem wird geholfen 

Ich geh einfach mal deinen code runter:

reverse:
funktioniert, allerdings würde ich kein Array mit einer while bearbeiten.
bei der Konstruktion verwendest du besser eine for-schleife dieser art:

```
for(int i = 0; i < deinarray.length; i++)
```

Ob man an dieser Stelle einen Dreieckstausch benutzt oder sich einfach ein 2. Array
erstellt, das entsprechend füllt und dann zurückgibt ist geschmackssache.

Allerdings ist die an der Stelle ein recht böser Fehler unterlaufen den man hier gut erkennt.
Ich hab mal die arraytostring implementiert und folgenden Aufruf erzeugt:

```
int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(arrayToString(array1));
        System.out.println(arrayToString(reverse(array1)));
        System.out.println(arrayToString(array1));
```
Die Ausgabe dazu (mal abgesehen davon, dass bei mir hinten ein Komma zuviel dranhängt )


> 1,2,3,4,5,6,7,8,
> 8,7,6,5,4,3,2,1,
> 8,7,6,5,4,3,2,1,


An der Stelle: manipuliere nie in einer Funktion direkt die Aufrufparameter, außer du willst es mit Absicht machen. Beim Aufruf kopierst du nämlich nicht das Array, sondern du übergibst nur einen Zeiger auf dein Array.
wenn du reverse also dein array1 gibst ist das (int[] a) nichts anderes als eben array1.
Und das soll doch bitte so bleiben 
Eine Möglichkeit funktionen zu erstellen die irgendwas zurückgeben ist sowas:

```
public Rückgabetyp(z.b.int[]) funktionX(parameter a1, parameter a2....){
ObjektDesRückgabetyps obj1 = new ...;
<Hier wird das Objekt obj1 manipuliert>
return obj1;
}
```
am reverse-Beispiel:

```
public static int[] reverse(int[] ar){
		//Array das zurückgegeben wird (hat die gleiche länge wie das übergebene)
		int[] ret = new int[ar.length];
		//Schleife die einmal über ar läuft
		for(int i = 0; i < ar.length; i++){
			/*
			 * bsp zu der Zeile: hat ar die länge 5, dann wird beim 1. schritt (i = 0)
			 * position 0 aus ar in position (5-0-1 = 4) in ret übertragen.
			 * Dannach wird position 1 aus ar in position (5-1-1 = 3) in ret übertragen.
			 * usw, bis beim letzten Schritt (i=4) position 4 von ar in position (5-4-1 = 0) in ret übertragen wird.
			 */
			ret[ar.length-i-1] = ar[i];
		}
		//Am ende wird ret zurückgegeben
		return ret;
	}
```

Bei der replicate hast du das Schema übrigens selbst schon angewendet 
Allerdings wird noch 0,0,0,0,0,0,0,0,0, ausgegeben, was aus der Zeile hier auch recht klar wird:

```
array[j]=array[k];
```
sollte wohl eher

```
array[j]=a[k];
```
heißen 

plateau tut noch nicht ganz das was sie soll, mit der Änderung hier wirft sie aber wenigstens
keine OutOfBounds-exception mehr 

```
public static int plateau(int[] a){
        int j=1;
        int i;
        int k=1;
        for(i=0; i<a.length; i++){
            if(a[i]==a[i]){
                j++;
                if(k<j){
                    k=j;
                }
            }
            else{
                j=1;
            }
        }
        return 0;
    }
```
Der Ansatz ist aber richtig.
Bin mal gespannt wie deine nächste Version aussieht,
beste Grüße


----------



## Alibistudent (14. Mrz 2011)

das kam bei dem ganzen jetzt raus fehlt mir nur noch die letzte methode vllt
ne kleine anregung dazu was da verlangt ist?! ich komm nicht drauf was die aufgabe bringen
soll entweder es kommt a0,a1,a2 raus kann ich ja auch als system.out.print machen hahahaha
aber sonst versteh ich nicht was es bringen soll bzw. was ich machen muss falls es was bringt

```
public class ArrayOperation{
	public static void main(String[] arg){
		int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
		arrayToString(reverse(array1));
		int[] array2 = {1,4,-2};
		int n2=3;
        arrayToString(replicate(array2,n2));
		int[] array3 = {8, 8, 7, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1};
		System.out.println(plateau(array3));
	}
	/*ich hab versucht arrayToString so zu lösen ich weiß nicht
	ob ich es mir zu einfach gemacht hab oder ob man es so lassen
	könnte weil dein kollege hatte mich bisschen verwirrt...dachte
	arrayToString ist eine funktion die schon in java enthalten ist^^
	jetzt seh ich auch das er es schon implementiert hatte unten
	deswegen hat es bei mir die ganze zeit nicht funktioniert-.-
	ich dachte das gehört zu print hahahaha:D ich schlafmütze
	ok dann wird seins auch funktionieren ich gucks mir nochmal an
	wie er es gemacht hab und werd mal gucken was dabei rauskommt und
	poste es dann*/
	
	public static void arrayToString(int[] a){
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]);
		}
		System.out.println();
	}

	/*hier ist auch alles ok hab das auch verstanden das man ein zweites
	array erzeugt und einfach in umgekehrter reihenfolge die werte übergibt
	aber ich lasse das mal so hab schon sehr viel gelernt jetzt was die arrays
	betrifft und wüsste jetzt auch wie ich es anders machen könnte*/
	public static int[] reverse(int[] a){
		int k = a.length;
		int i = 0;
		while(i<k){
			int h = a[i];
			a[i] = a[k-1];
			a[k-1] = h;
			i++;
			k--;
		}
		return a;
	}
	
	/*war halt der kleine fehler drin^^*/
	public static int[] replicate(int[] a, int n){
		int[] array = new int[a.length*n];
		int i = 0;
		int j = 0;
		while(i < n){
			int k = 0;
			while(k < a.length){
				array[j]=a[k];
				k++;
				j++;
			}
			i++;
		}
		return array;
	}
	
	/*klappt jetzt auch wunderbar als return will ich ja k haben und nicht 0
	hatte das bis jetzt mit return nicht verstanden aber jetzt wird alles
	langsam klar mit den methoden und den arrays*/
	public static int plateau(int[] a){
		int j=1;
		int i;
		int k=1;
		for(i=1; i<a.length; i++){
			if(a[i-1]==a[i]){
				j++;
				if(k<j){
					k=j;
				}
			}
			else{
				j=1;
			}
		}
		return k;
	}
	
	/*das hier ist mir noch unklar was hier eigtl gefragt ist*/
	public static print(int[]a){
		
	}
	
}
```
danke im voraus seit alle ne große hilfe:toll:


----------



## Firephoenix (15. Mrz 2011)

Hi,
das sieht doch gut aus, die funktionalen Methoden liefern soweit ich das jetzt sehe richtige Ergebnisse 

um das mit dem print zu erklären:

Grundsätzlich ist erstmal alles bei Java von der Klasse Object abgeleitet (abgesehen von Spezialfällen wie Arrays oder primitive Datentypen wie int, long, boolean etc).
In der Klasse Object gibt es eine Methode toString() mit der man jedes Objekt in einen String umwandeln kann (in der Urform kriegt man damit den Klassennamen und einen Hashcode zum Objekt).
Rufst du jetzt System.out.println() mit irgend einem Objekt als Parameter auf, das nicht vordefiniert ist (int, boolean etc sind extra implementiert und klappen daher) wird im hintergrund toString des Objektes aufgerufen.
Der Sinn der eigenen print() Methode ist daher, ein Array in eine sinnvolle String-Form zu übersetzen
(nach der Aufgabenstellung in der Form [0]+","+[1]+","+[2]+...)
Dieser String kann dann auf der Konsole ausgegeben werden (System.out.println()) oder auf irgendwelchen anderen Komponenten angezeigt werden (in einer Grafikanwendung z.b. irgendwelche Textfelder die Strings ausgeben können).
Ohne diese Methode hat man keine Möglichkeit die Arrays für den Menschen lesbar zu machen.
in dem Sinne ist print eigentlich auch kein passender Methodenname, die Methode sollte eher parseIntArrayToStringRepresentation() oder irgendwie so benannt werden 
In print() machst du eigentlich nichts anderes als das Array einmal zu durchlaufen (z.B. mit einer foreach-Schleife oder einer for-schleife) und jedes Element an einen Rückgabestring zu hängen.
Das kann dann ausgegeben werden.
Eine möglichkeit würde z.B. so aussehen:

```
public static String print(int[]a){
    	String ret = new String();
		for(int x : a){
		ret += x + ",";	
		}
        return ret;
    }
```

und die main entsprechend

```
public static void main(String[] arg){
        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(print(reverse(array1)));
        int[] array2 = {1,4,-2};
        int n2=3;
        System.out.println(print(replicate(array2,n2)));
        int[] array3 = {};
        System.out.println((plateau(array3)));
    }
```


Ich hab die Methoden übrigens auch mal durchimplementiert und durchkommentiert,
inwieweit das alles so optimal ist sei mal dahingestellt, ich lerne ja selber noch 

```
/**
	 * Main-Method
	 */
	public static void main(String[] args) {
		//paar Arrays zum testen
		int[] x1 = new int[] {4,5,2,1,3,5,6,1,2,3,4,1,2,3,4};
		int[] x2 = new int[] {1,1,1,1,1,2,2,3,3,3,3,4};
		int[] x3 = new int[] {42,2,4,42,4,2};
		//testen von print
		System.out.println(parseTextRepresentation(x1));
		//testen von reverse
		System.out.println(parseTextRepresentation(reverse(x3)));
		//testen von sequence
		System.out.println((sequence(x2)));
		//testen von replicate
		System.out.println(parseTextRepresentation(replicate(x3,4)));
	}
	
	/**
	 * @return Returns the given int-Array in reversed-Element-Order
	 */
	public static int[] reverse(int[] ar){
		//Array das zurückgegeben wird (hat die gleiche länge wie das übergebene)
		int[] ret = new int[ar.length];
		//Schleife die einmal über ar läuft
		for(int i = 0; i < ar.length; i++){
			/*
			 * bsp zu der Zeile: hat ar die länge 5, dann wird beim 1. schritt (i = 0)
			 * position 0 aus ar in position (5-0-1 = 4) in ret übertragen.
			 * Dannach wird position 1 aus ar in position (5-1-1 = 3) in ret übertragen.
			 * usw, bis beim letzten Schritt (i=4) position 4 von ar in position (5-4-1 = 0) in ret übertragen wird.
			 */
			ret[ar.length-i-1] = ar[i];
		}
		//Am ende wird ret zurückgegeben
		return ret;
	}
	
	/**
	 * counts the longest sequence of following equal numbers in a sorted-int-array
	 */
	public static int sequence(int[] ar){
		//trivialfälle
		if(ar.length < 2)
			return ar.length;
		//int das zurückgegeben wird (wird zum zählen der folgen benutzt)
		int ret = 0;
		//zahl die wir als letztes gefunden haben
		int before = ar[0];
		//länge der aktuellen folge
		int actualLength = 0;
		//Einmal über das Array laufen
		for(int val : ar){
			//Wenn die aktuelle Zahl gleich der vorigen ist
			if(val == before){
				//wird die aktuelle länge um eins erhöht
				actualLength++;
			}else{
				//ansonsten ist es eine neue Zahl, wir merken sie uns
				before = val;
				//und setzen die aktuelle Länge wieder auf 1
				actualLength = 1;
			}
			//außerdem prüfen wir ob unsere aktuelle Zahlenfolge länger als
			//die letzte gefundene längste ist
			if(actualLength > ret){
				//falls ja wird sie die neue längste
				ret = actualLength;
			}
		}
		//zähler zurückgeben
		return ret;
	}
	
	/**
	 * @return a String representation of the given Array (e.g. "1,2,3,4,5")
	 */
	public static String parseTextRepresentation(int[] ar){
		//StringBuilder mit passender Puffergröße anlegen (erspart unnötiges kopieren)
		StringBuilder sb = new StringBuilder(ar.length*2);
		//einmal über das Array laufen
		for(int i = 0; i < ar.length; i++){
			//jedes int auslesen und an den sb anhängen
			sb.append(ar[i]);
			//bei allen bis auf dem letztem ein Komma anfügen
			if(i < ar.length-1){
				sb.append(",");
			}
		}
		//String aus dem StringBuilder zurückgeben
		return sb.toString();
	}
	
	/**
	 * Method which replicates an int-Array x-times and stick the replicates on the original-array
	 */
	public static int[] replicate(int[] ar,int x){
		//Array das zurückgegeben wird
		int[] ret = new int[ar.length*x];
		//x mal das array ar an ret anfügen
		int pos = 0;
		while(pos < ret.length){
			for(int val : ar){
				ret[pos++] = val;
			}
		}
		//neues Array zurückgeben
		return ret;
	}
```
Gruß


----------



## Alibistudent (15. Mrz 2011)

du hast es super erklärt und mir wird auch alles klar nur weiß ich nicht was genau in dieser for-schleife passiert von print bzw. arraytostring ich kann mir einfach nicht vorstellen wofür dieses x steht...die symbole werden in einen string übergeben und so manipuliert wahrscheinlich in der for-schleife das sie wieder zahlen ausgeben nicht mehr symbole aber warum passiert das indem ich x:a mache:rtfm:

```
public class ArrayOperation{
	public static void main(String[] arg){
		int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8};
		System.out.println(arrayToString(reverse(array1)));
		int[] array2 = {1,4,-2};
		int n2=3;
        System.out.println(arrayToString(replicate(array2,n2)));
		int[] array3 = {8, 8, 7, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1};
		System.out.println(plateau(array3));
	}
	/*achso jetzt wird mir klar das als print-methode in der aufgabenstellung
	dieses arraytostring verlangt war^^ nur versteh ich dieses arraytostring
	noch nicht ganz ich hab schon verstanden das ich wenn ich ein array erzeuge
	und dem notebook übergebe es keine zahlen mehr sind wie ich es sehe sondern
	symbole wie wenn ich dieses arraytostring z.B. nicht verwende und gleich ausgebe
	und wenn ich ein array manipuliere und dann zurückgebe besitzt dieser wert ab
	sofort den manipulierten wert*/
	public static String arrayToString(int[]a){//eigtl print() aber so merk ich es mir besser
        String array = new String();//string wird erzeugt
        for(int x : a){//was passiert in der for klammer und wofür steht das x? und was entsteht wenn ich x mit a teile?
        array = array + x + ",";//das hier versteh ich auch noch nicht ganz aber erklärt sich bestimmt wenn ich die klammer verstanden hab...
        }
        return array;
    }

	public static int[] reverse(int[] a){
		int k = a.length;
		int i = 0;
		while(i<k){
			int h = a[i];
			a[i] = a[k-1];
			a[k-1] = h;
			i++;
			k--;
		}
		return a;
	}
	
	public static int[] replicate(int[] a, int n){
		int[] array = new int[a.length*n];
		int i = 0;
		int j = 0;
		while(i < n){
			int k = 0;
			while(k < a.length){
				array[j]=a[k];
				k++;
				j++;
			}
			i++;
		}
		return array;
	}

	public static int plateau(int[] a){
		int j=1;
		int i;
		int k=1;
		for(i=1; i<a.length; i++){
			if(a[i-1]==a[i]){
				j++;
				if(k<j){
					k=j;
				}
			}
			else{
				j=1;
			}
		}
		return k;
	}	
}
```
juhuuu bin fast fertig nur noch dieses arraytostring:toll:


----------



## Firephoenix (15. Mrz 2011)

Hi,
zu der for-Schleife:
eine for-schleife dieser form

```
(int i = 0; i < x; i++){

Anweisungen

}
```

würde x-1 schritte durchlaufen.
beim ersten schritt ist i=0, dann werden die anweisungen ausgeführt.
Dannach wird die Schleifenanweisung ausgeführt (i++), also i um eins erhöht.
dannach werden wieder die anweisungen im schleifenrumpf ausgeführt usw.
irgendwann ist i = x und die schleife beendet sich ohne nochmal die anweisungen auszuführen.

Angewendet auf ein Array:
Dein Array hat z.B. die Länge 5.
Dann sind die Felder des Arrays von 0 bis 4 durchnummeriert.
wenn du also die schleife so aufbaust:
for(int i = 0; i < array.length; i++){
machwasmit array_
}
,kannst du nacheinander auf jedes element des arrays zugreifen -> also genau das, was wir wollen.

die erweiterte for-schleife kann man sich so übersetzen:
for(int x : int[]){
machwas mit x
}
"laufe einmal über das Array rechts neben dem doppelpunkt, lese jeden int-wert aus und nenne ihn x, im schleifenrumpf kannst du irgendwas mit x machen, dannach hole das nächste x")
wie genau die im Hintergrund arbeitet solltest du dir aber selbst ergooglen, das würde hier zu weit gehen ^^
Du hast auf alle Fälle keinen nachteil wenn du statt der foreach/erweitertenForSchleife einfach die normale for-schleife benutzt.
Gruß_


----------



## dehlen (15. Mrz 2011)

du teilst nicht x durch a sondern das ist eine for-each schleife 
schau dir das mal an da wirds erklärt:
The For-Each Loop


----------



## xehpuk (15. Mrz 2011)

Kleine Verbesserung:


Firephoenix hat gesagt.:


> eine for-schleife dieser form
> 
> ```
> (int i = 0; i < x; i++){
> ...


Ne, sie würde schon x-mal durchlaufen. Und zwar für i=0..x-1 (i = 0, 1, …, x-2, x-1). Meintest wohl eher, dass es von einschließlich 0 bis ausschließlich x/einschließlich x-1 geht.


----------



## Firephoenix (15. Mrz 2011)

xehpuk hat gesagt.:


> Kleine Verbesserung:
> 
> Ne, sie würde schon x-mal durchlaufen. Und zwar für i=0..x-1 (i = 0, 1, …, x-2, x-1). Meintest wohl eher, dass es von einschließlich 0 bis ausschließlich x/einschließlich x-1 geht.



asche auf mein Haupt


----------

