» Tutorial / Java Bibliotheken / Arrays

In diesem Kapitel unsere zweiten Tutorial - Reihe wollen wir uns noch einmal detaillierter den Arrays widmen. Dabei wollen wir speziell auf diverse Klassen der Standardbibliothek eingehen, die eine große Anzahl von nützlichen Methoden zur Verwaltung und Manipulation von Arrays bereitstellen.


» Implementierung in Java
» Klassen Array und Arrays
» Kopieren von Arrays
» Durchsuchen von Arrays
» Vergleiche durchführen
» Wertezuweisung
» Sortieren von Arrays
» Anzahl der Elemente ermitteln

» Implementierung in Java nach oben «

Arrays werden in Java in einer eigenen Klasse der Standardbibliothek verwaltet. Diese stellt diverse Methoden zur Erzeugung und Wertezuweisung zur Verfügung. Die Klasse trägt den Namen Array und befindet sich im sogenannten Reflection - Package, wo Sie auch eine Referenz der Klasse wiederfinden.

Neben dieser gibt es noch eine weitere Variante, die die restlichen Algorithmen für die Sortierung, Wertezuweisung und Durchsuchung bereitstellt. Dabei handelt es sich um die Klasse Arrays im Utility - Package von Java.


» Klassen Array und Arrays nach oben «

Die folgenden zwei Klassen sind auf die Operationen mit Arrays zugeschnitten und im Standard implementiert worden. Die System - Klasse bietet eine Methode für das tiefe Kopieren von Feldern an.

Klasse Beschreibung
  
Array Die Stammklasse aller Arrays in Java. Sie stellt zwei Methoden für das Anlegen eines Arrays bereit. Sowohl für eindimensionale als auch für mehrdimensionale Arrays. Des weiteren stellt Sie statische Methoden für das Setzen und Auslesen jedes elementaren Datentyps im Array bereit.
Arrays Die neue Klasse im Standard enthält eine Vielzahl von statischen Methoden, um ganze Arrays oder Sequenzen eines Arrays zu verwalten oder zu manipulieren. Für alle Datentypen können Methoden für die binäre Suche, das Sortieren von Arrayelementen, das Vergleichen der Elemente zweier korrespondierenden Arrays oder das Füllen mit Werten, aufgerufen werden.
System Stellt eine Methode für das sichere und tiefe Kopieren eines Arrays bereit. Dabei wird das gesamte Array neu angelegt, und nicht nur eine neue Referenz auf das alte Objekt erstellt.

» Kopieren von Arrays nach oben «

Um eine tiefe Kopie - sprich ein exaktes Abbild - eines Arrays machen zu können, kann man die Methode arraycopy der Standardbibliothek nutzen. Diese umgeht die häufige Fehlerquelle der Erstellung einer Referenzkopie, indem sie das betroffene Array neu instanziiert und dem zu Folge eine neue Referenz liefert.

Prinzip einer tiefen Kopie

Dabei muss nicht zwangsläufig das gesamte Array betroffen sein. Es können auch einzelne Sequenzbereiche des Arrays kopiert werden. Die Methode hat folglich fünf Parameter. Diese spezifizieren das Quell- und Zielarray, sowie die Startpositionen des Lese- und Schreibvorgangs. Die Anzahl der zu kopierenden Elemente gilt dann ab der Leseposition und stimmt mit der Größe des Zielarrays folgerichtig überein.

Referenz der Methode jetzt nachschlagen

Die Methode befindet sich im System - Package von Java und wird dort global zur Verfügung gestellt. Im folgenden Beispiel werden wir diese Methode nutzen, um eine tiefe Kopie des Arrays zu erzeugen.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    int[] array = {0,1,2,3,4};
    int[]  copy = {0,0,0,0,0};
		
    System.arraycopy(array,1,copy,1,3);
		
    for(int i=0; i<copy.length; i++) 
      System.out.println(copy[i]);
  }
}
Ausgabe 

0
1
2
3
0

Das Beispiel kopiert drei Elemente. Dabei wird im Quellarray ab dem zweiten Index begonnen. Alle drei kopierten Variablen werden in das Zielarray ab der zweiten Indexposition eingefügt.


» Durchsuchen von Arrays nach oben «

Um Arrays nach einem spezifischen Element zu durchsuchen, steht die Methode binarySearch zur Verfügung. Diese steht für alle elementaren Datentypen sowie der Klasse Object bereit. Bei der binären Suche werden nacheinander alle Elemente mit dem gesuchten Wert verglichen und dessen Position geliefert.

Zunächst wollen wir uns die Varianten der elementaren Datentypen ansehen. Sieben Methoden stehen dafür zur Verfügung.

Referenz der Methode jetzt nachschlagen

Bevor dieser Algorithmus angewendet werden kann, muss das Array vorher definitif sortiert werden, ansonsten gibt es fehlerhafte Ergebnisse. Das folgende Beispiel sucht zwei Werte und liefert ihre Indexposition, sofern sie vorhanden sind.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    int[] array = {1,3,5,8};
    
    System.out.println(Arrays.binarySearch(array,5));
    System.out.println(Arrays.binarySearch(array,6));
  }
}
Ausgabe 

 2
-4

Das Element mit dem Wert fünf befindet sich an der dritten Indexposition. Wie aber erklären wir uns die zweite Indexangabe? Ist ein Element nicht im Array enthalten, so wird dessen mögliche Einfügepostion als negativer Wert geliefert. In diesem Fall könnte man den Wert sechs noch an der fünften Position einfügen, um die Sortierreihenfolge des Arrays zu erhalten.

Als nächstes sehen wir uns die Möglichkeit der Verwendung eines sogenannten Comparator - Objekts an. Dabei handelt es sich um eine Klasse, die die Schnittstelle Comparator implementiert. Comparator ist für benutzerdefinierte Vergleichskriterien gedacht, so dass die Art des Vergleichs beeinflusst werden kann. Dazu stellt sie zwei zu implementierende Methoden bereit, die den Vergleich durchführen werden.

Referenz der Schnittstelle jetzt nachschlagen

Das Comparator - Objekt wird von der Methode binarySearch verwendet, kann aber auch als optional belassen werden. Vorallem bei eigenen Klassestypen kann diese Technologie gewinnbringend eingesetzt werden.

Referenz der Methode jetzt nachschlagen

Im folgenden Beispiel legen wir ein Array von Strings an, welches über unser Comparator - Objekt einem benutzerdefinierten Vergleichsalgorithmus unterworfen wird. Die Methode nutzt zwar wiederum die Standard - Vergleichsmethoden des String - Objekts, soll aber verdeutlichen, wie schnell eigene Algorithmen implementiert werden können.

Quellcode 

import java.util.*;

public class MyClass
{
  public static void main(String[] args)
  {
    String[] array = new String[2];
    
    array[0] = new String("ProgrammersBase.DE" );
    array[1] = new String("ProgrammersBase.NET");
    
    System.out.println(
      Arrays.binarySearch(
        array,"ProgrammersBase.NET",new MyComparator()));
  }	
}

class MyComparator
implements Comparator
{	
  public int compare(Object obj1,Object obj2)
  { 	
    return ((String)obj1).compareTo((String)obj2);
  }	
  public boolean equals(Object obj)
  {
    // wird hier nicht verwendet
    return false;
  }	
}
Ausgabe 

1

» Vergleiche durchführen nach oben «

Arrays gleichen Typs können miteinander verglichen werden. Dabei steht die Methode equals der Arrays - Klasse zur Verfügung. An dieser stelle wollen wir zunächst die Methoden für die elementaren Datentypen betrachten. Diese übernehmen jeweils die zwei zu vergleichenden Arrays.

Referenz der Methode jetzt nachschlagen

Die Arrays gelten als gleich, wenn die gleiche Anzahl von Elementen vorhanden ist und wenn die jeweils korrespondierenden Elemente der Arrays identisch sind.

Das folgende Beispiel vergleicht mehrfach zwei Array miteinander und gibt das Ergebis aus.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    int[] array1 = {1,2,3,4};
    int[] array2 = {1,2,3,4};
    int[] array3 = {4,3,2,1};
    int[] array4 = {1,2    };
    
    System.out.println(Arrays.equals(array1,array1));
    System.out.println(Arrays.equals(array1,array2));    
    System.out.println(Arrays.equals(array2,array3));
    System.out.println(Arrays.equals(array1,array4));
  }
}
Ausgabe 

true
true
false
false

» Wertezuweisung nach oben «

Die Arrays - Klasse stellt diverse Füllmethoden zur Verfügung. Als erstes sehen wir uns die Versionen für die Zuweisung eines Wertes an alle Elemente eines Arrays an. Diese erleichtern das initialisieren von Arrays erheblich, denn sie ersetzen oft umfangreiche Schleifenkonstruktionen.

Referenz der Methode jetzt nachschlagen

Folglich initialisieren wir ein Array mit einem festen Wert für alle Elemente.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    int[] array = new int[10];

    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
      
    Arrays.fill(array,1);
    System.out.print('\n');
    
    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
  }
}
Ausgabe 

0000000000
1111111111

Eine letzte Variante erlaubt das Initialisieren einer Teilsequenz des Arrays. Dabei wird ebenfalls eine Referenz auf das Array und den neuen Wert. Des weiteren wird der Start- und Endindex der zu füllenden Sequenz bestimmt.

Referenz der Methode jetzt nachschlagen

Folglich initialisieren wir eine Arraysequenz mit einem festen Wert.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    int[] array = new int[10];

    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
      
    Arrays.fill(array,2,4,1);
    System.out.print('\n');
    
    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
  }
}
Ausgabe 

0000000000
0011000000

» Sortieren von Arrays nach oben «

Im vorletzten Punkt werden wir uns die Sortierung von Arrays, Arraysequenzen und benutzerdefinierten Klassen ansehen. Die erste Variante der Methode sort sortiert ein Array vollständig der Reihe nach vom kleinsten zum größten Element hin.

Referenz der Methode jetzt nachschlagen

Folglich sortieren wir alle zunächst willkürlich eingefügten Elemente eines Arrays und geben die neue Reihenfolge aus.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    int[] array = {7,4,9,0,1,3,8,2,5,6};

    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
      
    Arrays.sort(array);
    System.out.print('\n');
    
    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
  }
}
Ausgabe 

7490138256
0123456789

Die nächste Variante erlaubt die Angabe einer zu sortierenden Sequenzen. Der Prototyp der Methode erweitert sich dabei um die Angabe des Start- und Endindex der zu verwendenden Sequenz.

Referenz der Methode jetzt nachschlagen

Folglich sortieren wir eine Sequenz zunächst willkürlich eingefügter Elemente eines Arrays und geben die neue Reihenfolge aus.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    int[] array = {9,8,7,6,5,4,3,2,1,0};

    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
      
    Arrays.sort(array,5,10);
    System.out.print('\n');
    
    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
  }
}
Ausgabe 

9876543210
9876501234

Die letzte Variante von sort implementiert einen benutzerdefinierten Algorithmus für die Sortierung eines Arrays. Dieser ist für eigene Klassen vorgesehen und wird durch die Schnittstelle Comparator implementiert.

Referenz der Methode jetzt nachschlagen

In der Regel wird dazu eine eigene Klasse definiert, die die Schnittstelle implementiert und dann als Parameter an die Sortiermethode übergeben wird. Zu implementieren sind alle enthaltenen Methoden, wichtig ist für die Methode sort allerdings nur die Methode compare.

Referenz der Schnittstelle jetzt nachschlagen

Folglich sortieren wir ein Array von Integerwerten über unser Comparator - Objekt. Dieses implementiert zwar auf einfache Weise den Standardalgorithmus, zeigt aber die Möglichkeiten dieser Technologie auf.

Quellcode 

import java.util.*;      
      
public class MyClass
{
  public static void main(String[] args)
  {
    Object[] array = new Object[10];
    
    for(int i=9;i>=0;--i)
      array[i] = new Integer(9-i);
    
    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);
    
    Arrays.sort(array,new MyComparator());
    System.out.print('\n');
    
    for(int i=0;i<array.length;i++)
      System.out.print(array[i]);    
  }
}

class MyComparator
implements Comparator
{	
  public int compare(Object obj1,Object obj2)
  {  	  	
    return ((Integer)obj1).compareTo(((Integer)obj2));
  }	
  public boolean equals(Object obj)
  {
    //wird nicht verwendet
    return false;
  }	
}
Ausgabe 

9876543210
9876501234

Die hier gezeigte Methode existiert auch in der Variante der Angabe einer Sequenz.


» Anzahl der Elemente ermitteln nach oben «

Alle Arrays unter Java haben ein gemeinsames Merkmal in Form einer Variable, welche die aktuelle Zahl der im Array enthaltenen Elemente speichert. Die Variable length kann für jedes Array abgefragt werden und wird in Form eines positiven Integerwertes geliefert.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    Object[] array = new Object[10];
    System.out.print(array.length);   
  }
}
Ausgabe 

10

Kapitelübersicht nach oben Kapitel »