5.5 Klasse ArrayTools

Eine nützliche Klasse

Natürlich gibt es für den Umgang mit Arrays die sehr umfangreiche Klasse Arrays mit vielen Methoden zum Kopieren, Sortieren, Suchen etc. Später können Sie diese Methoden auch gerne in ihren Projekten einsetzen, aber im ersten und zweiten Semester sollte man lernen, wie man selbst solche Methoden schreiben kann.

Statische Methoden

Wir erstellen jetzt eine Klasse namens ArrayTools. Diese Klasse soll nützliche Methoden zum Umgang mit Arrays aus int-Zahlen zur Verfügung stellen. Alle Methoden werden als statische Methoden deklariert. Das bedeutet, dass man diese Methoden "einfach so" aufrufen kann, ähnlich wie die Methoden der Klasse Math.

Die erste Version der Klasse ArrayTools

Beginnen wir mit der Basis-Version der Klasse. Es soll ein Array beliebiger Länge erzeugt werden können, dann soll das Array ganz oder teilweise mit Zufallszahlen gefüllt werden können, und schließlich soll das Array ganz oder teilweise angezeigt werden können.

Hier zunächst der Quelltext der ersten Version. Ich habe jetzt meine eigene ursprüngliche Version der Klasse von ChatGPT auf Englisch übersetzen lassen - die Kommentare bleiben aber weiterhin deutsch.

import java.util.Random;

public class ArrayTools
{

    /*  Diese Methode erzeugt ein int-Array mit der 
     *  angegebenen Länge.
     */
    public static int[] createArray(int length)
    {
        if (length <= 0)
            return new int[0];

        return new int[length];
    }

    /* Diese Methode füllt die ersten 'count' Elemente des Arrays
     * mit Zufallszahlen aus dem Wertebereich [min, max].
     * count = Anzahl der zu erzeugenden Zufallszahlen
     * min/max = Untere/obere Grenze des Wertebereichs
     */
    public static void fillWithRandomNumbers(int[] array, int count, int min, int max)
    {
        if (array == null || count <= 0 || min > max)
            return;

        Random rng = new Random();
        int limit = Math.min(count, array.length);

        for (int i = 0; i < limit; i++)
        {
            array[i] = rng.nextInt(max - min + 1) + min;
        }
    }

    /* Komfortmethode:
     * Füllt das gesamte Array mit Zufallszahlen aus dem Bereich [min, max].
     */
    public static void fillWithRandomNumbers(int[] array, int min, int max)
    {
        if (array == null)
            return;

        fillWithRandomNumbers(array, array.length, min, max);
    }    

    /* Diese Methode gibt die ersten 'count' Elemente des Arrays aus.
     * Nach jeweils 10 Werten erfolgt ein Zeilenumbruch.
     */
    public static void showArray(int[] array, int count)
    {
        if (array == null || count <= 0)
        {
            System.out.println("(keine Daten)");
            return;
        }

        int limit = Math.min(count, array.length);

        for (int i = 0; i < limit; i++)
        {
            System.out.printf("%5d", array[i]);

            if ((i + 1) % 10 == 0)
                System.out.println();
        }

        System.out.println();
    }

    /* Komfortmethode: Gibt das gesamte Array aus. */
    public static void showArray(int[] array)
    {
        showArray(array, array.length);
    }

}

Methode createArray()

Diese Methode legt ein neues int-Array in der gewünschten Größe an und gibt es zurück. Ein solches Array kann später mit Zufallszahlen gefüllt, ausgegeben oder sortiert werden.

Wenn die angegebene Länge jedoch nicht gültig ist (also length ≤ 0), erzeugt die Methode ein Array der Länge 0. Ein solches leeres Array enthält keine Elemente und kann deshalb zwar zurückgegeben, aber nicht mit Werten belegt werden.

Methode fillWithRandomNumbers()

Die Methode fillWithRandomNumbers(int[] array, int count, int min, int max) füllt die ersten count Elemente eines vorhandenen int-Arrays mit Zufallszahlen. Die erzeugten Werte liegen im Bereich von min bis max (jeweils einschließlich).

        if (array == null || count <= 0 || min > max)
            return;

Mit dieser Anweisung werden Falscheingaben abgefangen. Falls der Wert von count nicht mit der Anzahl der Arrayelemente übereinstimmt, kommt folgende Anweisung zum Zuge:

 int limit = Math.min(count, array.length);

Mit der Methode Math.min() wird das Minimum der beiden Parameter ermittelt. Ist count also größer als array.length, wird das gesamte Array mit Zufallszahlen gefüllt. Ist count kleiner als array.length, werden nur die ersten count Element mit Zufallszahlen gefüllt.

Die Komfortmethode fillWithRandomNumbers()

Diese Methode hat den gleichen Namen wie die vorherige Methode, aber eine andere Parameterliste. Der Compiler kann also problemlos zwischen diesen beiden Methoden unterscheiden. Diese Methode kann benutzt werden, wenn das gesamte Array mit Zufallszahlen gefüllt werden soll. In diesem Fall kann auf den Parameter count verzichtet werden.

Solche Methoden, die eigentlich nichts anderes machen, als eine ähnliche Methode aufzurufen, die mehr Parameter hat, werden als Komfortmethoden bezeichnet. Sie erleichtern den Usern der Klasse den Umgang mit den Methoden.

Methode showArray()

Die Methode showArray(int[] array, int count) gibt die ersten count Elemente eines int-Arrays formatiert in der Konsole aus. Dabei werden pro Zeile genau zehn Werte dargestellt, um eine übersichtliche, tabellarische Struktur zu erzeugen. Ist die angegebene Anzahl größer als die tatsächliche Arraylänge, werden nur so viele Elemente ausgegeben, wie im Array vorhanden sind.

Die Komfortmethode showArray()

Diese Methode kommt ohne den Parameter count aus und gibt das gesamte Array in der Konsole aus. Dazu wird die vorherige Methode showArray() mit dem Parameter count = array.length aufgerufen.

Eine solche Testklasse könnte so aussehen (BlueJ-Version):

public class Test
{
    public Test()
    {
        runTest();
    }

    public void runTest()
    {
        System.out.println("Erzeugung eines Arrays mit 40 Elementen"); 
        int[] numbers = ArrayTools.createArray(40);

        System.out.println("\nDas Array wird mit 12 Zufallszahlen zwischen 20 und 120 gefüllt"); 
        ArrayTools.fillWithRandomNumbers(numbers,12,20,120);

        System.out.println("\nAnzeigen der ersten 12 Zahlen"); 
        ArrayTools.showArray(numbers,12);

        System.out.println("\nAnzeigen des gesamten Arrays"); 
        ArrayTools.showArray(numbers);       

        System.out.println("\nDas gesamte Array wird mit Zufallszahlen zwischen 1 und 60 gefüllt"); 
        ArrayTools.fillWithRandomNumbers(numbers,1,60);    

        System.out.println("\nAnzeigen des gesamten Arrays"); 
        ArrayTools.showArray(numbers);           
    }
}

Sie können diese Testklasse gern übernehmen. Leute, die mit IntelliJ arbeiten, müssen dann noch eine main()-Methode ergänzen.

Einbau der Sortieralgorithmen in ArrayTools

Wir wollen nun eine Bubblesort-Methode in die Klasse ArrayTools einbauen. Das geht so:

   public static void bubblesort(int[] array)
    {
        if (array == null || array.length < 2)
            return;

        int n = array.length;

        for (int pass = 0; pass < n - 1; pass++)
        {
            for (int i = 0; i < n - 1 - pass; i++)
            {
                if (array[i] > array[i + 1])
                {
                    swap(array, i, i + 1);
                }
            }
        }
    } 

Die Methode swap() ist eine private statische Methode, die Sie selbst noch in die Klasse einfügen müssen. Sie vertauscht die beiden Arrayelemente an den Positionen i und i+1.

Verwenden Sie zum Testen gern die folgende Testklasse:

public class Test
{
    public Test()
    {
        runTest();
    }

    public void runTest()
    {
        System.out.println("Erzeugung eines Arrays mit 40 Elementen"); 
        int[] numbers = ArrayTools.createArray(40);

        System.out.println("\nDas gesamte Array wird mit Zufallszahlen zwischen 1 und 60 gefüllt"); 
        ArrayTools.fillWithRandomNumbers(numbers,1,60);    

        System.out.println("\nAnzeigen des gesamten Arrays"); 
        ArrayTools.showArray(numbers);    
        
        System.out.println("\nAufrufen von Bubblesort"); 
        ArrayTools.bubblesort(numbers);
        
        System.out.println("\nAnzeigen des gesamten Arrays"); 
        ArrayTools.showArray(numbers);           
    }
	 
    // Für die IntelliJ-User
    public static void main(String[] args)
    {
        new Test();
    }
}

Weitere Übungen zur Klasse ArrayTools

Die Klasse ArrayTools soll um weitere Methoden erweitert werden, die man beim Umgang mit int-Arrays immer wieder gebrauchen kann. Einige dieser Übungen haben Sie bereits in der Folge 4 kennen gelernt.

public static void delete(int[] array, int index)

public static void insert(int[] array, int index, int value)

public static void insertIntoSorted(int[] array, int value)

public static boolean isSorted(int[] array)

Nachdem wir nun eine eigene Klasse zum Umgang mit int-Array entwickelt haben, können wir uns dem nächsten größeren Projekt zuwenden, dem Bucketsort-Algorithmus.