Rheinwerk Computing < openbook >


 
Inhaltsverzeichnis
Materialien
Vorwort
1 Java ist auch eine Sprache
2 Imperative Sprachkonzepte
3 Klassen und Objekte
4 Arrays und ihre Anwendungen
5 Der Umgang mit Zeichenketten
6 Eigene Klassen schreiben
7 Objektorientierte Beziehungsfragen
8 Ausnahmen müssen sein
9 Geschachtelte Typen
10 Besondere Typen der Java SE
11 Generics<T>
12 Lambda-Ausdrücke und funktionale Programmierung
13 Architektur, Design und angewandte Objektorientierung
14 Java Platform Module System
15 Die Klassenbibliothek
16 Einführung in die nebenläufige Programmierung
17 Einführung in Datenstrukturen und Algorithmen
18 Einführung in grafische Oberflächen
19 Einführung in Dateien und Datenströme
20 Einführung ins Datenbankmanagement mit JDBC
21 Bits und Bytes, Mathematisches und Geld
22 Testen mit JUnit
23 Die Werkzeuge des JDK
A Java SE-Module und Paketübersicht
Stichwortverzeichnis


Download:

- Listings, ca. 2,7 MB


Buch bestellen
Ihre Meinung?



Spacer
<< zurück
Java ist auch eine Insel von Christian Ullenboom

Einführung, Ausbildung, Praxis
Buch: Java ist auch eine Insel


Java ist auch eine Insel

Pfeil 4 Arrays und ihre Anwendungen
Pfeil 4.1 Einfache Feldarbeit
Pfeil 4.1.1 Grundbestandteile
Pfeil 4.1.2 Deklaration von Array-Variablen
Pfeil 4.1.3 Array-Objekte mit new erzeugen
Pfeil 4.1.4 Arrays mit { Inhalt }
Pfeil 4.1.5 Die Länge eines Arrays über das Attribut length auslesen
Pfeil 4.1.6 Zugriff auf die Elemente über den Index
Pfeil 4.1.7 Typische Array-Fehler
Pfeil 4.1.8 Arrays an Methoden übergeben
Pfeil 4.1.9 Mehrere Rückgabewerte *
Pfeil 4.1.10 Vorinitialisierte Arrays
Pfeil 4.2 Die erweiterte for-Schleife
Pfeil 4.3 Methode mit variabler Argumentanzahl (Varargs)
Pfeil 4.3.1 System.out.printf(…) nimmt eine beliebige Anzahl von Argumenten an
Pfeil 4.3.2 Durchschnitt finden von variablen Argumenten
Pfeil 4.3.3 Varargs-Designtipps *
Pfeil 4.4 Mehrdimensionale Arrays *
Pfeil 4.4.1 Nichtrechteckige Arrays *
Pfeil 4.5 Bibliotheksunterstützung von Arrays
Pfeil 4.5.1 Klonen kann sich lohnen – Arrays vermehren
Pfeil 4.5.2 Warum »können« Arrays so wenig?
Pfeil 4.5.3 Array-Inhalte kopieren
Pfeil 4.6 Die Klasse Arrays zum Vergleichen, Füllen, Suchen und Sortieren nutzen
Pfeil 4.6.1 Eine lange Schlange
Pfeil 4.7 Der Einstiegspunkt für das Laufzeitsystem: main(…)
Pfeil 4.7.1 Korrekte Deklaration der Startmethode
Pfeil 4.7.2 Kommandozeilenargumente verarbeiten
Pfeil 4.7.3 Der Rückgabetyp von main(…) und System.exit(int) *
Pfeil 4.8 Zum Weiterlesen
 

Zum Seitenanfang

4.2    Die erweiterte for-Schleife Zur vorigen ÜberschriftZur nächsten Überschrift

for-Schleifen laufen oft Arrays oder Datenstrukturen ab. Bei der Berechnung des Mittelwerts konnten wir das ablesen:

double sum = 0;

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

sum += array[ i ];

double arg = sum / array.length;

Die Schleifenvariable i hat lediglich als Index ihre Berechtigung; nur damit lässt sich das Element an einer bestimmten Stelle im Array ansprechen.

Weil das komplette Durchlaufen von Arrays häufig ist, gibt es eine Abkürzung für solche Iterationen:

for ( Typ Bezeichner : Array )

...

Die erweiterte Form der for-Schleife löst sich vom Index und erfragt jedes Element des Arrays. Das können Sie sich als Durchlauf einer Menge vorstellen, denn der Doppelpunkt liest sich als »in«. Rechts vom Doppelpunkt steht immer ein Array oder, wie wir später sehen werden, etwas vom Typ Iterable, wie eine Datenstruktur. Links wird eine neue lokale Variable deklariert, die später beim Ablauf jedes Element der Sammlung annehmen wird.

Die Berechnung des Durchschnitts lässt sich nun umschreiben. Die statische Methode avg(…) soll mit dem erweiterten for über die Schleife laufen, anstatt den Index selbst hochzuzählen. Eine Ausnahme zeigt an, ob der Array-Verweis null ist oder das Array keine Elemente enthält:

Listing 4.4    src/main/java/com/tutego/insel/array/Avg2.java, avg()

static double avg( double[] array ) {

if ( array == null || array.length == 0 )

throw new IllegalArgumentException( "Array null oder leer" );



double sum = 0;



for ( double n : array )

sum += n;



return sum / array.length;

}

Zu lesen ist die for-Zeile demzufolge als »Für jedes Element n vom Typ double in array tue …«. Eine Variable für den Schleifenindex ist nicht mehr nötig.

Anonyme Arrays in der erweiterten for-Schleife nutzen

Rechts vom Doppelpunkt lässt sich auf die Schnelle ein Array aufbauen, über welches das erweiterte for dann laufen kann:

for ( int prime : new int[]{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31 } )

System.out.println( prime );

Das ist praktisch, um über eine feste Menge von Werten zu laufen. Das funktioniert auch für Objekte, etwa Strings:

for ( String name : new String[]{ "Cherry", "Gracel", "Fe" } )

System.out.println( name );
[»]  Hinweis

Rechts vom Doppelpunkt kann ein Array oder ein Objekt vom Typ Iterable stehen:

for ( String name : Arrays.asList( "Cherry ", "Gracel", "Fe" ) )

System.out.println( name );

Arrays.asList(…) erzeugt kein Array als Rückgabe, sondern baut aus der variablen Argumentliste eine Sammlung auf, die von einem speziellen Typ Iterable ist; alles, was Iterable ist, kann die erweiterte for-Schleife ablaufen. Wir kommen später noch einmal darauf zu sprechen. Unabhängig vom erweiterten for hat die Nutzung von Arrays.asList(…) noch einen anderen Vorteil, etwa bei Ist-Element-von-Anfragen, etwa so:

if ( Arrays.asList( 1, 2, 6, 7, 8, 10 ).contains( number ) )

Mehr zu der Methode folgt in Abschnitt 4.6, »Die Klasse Arrays zum Vergleichen, Füllen, Suchen und Sortieren nutzen«.

Umsetzung und Einschränkung

Intern setzt der Compiler diese erweiterte for-Schleife ganz klassisch um, sodass der Bytecode unter beiden Varianten gleich ist. Nachteile dieser Variante sind jedoch:

  • Das erweiterte for läuft standardmäßig immer das ganze Array ab. Ein Anfang- und ein Ende-Index können nicht ausdrücklich gesetzt werden.

  • Die Ordnung ist immer »von vorn nach hinten«.

  • Die Schrittlänge ist immer 1.

  • Der Index ist nicht sichtbar.

  • Die Schleife liefert ein Element, kann aber nicht in das Array schreiben.

Abbrechen lässt sich die Schleife mit einem break. Bestehen andere Anforderungen, kann weiterhin nur eine klassische for-Schleife helfen.

Beispiel: Arrays mit Strings durchsuchen

In unserem ersten Beispiel soll ein nichtprimitives Array Strings referenzieren und später schauen, ob eine Benutzereingabe im Array ist. String-Vergleiche lassen sich mit equals(…) realisieren:

Listing 4.5    src/main/java/com/tutego/insel/array/UserInputInStringArray.java, main()

String[] validInputs = { "Banane", "Apfel", "Kirsche" };



boolean found = false;

while ( ! found ) {

String input = new Scanner( System.in ).nextLine();



for ( String s : validInputs )

if ( s.equals( input ) ) {

found = true;

break;

}

}



System.out.println( "Gültiges Früchtchen eingegeben" );

Zur Initialisierung des Arrays nutzt das Programm eine kompakte Variante, die drei Dinge vereint: den Aufbau eines Array-Objekts (mit Platz für drei Referenzen), die Initialisierung des Array-Objekts mit den drei Objektreferenzen und schlussendlich die Initialisierung der Variablen validInputs mit dem neuen Array – alles in einer Anweisung.

Für die Suche kommt das erweiterte for zum Einsatz, das in einer Schleife eingebettet ist, die genau dann endet, wenn das Flag found gleich true wird. Wenn wir nie einen korrekten String eingeben, wird die äußere Schleife auch nie enden. Wenn wir einen Eintrag finden, kann das flag gesetzt werden und break die Array-Schleife früher verlassen.

Zufällige Spielerpositionen erzeugen

Im zweiten Beispiel sollen fünf zufällig initialisierte Punkte in einem Array abgelegt werden. Die Punkte sollen Spieler repräsentieren.

Zunächst benötigen wir ein Array:

Point[] players = new Point[ 5 ];

Die Deklaration schafft Platz für fünf Verweise auf Punkt-Objekte, aber kein einziges Point-Objekt ist angelegt. Standardmäßig werden die Array-Elemente mit der null-Referenz initialisiert, sodass System.out.println(players[0]) die Ausgabe »null« auf den Bildschirm bringen würde. Bei null wollen wir es nicht belassen, daher müssen die einzelnen Array-Plätze etwa mit players[0] = new Point() initialisiert werden.

Zufallszahlen erzeugt die mathematische Methode Math.random(). Da die statische Methode jedoch Fließkommazahlen zwischen 0 (inklusiv) und 1 (exklusiv) liefert, werden die Zahlen zunächst durch Multiplikation frisiert und dann abgeschnitten.

Im letzten Schritt geben wir ein Raster auf dem Bildschirm aus, in dem zwei ineinander verschachtelte Schleifen alle x/y-Koordinaten des gewählten Bereichs ablaufen und dann ein & setzen, wenn der Punkt einen Spieler trifft.

Das Programm als Ganzes:

Listing 4.6    src/main/java/com/tutego/insel/array/FivePlayers.java, main()

Point[] players = new Point[ 5 ];



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

players[ i ] = new Point( (int)(Math.random() * 40),

(int)(Math.random() * 10) );



for ( int y = 0; y < 10; y++ ) {

for ( int x = 0; x < 40; x++ )

if ( Arrays.asList( players ).contains( new Point(x,y) ) )

System.out.print( "&" );

else

System.out.print( "." );

System.out.println();

}

Der Ausdruck Arrays.asList(players).contains(new Point(x, y)) testet, ob irgendein Punkt im Array players gleich dem Punkt mit den x/y-Koordinaten ist.

Die Ausgabe erzeugt zum Beispiel Folgendes:

........................................

...............&........................

&.......................................

........................................

........................................

..............................&.........

........................................

...&....................&...............

........................................

........................................

Während die erweiterte for-Schleife gut das Array ablaufen kann, funktioniert das zur Initialisierung nicht, denn das erweiterte for ist nur zum Lesen gut. Elementinitialisierungen funktionieren bei Arrays nur mit players[i]=…, und dazu ist eben eine klassische for-Schleife mit dem Index nötig.

 


Ihre Meinung?

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de

<< zurück
 Zum Rheinwerk-Shop
Zum Rheinwerk-Shop: Java ist auch eine Insel Java ist auch eine Insel

Jetzt Buch bestellen


 Buchempfehlungen
Zum Rheinwerk-Shop: Captain CiaoCiao erobert Java

Captain CiaoCiao erobert Java




Zum Rheinwerk-Shop: Java SE 9 Standard-Bibliothek

Java SE 9 Standard-Bibliothek




Zum Rheinwerk-Shop: Algorithmen in Java

Algorithmen in Java




Zum Rheinwerk-Shop: Objektorientierte Programmierung

Objektorientierte Programmierung




 Lieferung
Versandkostenfrei bestellen in Deutschland, Österreich und in die Schweiz

InfoInfo



 

 


Copyright © Rheinwerk Verlag GmbH 2021

Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das Openbook denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt.

Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

 

[Rheinwerk Computing]



Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de



Cookie-Einstellungen ändern