Eindimensionale Arrays

Problemorientierte Programmiersprachen - Java I SS 2000 

Eindimensionale Arrays 

Erzeugen (2 Möglichkeiten): 

• Erzeugung durch new-Operator: 

float v[] = new float[4]; 


• Erzeugung durch einen Initialisierer: 

int lt[] = {1,2,4,8,16,32,64,128}; 

Diese Syntax erzeugt auf dynamische Weise einen Array und initialisiert seine 

Elemente mit den angebenen Werten. 

lt: 

1 2 4 8 16 32 64 128 

v: 

0.0f 0.0f 0.0f 0.0f 

lt[0] lt[3] lt[7] 

v[0] 

v[3] 

• Arrays sind Objekte. 

• Sie werden dynamisch erzeugt 

• Sie werden automatisch vom Garbage Collector entfernt . 

• Aber kein Konstruktor, sondern new-Operator. 

• Anzahl der Komponenten des Arrays muß bei der Definition 

angegeben werden. 

• Die Länge des Arrays erhält man durch das length-Attribut des 

Arrays (v.length ist in unserem Beispiel gleich 4). 

• Die Indizes der Komponenten müssen ganzzahlig sein. 

• Die Komponenten selbst werden mit 0 beginnend numeriert. 

• Der größte zulässige Index ist immer um 1 kleiner ist als die 

Anzahl der Komponenten (length-1). 

• Negative Indizes und Indizes größer oder gleich der Länge length 

sind nicht zugelassen (z.B. [v.length] führt zum Fehler). 

• Die Elemente eines auf diese Weise erzeugten Arrays werden mit 

dem für diesen Typ üblichen Standardwert initialisiert. (Bei unserem 

Array v beispielweise mit 0.0f.) 

• Direkter Zugriff auf jede Komponente (z.B. v[1] = 1.2). 

Beispiel: (Ausgabe des Arrays lt) 

public class lt { 

public static void main(String[] args) { 

int lt[] = {1,2,4,8,16,32,64,128}; 

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

System.out.println(lt[i]); 

} 

} 

Beispiel: (Summe des Arrays lt) 

public class lt { 


int lt[] = {1,2,4,8,16,32,64,128}; 

int summe =0; 

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

summe = summe + lt[i]; 

System.out.println("Summe: " +summe); 

} 

} 

A. Schmidt, W. Süß 1 19.10.2000 

A. Schmidt, W. Süß 2 19.10.2000



Beispiel: (Erzeugen eines Feldes mit Zufallszahlen als Inhalt) 

public class MyArray { 


double nums[] = new double[10]; 

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

nums[i] = Math.random() * 100; 

Deklaration eines Arrays: 

public class MyArray1 { 


int a1[]= {1,2,3,4,5}; // Definition von a1 

int a2[]; // Deklaration von a2; 

} 

} 


System.out.println(nums[i]); 

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

System.out.println(a1[i]); 

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

System.out.println(a2[i]); } 

} 

Ergibt einen Fehler, da a2 nicht initialisiert wurde. 

Beispiel: (Suchen des größten Wertes im Array) 

public class ArrayGreat { 


double[] nums = new double[10]; //Klammern 

//koennen auch hier stehen 


nums[i] = Math.random() * 100; 

Zuweisung von Arrays: 

public class MyArray1 { 


int a1[]= {1,2,3,4,5}; // Definition von a1 

int a2[]; // Deklaration von a2; 

} 

} 

int max=0; 

//Index des groessten Elementes 


if (nums[max]



Kopieren von Arrays (by reference): 

public class ArrayCopy { 


int[] a = {1,2,4,8,16}; 

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

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

System.out.print (a[i]+" "); 

System.out.println(); 

int[] b = {32,64,128,256,512,1024}; 

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

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

System.out.print(b[i]+" "); 


a=b; 



System.out.print(a[i]+" "); 


a[0]=33; 









} 

} 

Ausgabe: 

a: 1 2 4 8 16 

b: 32 64 128 256 512 1024 

a: 32 64 128 256 512 1024 

a: 33 64 128 256 512 1024 

b: 33 64 128 256 512 1024 

Referenzdatentypen 

• Die komplexeren Datentypen von Java sind Objekte und Arrays. Sie 

werden als „Referenztypen“ bezeichnet, weil sie „per Referenz“ (by 

reference) verarbeitet werden. 

• Im Gegensatz dazu werden die einfachen Datentypen by value, also 

„per Wert“ verarbeitet. 

Kopieren von Variablen (by value): 

public class VarCopy { 


int a = 1; 

System.out.println("a: "+a); 

int b = 2; 

System.out.println("b: "+b); 

a=b; 



a=3; 



} 

} 

Ausgabe: a: 1 

b: 2 

a: 2 

b: 2 

a: 3 

b: 2 

A. Schmidt, W. Süß 5 19.10.2000 

A. Schmidt, W. Süß 6 19.10.2000



Kopieren von Objekten (by reference): 

public class Circle { 

public double x,y,r; // Instanzvariablen 

// Die Konstruktormethoden 

public Circle(double x, double y, double r) 

{ this.x = x; this.y = y; this.r = r; 

} 

public Circle(double r) {this(0.0,0.0,r);} 

public Circle(Circle c) {this (c.x,c.y,c.r);} 

public Circle(){this(0.0,0.0,1.0);} 

public double circumference() 

{ return 2 * 3.14159 * r; } 

public double area() {return 3.14159 * r*r; } 


Circle c1 = new Circle(); 

Circle c2 = new Circle(2,2,4); 

System.out.println("Area c1: " + c1.area()); 


c2=c1; 



c1.r=2; 



} 

} 

Ausgabe: Area c1: 3.14159 

Area c2: 50.26544 

Area c1: 3.14159 

Area c2: 3.14159 

Area c1: 12.56636 

Area c2: 12.56636 

A. Schmidt, W. Süß 7 19.10.2000 

Kopieren von Arrays (by value): 



int[] a = {1,2,4,8,16}; 





int[] b = {32,64,128,256,512,1024}; 





System.arraycopy(a,0,b,0,a.length); 









a[0]=33; 









Ausgabe: 

} 

} 

a: 1 2 4 8 16 

b: 32 64 128 256 512 1024 

a: 1 2 4 8 16 

b: 1 2 4 8 16 1024 

a: 33 2 4 8 16 

b: 1 2 4 8 16 1024 

A. Schmidt, W. Süß 8 19.10.2000



Vorsicht vor Überschreitung der Arraygrenzen: 



int[] a = {1,2,4,8,16}; 





int[] b = {32,64,128,256,512,1024}; 





System.arraycopy(a,0,b,b.length,a.length); 









a[0]=33; 





} 

} 





Keine Erweiterung eines bestehenden Arrays möglich! Lösung: 

int c[] = new int [a.length + b.length] 

System.arraycopy(a,0,c,0,a.length); 

System.arraycopy(b,0,c,a.length,b.length); 

Beispiel: (Sortieren eines Feldes) 

public class ArraySortOwn { 

/**Primitve Moeglichkeit des Sortierens eines Arrays 

**/ 

public static void sort(double[] nums) { 

//Schleife durch das Array 

//Suchen des kleinsten Elementes im Feld 

//Kleinstes Element an erste unsortierte Stelle 

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

int min = i; //Suchen des kleinsten Elementes 

//zwischen i und dem Ende des Arrays. 

for(int j = i; j < nums.length; j++) 

if (nums[j] < nums[min]) min = j; 

// Tauschen des kleinsten Elementes mit i 

double tmp; 

tmp = nums[i]; 

nums[i] = nums[min]; 

nums[min] = tmp; 

} 

} 


double[] nums = new double[10]; //Arrayerzeugung 

for(int i = 0; i < nums.length; i++) //Zufallszahlen 

nums[i] = Math.random() * 100; //generieren 

sort(nums); //Aufruf der Instanzmethode sort 

for(int i = 0; i < nums.length; i++) //Ausdruck 

System.out.println(nums[i]); 

} 

} 

A. Schmidt, W. Süß 9 19.10.2000 

A. Schmidt, W. Süß 10 19.10.2000


Mehrdimensionale Arrays (Felder) 

byte ZweiDimArray[][]; 

• Deklaration der Variablen ZweiDimArray mit Typ byte[][] (Array-von- 

Array-aus-byte). 

byte ZweiDimArray[][] = new Byte [256][]; 

• Dynamische Bereitstellung eines Arrays mit 256 Elementen. Jedes Element 

dieses neuen Arrays ist vom Typ byte[] - einem eindimensionalen 

Array von bytes. 

byte ZweiDimArray[][] = new Byte [256][16]; 

• Dynamische Bereitstellung eines 256Bytes-Arrays, von denen jeder 16 

Bytes aufnehmen kann. Gleichzeitig wird eine Referenz dieser 16 byte- 

Arrays in den 256 Elementen des „äußeren“ Arrays gespeichert. Die 16 

Bytes dieser 256 Arrays werden mit dem Standardwert 0 initialisiert. 

Nicht Erlaubt: 

byte ZweiDimArray[][] = new Byte [][16]; 

Erlaubt: 

• Beliebige Dimension eines mehrdimensionalen Arrays: 

int[][][][][] FuenfDim=new int[3][4][5][6][7]; 

• Nicht rechteckige Form von Arrays: 

int ZweiDim[][]= {{1,2},{3,4,5}, {5,6,7,8}}; 

Beispiel: (Generieren einer Matrix und Ausgabe der Matrix) 

public class Matrix { 


int matrix[][]=new int[4][5]; 

//Ausgabe der Matrix 

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

for (int j=0;j


Beispiel: (Nicht rechteckige Form eines mehrdimensionalen Arrays) 

public class Array2 { 


short triangle[][]=new short[10][]; 

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

triangle[i] = new short[i+1]; 

for (int j=0;j

Eindimensionale Arrays

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?