Wirtschaftsinformatik (Bachelor-Studiengang): Programmierung (2. Semester)

Sie sind hier: StartseiteWirtschaftsinformatikProgrammierung Java (Kurs 2): Arrays

HB / CM, Kurs vom 01.10.2002 - 31.03.2003

Programmierung Java (Kurs 2): Arrays: 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.

  1. Arrays allgemein
  2. Erzeugung von Arrays
  3. Wozu sind leere Arrays da?
  4. Wie mit Arrays gearbeitet werden kann?!
  5. Was man noch über Arrays wissen muss?!
  6. Arrays und Methoden

Arrays allgemein

Arrays sind Objekte (!), die sich aus gleichartigen Komponenten zusammensetzen.

Array

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.

Zum Menü Wirtschaftsinformatik | Zum Seitenanfang

Erzeugung von Arrays

Beispiel: int[ ] x;

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

Array II

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.

Array III

Bildbeschreibung "Array III": new erzeugt ein neues Objekt, d.h. ein int-Array mit 7 Komponenten.

Arrays der Länge 0 heißen leere Arrays.

Zum Menü Wirtschaftsinformatik | Zum Seitenanfang

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"};

Zum Menü Wirtschaftsinformatik | Zum Seitenanfang

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.

Quelltext überspringen

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.

mehrdimensionale 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:

Quelltext überspringen

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:

Quelltext überspringen

...
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.

Zum Menü Wirtschaftsinformatik | Zum Seitenanfang

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.

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"

Zum Menü Wirtschaftsinformatik | Zum Seitenanfang

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:

Quelltext überspringen

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:

Quelltext überspringen

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:

  1. mit selbstgeschriebener Wiederholungsanweisung

    for (i = 0; i < testWert.length, i++)
    kopie[ i ] = testWert[ i ];

  2. mit Methode arraycopy der Klasse System

    public static void arraycopy(Object original, int originalStart, Object Kopie, int kopieStart, int anzahl);
    hier:
    System.arraycopy(testWert, 0, Kopie, 0, testWert.length);

    Empfehlung: statt 1. möglichst immer 2. verwenden
  3. mit Methode clone

Selbstverständlich können auch mehrdimensionle Arrays an Methoden übergeben werden.

Beispiel:

Quelltext überspringen

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.