Wirtschaftsinformatik (Bachelor-Studiengang): Programmierung (2. Semester)
Sie sind hier: Startseite › Wirtschaftsinformatik › Programmierung Java (Kurs 2): Arrays
HB / CM, Kurs vom 01.10.2002 - 31.03.2003
- Arrays allgemein
- Erzeugung von Arrays
- Wozu sind leere Arrays da?
- Wie mit Arrays gearbeitet werden kann?!
- Was man noch über Arrays wissen muss?!
- Arrays und Methoden
Arrays allgemein
Arrays sind Objekte (!), die sich aus gleichartigen Komponenten zusammensetzen.
Bildbeschreibung "Array": Ein Array bestehend aus sieben Komponenten.
Alle Komponenten haben denselben Datentyp, gennannt Komponententyp des Arrays.
Es sind alle Datentypen als Komponentendatentypen zulässig (primitive, Referenzdatentypen, also auch Arrays und Objekte)!
Wozu sind Arrays da?
wenn keine Arrays
verfügbar:
Beispiel: angenommen, 100.000 Messwerte sollen statistisch ausgewertet
werden.
public class Messwerte
{
private double messwert1;
...
private double messwert100000;
...
}
Arrays ermöglichen es, derartige Objekte auf einfache Weise angeben zu können.
Erzeugung von Arrays
Beispiel: int[ ] x;
x
ist Referenzvariable auf ein (noch nicht existierendes) Arrayint
ist der Komponentendatentyp des (noch nicht existierenden) Arraysint[ ]
ist der Array-Datentyp
Der Array-Datentyp ist eine Klasse.
x
ist eine Referenzvariable
("Querverweis"), wie bei
allen Objekten muss das Array
(= Objekt) des Array-Datentyps
explizit erzeugt werden!
Hinweis: mit Operator new
durch Initialisierung der
Referenzvariablen
Bildbeschreibung "Array II": x ist Referenzvariable auf ein (noch nicht existierendes) Array.
Erzeugung mit new
Beispiel: x = new int[6];
new
erzeugt ein neues Objekt, d.h. ein
int
-Array mit 7
Komponenten.
Bildbeschreibung "Array III": new
erzeugt ein neues Objekt,
d.h. ein int
-Array mit 7 Komponenten.
- Die Anzahl Komponenten eines Arrays wird erst beim Erzeugen des Arrays festgelegt!
- zulässige Anzahl: 0 bis 2(hoch 31) -1 (Maxint)
- Danach kann sie nicht mehr verändert werden!
- Die Anzahl der Komponenten wird Länge des Arrays genannt.
Arrays der Länge 0 heißen leere Arrays.
Wozu sind leere Arrays da?
Beispiel:
int[ ] machWas()
{
int[ ] speicher;
boolean ok;
...
if (ok)
{
speicher = new int[100];
...
}
else
speicher = new int[0];
return speicher;
}
Es wird auf jeden Fall ein Array erhalten.
Die Länge eines Arrays kann vor der Erzeugung berechnet werden.
Beispiel:
int[ ] x;
int laenge;
final int FAKTOR = 3;
...
laenge = berechneLaenge();
x = new int[FAKTOR × laenge];
Referenzvariablen von einem Array-Datentyp können auf Arrays unterschiedlicher Länge zeigen.
Beispiel:
int[ ] x;
int[ ] y;
...
y = new int[50];
...
y = x; // beide Variablen zeigen auf dasselbe Array;
x = new int[3]; // x aber nicht y zeigt auf ein neues Array mit der Länge 3
Referenvariablen von einem Array-Datentyp können im Rahmen ihrer Deklaration initialisiert werden.
Beispiel:
int[ ] x = {-3, 5, 7}; // Das Array hat die Länge 3
double[ ] messwert = {0.113, 27.3};
String[ ] weltstadt = {"New York", "London", "Paris"};
Wie mit Arrays gearbeitet werden kann?!
Es kann auf die einzelnen Komponenten lesend und schreibend zugegriffen werden. Sie verhalten sich exakt so, wie "normale" Variablen des Komponentendatentyps.
Die Komponenten eines Arrays werden durchnummeriert.
Hinweis: Achtung: Die Zählung beginnt immer bei 0 !!!
Der Zugriff auf die Komponenten eines Arrays erfolgt über die Referenzvariable, die auf das Array zeigt.
Beispiel:
int[ ] x = new int[30];
x[2] = 7;
x[29] = -1;
...
System.out.print(x[29]); // -1
Zeigen mehrere Referenzvariablen auf dasselbe Array, kann über jede von ihnen auf die Komponenten zugegriffen werden.
Beispiel:
boolean[ ] ok, x;
...
ok new boolean[5];
...
for (int i = 0; i < 5; i++)
ok[i] = true;
...
x = ok;
x[0] = false;
System.out.print(ok[0]); // false
In Java ist es nicht möglich, versehentlich "neben" ein Array zuzugreifen (anders als in C, C++).
Jeder Array-Datentyp hat
(als Klasse) ein Attribut namens length
, in dem
automatisch die Länge des Arrays gespeichert wird. Das
heißt, jedes Array
"weiß", wie lang es ist.
Natürliche Darstellung (Beispiel):
void initialisiere (int[ ] feld, int wert)
{
for (int i = 0; i < feld.length; i++)
feld[i] = wert;
}
Diese Methode funktioniert für Arrays unterschiedlicher Länge.
Beispiel:
int[ ] x = new int[100];
int[ ] y = new int[99999];
...
initialisiere(x -1);
initialisiere(y, 1000);
Hinweis: Wenn die Länge eines Arrays benötigt wird, soll immer auf das Attribut length zugegriffen werden. (Nie den vielleicht aus dem Kontext bekannten Wert der Länge direkt benutzen!)
Dass sich die Komponenten eines Array verhalten wie die "normalen" Variablen und Attribute des Komponentendatentyps gilt insbesondere für Arrays, deren Komponentendatentyp ein Referenzdatentyp ist.
public void setzeX(int wert)
{
x = wert;
{
public void setzeY(int wert)
{
y = wert;
}
public void schreibePunkt()
{
System.out.println("(" + x + "; " + y + ")");
}
...
Punkt[ ] p = new Punkt[5];
p[0].setzeX(1);
p[0].setzeY(2);
p[0].schreibePunkt();
richtig:
Punkt[ ] p = new Punkt[ 5 ];
for (int i = 0; < p.length; i++)
p[ i ] = new Punkt();
p[ 0 ].setzeX(1);
p[ 0 ].setzeY(2);
p[ 0 ].schreibePunkt();
Hinweis: Wenn die Komponenten eines Arrays von einem Referenzdatentyp sind, müssen immer zunächst die zugehörigen Objekte erzeugt werden, bevor mit ihnen gearbeitet werden kann!
Der Komponentendatentyp von Arrays kann selbst ein Array-Datentyp sein. Man spricht von mehrdimensionalen Arrays.
Bildbeschreibung "mehrdimensionale Arrays": Abbildung eines
zweidimensionalen Arrays:
int[][]x
. Der Komponentendatentyp ist hier der Array-Datentyp
int[]
.
x
ist eine Referenzvariable auf ein Array, dessen Komponenten
Referenzvariablen
auf ein Array sind, dessen
Komponenten vom Datentyp int
sind.
Achtung: Das Array, auf das x verweist, existiert noch
nicht! Es muss erst erzeugt werden, entweder mit new
oder mit
Initialisierung.
Beispiel:
int[ ] [ ] x;
x = new [ 4 ] [ ]; // immer in Reihenfolge zu benennen
for (int i = 0; i < x.length; i++)
{
x[ i ] = new int[ 5 ];
}
Danach kann mit den Komponenten gearbeitet werden.
Beispiel:
...
x[ 2 ][ 3 ] = 10;
for (int i = 0; i < x.length; i++)
x[ i ][ 1 ] = 3;
for (int j = 0; j < x[ 3 ].length; j++)
x[ 3 ][ j ] = 1
System.out.println(x[ 3 ] [ 1 ]);
Es ist keineswegs zwingend, dass die Arrays, auf die die Komponenten des Arrays verweisen, auf das x verweist, alle dieselbe Länge haben.
Beispiel:
int[ ][ ] x = new int[ 3 ] [ ];
x[ 0 ] = new int[ 5 ];
x[ 1 ] = new int[ 2 ];
x[ 2 ] = new int[ 7 ];
Wenn alle gleichlang sind, ist folgende abkürzende Schreibweise zulässig:
statt:
int[ ] [ ] x = new int[ 4 ] [ ];
for (int i = 0; i < x.length; i++)
x[ i ] = new int[ 5 ];
kann kürzer geschrieben werden:
int[ ] [ ] x = new int[ 4 ] [ 5 ];
Auch höherdimensionale Arrays können im Rahmen ihrer Deklaration initialisiert werden.
Beispiel:
int[ ] [ ] magischesQuadrat = {
{16, 3, 2, 13},
{ 5, 10, 11, 8},
{ 9, 6, 7, 12},
{ 4, 15, 14, 1}
};
int[ ] [ ] y = {
{ 1, 2, 3},
null,
{-1, -2, -3}
};
Die "Zeilen" eines mehrdimensionalen Arrays können einzeln "angesprochen" werden.
Beispiel:
...
int[ ] z = {100, 101, 102};
y[ 1 ] = z;
...
int[ ] temp = null;
temp = y[ 0 ]; //
y[ 0 ] = y[ 2 ]; //
y[ 2 ] = temp; // insgesamt: erste und letzte Zeile werden ausgetauscht
Es können auch höherdimensionale Arrays erzeugt werden.
Beispiel:
int[ ] [ ] [ ] x = new int[ 2 ][ 3 ] [ 3 ];
Für mehrdimensionale Arrays gelten die gleichen Regeln wie für zweidimensionale.
Was man noch über Arrays wissen muss?!
Alternative Möglichkeit zur Deklaration:
statt:
int[ ] x; // so immer in Java
alternativ:
int x[ ]; // ok in C, C++
Auch Referenzvariablen auf Arrays können bei Bedarf mit Attributsmodifizierern versehen werden.
public, protected, private
(nur bei Attributen)static, final, transient, rolefile
Achtung: Attributsmodifizierer gelten nur für die Referenzvariablen, nicht für die zugehörigen Arrays.
Beispiel:
final int[ ] WERTE = {97, 98, 99}
int[ ] x = {1, 2, 3}
...
WERTE[ 0 ] = 100; // ok
WERTE = x; // falsch, da WERTE final ist
Es gibt keine Möglichkeit, Attributsmodifizierer auf die Komponenten von Arrays anzuwenden.
Die praktische Vorgehensweise zur Initialisierung von Referenzvariablen auf Arrays kann nicht bei späteren Wertzuweisungen benutzt werden.
Beispiel:
int[ ] x = {1, 2, 3, 4, 5, 6};
...
... // arbeite mit x
...
x = {20, 21, 22} // nicht erlaubt
Korrekt wäre:
int[ ] temp = {20, 21, 22};
x = temp;
zur Abkürzung dieses korrekten Verfahrens ist folgendes zulässig:
x = new int[ ] {20, 21, 22}; // "anonymes Array"
Arrays und Methoden
Mit Arrays als Parametern können Methoden eine Vielzahl von Input-Werten auf kompakte Weise übergeben werden.
Bei der Übergabe von Arrays auf Methoden ist zu beachten, dass lediglich der Wert der Referenzvariablen auf die Arrays als Parameterwert kopiert wird. ("call by value")
Beispiel:
void verdoppele (int [ ] x)
{
for (int i = 0; i < x.length; i++)
x[ i ] *= 2;
}
...
int[ ] testWert = {1, 2, 3};
...
verdoppele(testWert);
for (int i = 0; i < testWert.length; i++)
System.out.print(testWert[ i ] + " "); // 2 4 6
Daher wird außer- und innerhalb der Methode auf dasselbe Array verwiesen. Das heißt, Änderungen an Arrays innerhalb von Methoden sind auch außerhalb sichtbar.
Sollen die ursprünglichen Werte erhalten bleiben, muss zuvor eine Kopie des Arrays angelegt werden.
Beispiel:
void verdoppele (int [ ] x)
{
for (int i = 0; i < x.length; i++)
x[ i ] *= 2;
}
...
int[ ] testWert = {1, 2, 3};
int[ ] kopie = testWert; // falsch !!! kein kopieren
...
verdoppele(kopie);
for (int i = 0; i < testWert.length; i++)
System.out.print(testWert[ i ] + " "); // 2 4 6
Wie können Arrays kopiert werden?
Es gibt drei Möglichkeiten:
- mit selbstgeschriebener Wiederholungsanweisung
for (i = 0; i < testWert.length, i++)
kopie[ i ] = testWert[ i ]; - mit Methode
arraycopy
der KlasseSystem
Empfehlung: statt 1. möglichst immer 2. verwendenpublic static void arraycopy(Object original, int originalStart, Object Kopie, int kopieStart, int anzahl);
hier:
System.arraycopy(testWert, 0, Kopie, 0, testWert.length); - mit Methode
clone
Selbstverständlich können auch mehrdimensionle Arrays an Methoden übergeben werden.
Beispiel:
void schreibeMatrix(int[ ] [ ] m)
{
schreibeFeld(m[ i ]);
System.out.println();
}
void schreibeFeld(int[ ] a)
{
for (int i = 0, i < a.length, i++)
System.out.print(a[ i ] + " ");
}
...
int[ ] [ ] x = new int[ 4 ] [ 4 ];
for (int i = 0; i < x.length; i++)
for (int j = 0; j < x[ i ]length; j++)
x[ i ][ j ] = i == ? 1 : i + j; // ???
schreibeMatrix(x);
Kopieren mehrdimensionaler Arrays: nur Möglichkeit 1 oder
alternativ arraycopy
auf
zweite Array-Dimension.