Die for -Schleife HEUTE. Schleifen. Arrays. Schleifen in JAVA. while, do reichen aus, um alle iterativen Algorithmen zu beschreiben

Transkript

1 HEUTE Schleifen Arrays while, do reichen aus, um alle iterativen Algorithmen zu beschreiben Nachteil: Steuermechanismus ist verteilt Übersicht nicht immer leicht dazu gibt es for ( initialization ; condition ; increment )... ; Vorteil: Steuermechanismus steht zusammen man erkennt Funktion der Schleife mit einem Blick Schleifen in JAVA ihr kennt initialization ; initialization ; while ( condition ) do... ;... ; increment ; increment ; while ( condition ) ; Steuermechanismus: initialization: die Steuervariable erstmals setzen condition: die Steuervariable überprüfen increment: die Steuervariable verändern Vergleich der Schreibweisen: int sum = ; int sum = ; int prod = 1 ; int prod = 1 ; int k = 1 ; while ( k <= n ) for ( int k = 1 ; k <= n ; ++k ) sum += a[ k ] ; sum += a[ k ] ; prod *= a[ k ] ; prod *= a[ k ] ; ++k ;

2 for ( int k = 1 ; k <= n ; ++k ) sum += a[ k ] ; prod *= a[ k ] ; Ähnlichkeit zur mathematischen Notation: sum = n a k prod = k=1 eine deklarierte Steuervariable gilt nur innerhalb des Schleifenblocks kein übrig gebliebener Wert außerhalb n k=1 Steuervariable darf im Schleifenblock nicht verändert werden! a k zyklische Vertauschung in einem eindimensionalen Array: gegeben: array[] = gesucht: array[] = public void rotate ( int array[] ) int firstelement = array[ ] ; for ( int i = 1 ; i < array.length ; ++i ) array[ i - 1 ] = array[ i ] ; array[ array.length - 1 ] = firstelement ; // end rotate() zyklische Vertauschung in einem eindimensionalen Array: gegeben: array[] = gesucht: array[] = int[][] = new int[ 5 ][] ; // Init. der Gesamtreferenz for ( int i = ; i <.length ; ++ i ) int[] temp = new int[ i + 1 ] ; // Init. der Zeilenreferenzen for ( int j = ; j < temp.length ; ++j ) temp[ j ] = i + j ; // Init. der Werte [ i ] = temp ; // in Tabelle einhängen alloziert und initialisiert verschieden lange Arrays vom Typ int überschaubares Bild:

3 jeder der Steuerteile darf auch leer sein, z.b.: int n = Integer.valueOf( args[ 1 ] ).intvalue() ; if ( n < 1 ) System.out.println( "eingegebene Zahl muss >= 1 sein!" ) ; else for ( ; n >= 1 ; --n )... for ( ; ; ) entspricht while ( true ) echte Endlosschleife zwei Schleifen vorzeitig verlassen public boolean containsnegativeentry ( int array[][] ) boolean returnvalue = false ; for ( int i = ; i < array.length ; ++i ) for ( int j = ; j < array[ i ].length ; ++j ) if ( array[ i ][ j ] < ) returnvalue = true ; break ; // for ( j ) abbrechen if ( returnvalue ) break ; return returnvalue ; // for ( i ) abbrechen // end containsnegativeentry() eine Schleife vorzeitig verlassen sinnvolle Endlosschleife public boolean containsnegativeentry ( int array[] ) boolean returnvalue = false ; for ( int i = ; i < array.length ; ++i ) if ( array[ i ] < ) returnvalue = true ; break ; // for ( i ) abbrechen return returnvalue ; // end containsnegativeentry() Benutze break, um Schleifenbedingung in der Mitte zu prüfen, z.b.: while ( true ) int nvalue = readintfromuser() ; // int-wert einlesen if ( nvalue < ) break ;... // Signal: soll aufhören // while ( true ) beenden

4 einen Laufwert überspringen break und continue Summe der Nichtdiagonalelemente bilden: array[4][4] = beziehen sich immer auf den innersten Schleifenblock werden beide nicht oft benötigt nur einsetzen, wenn wirklich sinnvoll ihren Sinn immer kommentieren! break ist jedoch obligatorisch in der switch-anweisung einen Laufwert überspringen Arrays in JAVA public void sumintodiagonal ( int array[][] ) for ( int i = ; i < array.length ; ++i ) a[ i ][ i ] = ; for ( int j = ; j < array[ i ].length ; ++j ) if ( j == i ) continue ; // restlichen for(j)-block überspringen a[ i ][ i ] += a[ i ][ j ] ; // end sumintodiagonal() Mathematik: indizierte Variablen z.b. bei Vektorkomponenten x i Folgegliedern a n indizierten Funktionswerten f k Permutationswerten π(i) JAVA: der Objekttyp Array Deklaration z.b. int a[] ; Definition z.b. int a[] = new int[ 3 ] ; Zugriff auf Wert durch []-Operator: a[ i ] Index ist allg. int-ausdruck: a[ 2 * i - 1 ] Arrayvariablen sind Referenztypen

5 Eigenschaften von Arrays zweidimensionale Arrays können von jedem Typ angelegt werden, z.b. int[], double[], Complex[], String[], int[][] werden entsprechend ihres Typs per default initialisiert, z.b. int mit, double mit., Referenztypen mit null int[][] = new int[ 5 ][ 1 ] ; alloziert eine 5 1-Tabelle vom Eintragtyp int [] (1. Zeile) [1][6] [4] (5. Zeile) können bei Deklaration literal initialisiert werden, z.b. int a[] = 1, 2, 3, 4 ; boolean b[] = true, false ; true false Speicherbild dazu: [1][6] die Länge wird zur Laufzeit unveränderlich festgelegt [4] Eigenschaften von Arrays zweidimensionale Arrays Länge ist verfügbar durch Datum length, z.b. int a[] = new int[ 5 ] ; System.out.println( "Array a hat Länge " + a.length ) ; int[][] = new int[ 5 ][] ; alloziert ein Array der Länge 5 von Referenzen des Typs int[] "Array a hat Länge 5" der gültige Indexbereich ist immer,..., length - 1: int a[] = 3, -1 ; System.out.println( "Array a hat Werte " + a[ ] + " und " + a[ 1 ] ) ; "Array a hat Werte 3 und -1" die Referenzen sind alle mit null initialisiert der Index wird zur Laufzeit auf Gültigkeit geprüft

6 zweidimensionale Arrays int[][] = new int[ 5 ][] ; // Init. der Gesamtreferenz [ ] = new int[ 1 ] ; [ 1 ] = new int[ 2 ] ; [ 2 ] = new int[ 3 ] ; [ 3 ] = new int[ 4 ] ; [ 4 ] = new int[ 5 ] ; alloziert jeweils verschieden lange Arrays vom Typ int i = 3 überschaubares Bild: [3][1]