Programmiertechnik Felder (Arrays)

(1)

Programmiertechnik

Felder (Arrays)

Prof. Dr. Oliver Haase

(2)

Oliver Haase Hochschule Konstanz 2

Exkurs – Code-Formatierung

Gute Code-Formatierung

 ist das erste und einfachste Mittel, den Programmcode lesbarer (und damit besser wartbar) zu machen;

 spiegelt die logische Struktur des Programms im Layout wider;

 basiert im wesentlich auf guter Einrückung.

(3)

Exkurs – Code-Formatierung

Gleichwertige Anweisungen

 Anweisungen, die auf derselben logischen Ebene stehen, d.h.

Sequenzen von Anweisungen, stehen direkt untereinander:

int i = 3;

String s = "hallo, welt.";

double prozentSatz;

falsch:

richtig:

int i = 3;

String s = "hallo, welt.";

(4)

Exkurs – Code-Formatierung

 Immer nur 1 Befehl pro Zeile! (sonst stünden auch gleichwertige Anweisungen nicht untereinander wie gefordert.)

int a = i; i++;

falsch:

richtig:

int a = i;

i++;

(5)

Exkurs – Code-Formatierung

Tieferstehende Anweisungen

 Anweisungen, die auf der nächst tieferen logischen Ebene stehen, werden um 1 Einheit eingerückt. Das können 2, 3 oder 4 Leerzeichen, oder ein Tabulatoreinrückung sein.  Wichtig: konsistent einrücken!

 Die nächst tiefere Ebene wird eingeleitet durch:

 eine Klassendeklaration

 eine Methodendeklaration

 eine If-Anweisung

 eine Switch-Anweisung

 eine Schleife

(6)

Exkurs – Code-Formatierung

Klassendeklaration

 Die Klassendeklaration steht eine Ebene höher als die Klassenkomponenten:

public class MyClass {

public static void main(String[] args) { …}

falsch:

richtig:

public static void main(String[] args) { …}

(7)

Exkurs – Code-Formatierung

Methodendeklaration (bisher nur main )

 Die Signatur steht eine Ebene höher als der Methodenrumpf:

deshalb z.B.:

public static void main(String[] args) { System.out.println(“Hallo Welt");

}}

(8)

Exkurs – Code-Formatierung

if-Anweisung

 Die Bedingung und das Schlüsselwort else stehen eine Ebene höher als die Anweisungen:

if ( i == 1 )

System.out.println("OK");

else i++;

falsch:

richtig:

if ( i == 1 )

else i++;

(9)

Exkurs – Code-Formatierung

noch besser:

if ( i == 1 ) {

}else { i++;

}

(10)

Exkurs – Code-Formatierung

Switch-Anweisung

 Das Schlüsselwort switch steht eine Ebene höher als das

Schlüsselwort case , das wiederum eine Ebene höher steht als die Anweisungen:

switch ( i ) { case 1:

System.out.println("i ist 1");

break;

case 2:

System.out.println("i ist 2");

break;

default:

System.out.println("Defaultfall");

}

(11)

Exkurs – Code-Formatierung

Schleifen

 Der Schleifenkopf steht eine Ebene höher als der Schleifenrumpf:

 For-Schleife:

for ( int i = 0; i < 10; i++ ) System.out.println(i);

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

System.out.println(i);

System.out.println(2 * i);

} und

(12)

Exkurs – Code-Formatierung

 While-Schleife:

while ( i < 10 )

System.out.println(i++);

while ( i < 10 ) {

System.out.println(i);

i++;

} und

(13)

Exkurs – Code-Formatierung

 Do-Schleife:

do System.out.println(i++);

while ( i < 10 );

do { System.out.println(i);

i++;

} while ( i < 10 );

und

(14)

Exkurs – Code-Formatierung

Klammerungsregel

 Sich öffnende geschweifte Klammern stehen am Ende des

vorangehenden Befehls, sich schließende Klammern in einer

eigenen Zeile. Letztere werden so eingerückt, dass sie mit dem

Beginn der Zeile übereinstimmen, in der die zugehörige offene

Klammer steht. Außer bei Do-Schleifen darf in dieser Zeile kein

weiterer Befehl stehen.

(15)

Exkurs – Code-Formatierung

 Beispiel:

public static void main(String[] args) { int i = 0;

while ( i < 10 ) { if ( i%3 == 0 ) {

System.out.println("Dreierzahl: " + i);

}

else {

System.out.println("keine Dreierzahl");

} i++;

} }

(16)

Exkurs-Ende

Felder (Arrays)

- diesmal wirklich -

(17)

Was sind Referenzdatentypen?

 In Java gibt es 2 Arten von Datentypen:

 skalare Typen (Basistypen, einfache Datentypen):

 byte

 short

 int

 long

 float

 double

 char

 boolean

 Referenzdatentypen

(18)

Was sind Referenzdatentypen?

 Referenzdatentypen erlauben es, aus vorhandenen Typen neue, komplexere, eigene Typen zu konstruieren

 Java kennt 2 Arten von Referenzdatentypen:

 Felder (Arrays)

  Klassen

 Variablen eines Referenzdatentyps sind keine direkten Werte,

sondern Referenzen, d.h. sie verweisen nur auf die eigentlichen

Werte.

(19)

Speicherschema

…

94: 107

… 123

…

101:

123:

Hauptspeicher Speicher-

adressen Variablen

b r

Datentyp

Ganzzahl

Referenz (Adresse, Verweis)

Situation:

 Ganzzahl-Variable b mit Wert 107, gespeichert in Zelle 94

 Referenzvariable r , gespeichert in Zelle 101, verweist auf Zelle 123

(20)

graphische Darstellung

 graphische Darstellung:

 Variable als Kästchen mit Variablennamen, ohne Speicheradresse

 Kästcheninhalt:

 für skalare Typen: Wert

 für Referenzen: Pfeil auf anderes (Speicher-)Kästchen:

b 107 r

 zwei Referenzen r und s sind gleich, wenn sie auf denselben Speicher verweisen:

r s

(21)

Kalenderprogramm

 Aufgabe: Kalenderprogramm zur Verwaltung von Terminen

 Vereinfachung: Nur ein Wochentag (Montag)

Mittagessen mit Kalle Aufgaben bearbeiten

Sport

dösen der Wecker klingelt

aufstehen

Vorlesung schwänzen 00:00

01:00 02:00 03:00 04:00 05:00 06:00 07:00 08:00 09:00 10:00 11:00

12:00 13:00 14:00 15:00 16:00 17:00 18:00 19:00 20:00 21:00 22:00 23:00

Montag

(22)

Kalenderprogramm

 Erste, umständliche, Realisierung (Warnung: 7 Seiten Programm!)

public class UmstaendlicherKalender {

public static void main(String[] args) { java.util.Scanner scanner =

new Java.util.Scanner(System.in);

// fuer jede Stunde eine Variable String termin_00 = "";

String termin_01 = "";

(23)

Kalenderprogramm

(24)

Kalenderprogramm

// die Hauptschleife boolean fertig = false;

while (!fertig) {

// zuerst ein Auswahlmenue

System.out.print("1 = neuer Eintrag\n" + "2 = Termine ausgeben\n" + "3 = beenden");

int auswahl = scanner.nextInt();

// nun eine Fallunterscheidung switch (auswahl) {

case 1: // neuen Termin eingeben System.out.print("Wieviel Uhr?");

int stunde = scanner.nextInt();

System.out.print("Termin?");

String termin = scanner.next();

(25)

Kalenderprogramm

switch (stunde) {

case 0: termin_00 = termin; break;

(26)

Kalenderprogramm

}

break;

(27)

Kalenderprogramm

case 2: // Termine ausgeben

System.out.println(" 0h: " + termin_00);

System.out.println("10h: " + termin_10);

(28)

Kalenderprogramm

System.out.println("---");

break;

case 3:

fertig = true;

break;

default: // falsche Zahl eingegeben

System.out.println("Eingabefehler!");

} } }}

(29)

Analyse

 Kalenderprogramm hat eine Länge von ca. 100 Zeilen

 Davon 72 Zeilen für Verwaltung der Termineinträge:

 24 Zeilen für Variablendeklaration

 24 Zeilen für Fallunterscheidung bei Termineingabe

 24 Zeilen für Ausgabe´der einzelnen Zeiten

 Kalender für ganzes Jahr: 365 · 72 = 26280 Zeilen nur für Termineintragsverwaltung!

 Beobachtung: alle 24 Terminvariablen haben

 denselben Typ (String)

 denselben Namen bis auf einen Index zwischen 00 und 23.

(30)

Felder

 Felder (engl: Arrays) erlauben, mehrere Variablen desselben Typs unter demselben Namen zusammenzufassen, und durch einen Index voneinander zu unterscheiden, etwa

termine[0], termine[1], …, termine[23] .

 Einzelnen Variablen eines Feldes heißen Komponenten.

 Index ist vom Typ int , es sind aber nur positive Werte erlaubt.

 Die erste Komponente eines Feldes hat immer den Index 0.

 Der Index einer Komponente beschreibt deren Position innerhalb des Feldes.

 Ein Feld kann auch als eindimensionale Tabelle aufgefasst werden.

(31)

Felder

 Beispiel: Feld termine für vereinfachtes Kalender- Programm:

Mittagessen mit Kalle Aufgaben bearbeiten

Sport

1213 14 15 16 17 18 19 20 21 der Wecker klingelt

Aufstehen

Vorlesung schwänzen 0 1 2 3 4 5 6 7 8 9 10 11

termine termine[0]

termine[6]

termine[14]

. . .

(32)

Felder

 Beispiel: Ausgabe des 6 Uhr Termins:

erzeugt die Bildschirmausgabe:

 Beispiel: Ausgabe aller Termine:

 Merke: die obige Verwendung einer Schleifenvariable als Index für ein Feld ist eine sehr häufige Programmiertechnik!

System.out.println("6h: " + termine[6]);

6h: der Wecker klingelt

Konsole

for ( int i = 0; i < 24; i++ ) {

System.out.println(i + "h: " + termine[i]);

}

(33)

Felddeklaration

 erzeugt eine Referenzvariable mit Namen <VariablenName> , die auf ein Feld mit Komponententyp <Komponententyp> verweist.

 Merke: Die Felddeklaration erzeugt nicht das eigentliche Feld, nur eine Referenz auf ein Feld!

 Aus Kompatibilitätsgründen mit C/C++ können die Klammern auch nach dem Variablennamen stehen  wird hier nicht verwendet.

<Komponententyp> [] <VariablenName>;

Syntaxregel

(34)

Felddeklaration

 Die Zeilen

int[] feld1;

double[] feld2;

String[] feld3;

int[] feld4;

erzeugen 4 Referenzvariablen, aber noch keine eigentlichen Felder. Zu diesem Zeitpunkt ist noch nicht einmal festgelegt, wieviele Komponenten die Felder einmal haben sollen.

Ein Komponentenzugriff, etwa feld1[0] , ist zu diesem Zeitpunkt noch nicht möglich ( Kompilierfehler)!

feld1

(35)

Felderzeugung

 Beispiel: Die Zeilen

<VariablenName> = new <KomponentenTyp>[<Feldlaenge>];

Syntaxregel

feld1 = new int[4];

feld2 = new double[2];

feld3 = new String[4];

feld4 = new int[5];

erzeugen 4 Felder der geeigneten Typen und setzen die Referenzen entsprechend.

feld1

0 1 2 3

(36)

Feldinitialisierung

 Die einzelnen Komponenten eines Feldes können durch einfache Wertzuweisungen initialisiert werden:

<VariablenName>[<Index>] = <Wert>;

Syntaxregel

 Bei regelmäßigen Werten geschieht dies meistens in einer Schleife:

for ( int i = 0; i < 4; i++ ) { feld1[i] = 2 * i + 1;

}

feld1 1 3 5 7

0 1 2 3

(37)

Feldinitialisierung

 Alternativ kann ein Feld gleichzeitig deklariert, erzeugt und initialisiert werden:

 der Klammerausdruck heißt Feldinitialisierer.

 Hierbei ergibt sich die Feldlänge automatisch aus der Anzahl der Startwerte.

 Diese Schreibweise ist vor allem geeignet für Felder,

 die nicht zu lang sind;

 deren Komponenten keinen regelmäßigen Gesetzmäßigkeiten folgen.

int[] feld1 = {1, 6, 4, 7};

double[] feld2 = {3.14, -276.06};

String[] feld3 = {"Hallo", "dies", "ist ein", "Feld"};

(38)

Kalenderprogramm

 Vereinfachte Realisierung mit Feldern:

public class EinfacherKalender {

// ein Feld fuer den ganzen Tag String[] termine = new String[24];

for ( int i = 0; i < 24; i++ ) { termine[i] = "";

}

(39)

Kalenderprogramm

 Vereinfachte Realisierung mit Feldern:

switch (auswahl) {

case 1: // neuen Termin eingeben System.out.print("Wieviel Uhr?");

termin[stunde] = scanner.next();

(40)

Kalenderprogramm

for ( int i = 0; i < 24; i++ ) {

System.out.println(i + "h: " + termine[i]);

}

break;

case 3:

fertig = true;

break;

} } }}

Programmlänge reduziert von ca. 100 auf 35 Zeilen!

(41)

Feldlänge

 Felder kennen ihre eigene Länge.

String[] feld = {"Hallo", "dies", "ist ein", "Feld"};

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

<VariablenName>.length

Syntaxregel

 Das ist praktisch z.B. wenn

 die Länge erst zur Laufzeit vom Benutzer eingegeben wird;

 eine Feld mit Hilfe eines Feldinitialisierers deklariert und initialisiert wird;

 ein Feld als Parameter in eine Methode übergeben wird.

 Beispiel:

(42)

Feldlänge

 Es ist guter, defensiver Programmierstil, die Feldlänge abzufragen anstatt sie direkt zu verwenden.

 Beispiel: Welches der folgenden Programme ist besser? Warum?

for ( int i = 0; i < feld.length; i++ ) { System.out.println(feld[i]);

}

oder

for ( int i = 0; i < 4; i++ ) { System.out.println(feld[i]);

}

(43)

Referenzzuweisungen

Betrachte folgendes einfaches Programmfragment:

System.out.print("Zahl: ");

int wert = scanner.nextInt();

// kopiere wert in eine neue Variable int wert2 = wert;

// verdopple die neue Variable wert2 *= 2;

// Ausgabe

System.out.println("Die Zahl " + wert +

" ergibt verdoppelt " + wert2);

Zahl: 17

Die Zahl 17 ergibt verdoppelt 34 Konsole

(44)

Referenzzuweisungen

Erweiterte Version für ein Zahlenfeld:

int[] werte = new int[3];

for ( int i = 0; i < werte.length; i++ ) { System.out.print("Zahl Nr. " + i + ": ");

werte[i] = scanner.nextInt();

}// kopiere Feld und verdopple die Eintraege int[] werte2 = werte;

for ( int i = 0; i < werte2.length; i++ ) { werte2[i] *= 2;

}// Ausgabe

for ( int i = 0; i < werte.length; i++ ) { System.out.println("Die Zahl " + werte[i]

+ " ergibt verdoppelt " + werte2[i]);

}

(45)

Referenzzuweisungen

Ausführen des erweiterten Programms:

Zahl Nr. 0: 1 Zahl Nr. 1: 2 Zahl Nr. 2: 3

Die Zahl 2 ergibt verdoppelt 2 Die Zahl 4 ergibt verdoppelt 4 Die Zahl 6 ergibt verdoppelt 6

Konsole

Was ist da schiefgegangen?

(46)

Referenzzuweisungen

werte

0 1 2 int[] werte = new int[3];

werte2 = werte;

werte2

Graphische Speicherdarstellung

werte[0] = 1;

1

werte[1] = 2;

2

werte[2] = 3;

3

werte2[0] *= 2;

2

werte2[1] *= 2;

4

werte2[2] *= 2;

6

Nur die Referenzvariable wird kopiert, nicht das eigentliche Feld! Jede

Änderung an einer der beiden

Variablen ändert auch die andere!

(47)

Kopieren eines Feldes

Kopieren eines Feldes (nicht nur Referenzvariable) erfordert etwas Handarbeit:

 Das neue Feld muss nicht nur deklariert, sondern auch erzeugt werden:

 Die einzelnen Komponenten müssen vom alten in das neue Feld kopiert werden. Dazu gibt es 3 Möglichkeiten:

1. per Hand in einer Schleife

2. Verwendung der Java-Methode System.arraycopy

3. Verwendung der clone-Methode. Diese Option wird noch nicht int[] werte2 = new int[werte.length];

(48)

Kopieren eines Feldes

 Kopieren der Feldkomponenten in einer Schleife:

for ( int i = 0; i < werte.length; i++ ) { werte2[i] = werte[i];

}

(49)

Kopieren eines Feldes

 Verwendung der Java-Methode System.arraycopy :

System.arraycopy(werte, 0, werte2, 0, werte.length);

System.arraycopy(<Quelle>, <QuellStartIndex>,

<Ziel>, <ZielStartIndex>, <Anzahl>);

Syntaxregel

 kopiert <Anzahl> Komponenten von Feld <Quelle> , beginnend bei Index <QuellStartIndex> nach Feld <Ziel> , beginnend mit Index <ZielStartIndex> .

 Beispiel:

(50)

Vergleich von Referenzen

Was gibt das folgende Programm aus und warum?

int[] werte = {1, 2, 3};

int[] werte2 = new int[werte.length];

for ( int i = 0; i < werte.length; i++ ) { werte2[i] = werte[i];

}

if ( werte == werte2 ) {

System.out.println("Gleichheit");

}else {

System.out.println("Ungleichheit");

}

(51)

Vergleich von Referenzen

Ungleichheit

Konsole

Was verglichen wird, sind die Referenzen, und die sind unterschiedlich!

(52)

Mehrdimensionale Felder

 Aufgabe: erweitere Kalenderprogramm so, dass Termine eines ganzen Monats (Januar) verwaltet werden.

00:00 01:00 02:00 03:00 04:00 05:00 06:00 07:00

...

21:00 22:00 23:00

Tag 1

... Tag 2

... Tag 31

…

(53)

Mehrdimensionale Felder

 Lösung: Feld von Feldern  mehrdimensionales Feld

 genauer: Feld mit (31) Komponenten des Typs Feld mit (24) Komponenten des Typs String .

 Deklaration: Verschachtelte Anwendung der Syntaxregel

<Komponententyp> [] <VariablenName>;

Syntaxregel

ergibt

<Feld mit Komponenten des Typs String>[] termine;

String[][] termine; erzeugt: termine

(54)

Mehrdimensionale Felder

 2. Schritt  Feld erzeugen:

erzeugt:

termine = new String[31][];

termine

termine[0] termine[1] … termine[30]

 Merke: Die Länge des äußeren Felds wird im linken Klammernpaar

angegeben.

(55)

Mehrdimensionale Felder

 3. Schritt  Innere Felder erzeugen:

erzeugt:

for ( int i = 0; i < termine.length; i++ ) { termine[i] = new String[24];

for ( int j = 0; j < termine[i].length; j++ ) { termine[i][j] = "";

}}

termine

termine[0] termine[1] … termine[30]

termine[0][0]

termine[0][1]

termine[0][2]

…

(56)

Mehrdimensionale Felder

Zugriff auf mehrdimensionale Felder:

 termine[i] bezeichnet die i-te Komponente des äußeren Felds, d.h. die i-te Spalte einer zweidimensionalen Tabelle. Diese

Komponente ist selbst ein Feld von 24 Strings.

 termine[i].length gibt die Länge der i-ten Komponente (Spalte) an.

 termine[i][j] bezeichnet den j-ten Eintrag in der i-ten Spalte.

 Der Ausdruck

termine[1][7] = "Fruehstueck";

weist dem 7h Termin am Tag 2 den Eintrag "Fruehstueck" zu.

(57)

Kalenderprogramm

 Erweiterte Version für einen ganzen Monat:

public class ErweiterterKalender {

int tag;

// ein Feld fuer den ganzen Monat

String[][] termine = new String[31][];

for ( int i = 0; i < termine.length; i++ ) { termine[i] = new String[24];

for ( int j = 0; j < termine[i].length; j++ ) { termine[i][j] = "";

(58)

Kalenderprogramm

(59)

Kalenderprogramm

// nun eine Fallunterscheidung switch (auswahl) {

case 1: // neuen Termin eingeben System.out.print("Welcher Tag?");

tag = scanner.nextInt();

System.out.print("Wieviel Uhr?");

termin[tag -1][stunde] = scanner.next();

break;

(60)

Kalenderprogramm

System.out.print("Welcher Tag?");

tag = scanner.nextInt();

for (int i = 0; i<termine[tag-1].length; i++) { System.out.println(i + "h: "

+ termine[tag-1][i]);

}

break;

case 3:

fertig = true;

break;

} } }}

(61)

Mehrdimensionale Felder

Vereinfachte Deklaration

 Anstelle von

kann auch die folgende Kurzschreibweise verwendet werden:

int[][] table;

table = new int[2][];

for ( int i = 0; i < table.length; i++ ) { table[i] = new int[3];

}

int[][] table = new int[2][3];

 Merke: Das funktioniert nur wenn alle inneren Felder dieselbe Länge

(62)

Kopieren mehrdimensionaler Felder

 Aufgabe: Kopiere zweidimensionales Feld int[][] table in ein neues zweidimensionales Feld int[][] newTable .

 1. Lösungsversuch:

int[][] newTable = new int[2][3];

newTable = table;

 1. Zeile legt neues zweidimensionales Feld an, aber

 nach 2. Zeile verweist Referenzvariable newTable auf dasselbe Feld wie Referenzvariable table.

 führt keine Feldkopie durch!

(63)

Kopieren mehrdimensionaler Felder

 2. Lösungsversuch:

for ( int i = 0; i < newTable.length; i++ ) { newTable[i] = table[i];

}

 1. Zeile legt neues zweidimensionales Feld an, aber

 nach Schleife verweisen alle inneren Referenzvariablen auf die Spalten in der alten Tabelle table.

 führt nur flache Kopie durch; nicht ausreichend!

(64)

Kopieren mehrdimensionaler Felder

 3. Lösungsversuch:

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

for ( int j = 0; j < newTable[i].length; j++ ) { newTable[i][j] = table[i][j];

}}

 führt gewünschte "tiefe Kopie" durch!