Datenfelder (Arrays)

In Variablen kann man nicht nur einzelne Werte speichern, sondern mehrere, die ein- oder zweidimensional organisiert sind. Das nennt man dann ein – oder zweidimensionale Arrays. Sie unterscheiden sich nur wenig von “normalen” Variablen und werden in der Form array[] (eindimensional) oder array [] [] (zweidimensional) deklariert. Der Datentyp (int, float, uws.) muss außerdem festgelegt werden.

float [] eindimensional = new float [200];

Die obige Anweisung deklariert ein eindimensionales Datenfeld mit dem Namen eindimensional, in dem 200 Werte gespeichert werden können (0-199). Aufgerufen werden die einzelnen Felder dann mit eindimensional[i], wobei i dann für eine Zahl von 0 bis 199 steht.

float[] [] zweidimensional = new float [200] [200];

Hier haben wir ein Beispiel für ein zweidimensionales Feld, das dann mit zweidimensional[i][i] mit Werten befüllt werden kann. So können die Werte dann natürlich auch wieder ausgelesen werden.

Beispiel: starte Applet

PImage foto;//deklariert die Variable foto;
int [] [] grau = new int [400] [400];
//hier wird ein zweidimensionales Array deklariert

void setup() {
 size(400, 400);
 smooth();
 foto = loadImage("blume.JPG");
//weist der Variablen foto die datei blume.jpg zu
 foto.loadPixels();
//sollte man aufrufen, bevor man die einzelen Pixel bearbeitet
 //foto.pixels=sort(foto.pixels);
//wird diese Funktion aktiviert, werden die Farben sortiert ausgegeben
 for (int gridX = 0; gridX < foto.width; gridX++) {
 for (int gridY = 0; gridY < foto.height; gridY++) {
 // überträgt die Farbinfo eines Pixels auf die Variable farbe
 color farbe = foto.pixels[gridY*foto.width+gridX];
 // wandelt die Farbinfo in einen Grauwert um
 int grauwert =round(red(farbe)*0.222+green(farbe)*0.707+blue(farbe)*0.071);
 grau [gridX] [gridY] = grauwert;//speichert den Grauwert in unser Array grau
 }
 }
}

void draw() {
 background(0);
 //image(foto,0,0);// gibt einen netten Überlagerungseffekt
 //jetzt wird nur für jedes 10 Pixel der Helligkeitswert ausgelesen.
 for (int gridX = 0; gridX < foto.width; gridX+=10) {
 for (int gridY = 0; gridY < foto.height; gridY+=10) {
 fill(grau [gridX] [gridY]);//gibt den Grauwert aus unserem Array aus
 ellipse (gridX,gridY,9,9);
 }
 }
}

Dieses Beispiel liest die Farbinformationen jedes Pixels eines Bildes aus und wandelt sie in Grauwerte um. Dann werden Ellipsen mit den Grauwerten gezeichnet.

Arrays können durch Funktionen manipuliert werden.

Array-A= append(Array-A, Wert) // hängt ein Element an
Array-A= shorten(Array-A) // eliminiert das letzte Element
arrayCopy(Array-A,Array-B) // kopiert den Inhalt von Array A nach Array-B
Array-A= reverse(Array-A) // kehrt die Reihenfolge der Elemente um
Array-A= sort(Array-A) //sortiert die Elemente der Größe nach
Array-A= concat(Array-A, Array-B) // hängt Array-B an Array-A an

Aufgabe: Erweitere das folgende Programm so, dass es:

1. ein Element an A anhängt
2. 2 Elemente kürzt
3. die Elemente in ein neues Array B kopiert
4. und die Elemente in umgekehrter Reihenfolge ausgibt.

int [] A = {1, 2, 3, 4, 5, 6};
for (int i=0; i<A.length; i++) { //*.length gibt die Anzahl der Elemente eines Arrays zurück (int)
 println(A[i]);
}

Kleinsten und größten Wert eines Arrays ermitteln:

Zwei kleine Funktionen, die diese Aufgaben erledigen.

float getMaxValue ( float[] values) {
Arrays.sort(values);
return values[values.length-1];
}

Und analog dazu:

float getMinValue ( float[] values) {
Arrays.sort(values);
return values[0];
}

Tags: Arrays, größter Wert, kleinster Wert, Processing