8.3 Die Klasse »ArrayList«

ArrayList gehört zu den Klassen, die das Interface IList implementieren. Ein Objekt vom Typ ArrayList hat standardmäßig eine Kapazität von null Elementen. Fügen Sie das erste Element hinzu, wird die Kapazität auf vier Elemente erhöht. Wird das fünfte Element hinzugefügt, verdoppelt sich automatisch die Kapazität auf acht Elemente. Grundsätzlich wird die Kapazität immer verdoppelt, wenn versucht wird, ein Element mehr hinzuzufügen, als es die aktuelle Kapazität erlaubt. Dabei werden die ArrayList-Elemente im Speicher umgeschichtet, was einen Leistungsverlust zur Folge hat, der umso größer ist, je mehr Elemente sich bereits in der ArrayList befinden.

Sie sollten daher von Anfang an der ArrayList eine angemessene Kapazität zugestehen. Am besten ist es, einfach den parametrisierten Konstruktor aufzurufen und diesem die gewünschte Anfangskapazität mitzuteilen. Eine weitere Möglichkeit bietet auch die Eigenschaft Capacity.

8.3.1 Einträge hinzufügen

Mit der Methode Add lassen sich Objekte einer ArrayList-Instanz hinzufügen. Das erste Element wird dann den Index »0« haben, das zweite den Index »1« usw. Sie haben mit der Add-Methode keinen Einfluss darauf, an welcher Position der Liste das Objekt hinzugefügt wird, denn es wird immer an das Listenende angehängt. Wollen Sie wissen, welchen Index ein hinzugefügtes Objekt erhalten hat, brauchen Sie nur den Rückgabewert der Add-Methode auszuwerten.

ArrayList liste = new ArrayList();
int index = liste.Add("Werner");

Die Add-Methode ist sehr typflexibel und definiert einen Parameter vom Typ Object. Sie können also alle Typen kunterbunt in die Liste packen, vom String über einen booleschen Wert, von einem Button- bis hin zu einem Circle-Objekt. Spätestens dann, wenn Sie die einzelnen Elemente auswerten wollen, werden Sie jedoch in Schwierigkeiten geraten, falls Sie nicht exakt wissen, welcher Typ sich hinter einem bestimmten Listenindex verbirgt. Genau das ist auch der Nachteil der ArrayList.

Über die Methode Add hinaus bietet ArrayList mit AddRange eine weitere, ähnliche Methode an, der Sie auch ein herkömmliches Array übergeben können:

ArrayList liste = new ArrayList();
int[] array = {0, 10, 22, 9, 45};
liste.AddRange(array);

Listing 8.1 Die Methode »AddRange« der Klasse »ArrayList«

Liegt das Array schon bei der Instanziierung von ArrayList vor, kann das Array auch direkt dem Konstruktor übergeben werden:

ArrayList arr = new ArrayList(intArr);

Collection-Initialisierer

Eine weitere Möglichkeit, einer ArrayList Elemente hinzuzufügen, sind Auflistungs-Initialisierer. Mithilfe von Collection-Initialisierern kann man bei der Initialisierung eines Auflistungs-Objekts elegant Elemente hinzufügen. Man verwendet geschweifte Klammern, in denen die einzelnen Elemente durch Kommata voneinander getrennt sind – was dann beispielsweise wie folgt aussieht:

ArrayList liste = new ArrayList() {"Aachen", "Bonn", "Köln", "Düsseldorf" };

Collection-Initialisierer verringern den Codierungsaufwand, da nicht immer wieder die Add-Methode aufgerufen werden muss.

Einträge aus einer »ArrayList« löschen

Mit der Methode Clear können alle Elemente aus der ArrayList gelöscht werden. Die ArrayList wird danach, obwohl sie leer ist, ihre ursprüngliche Kapazität beibehalten, sie schrumpft also nicht.

Löschen Sie einzelne Elemente, bieten sich die Methoden Remove und RemoveAt an. Remove erwartet das zu löschende Objekt, RemoveAt den Index des zu löschenden Objekts. Beim Löschen ist ein ganz besonderes Verhalten der IList-basierten Auflistungen zu erkennen, das wir uns nun in einem Beispiel ansehen wollen.

// Beispiel: ..\Kapitel 8\ArrayListSample
using System;
using System.Collections;
class Program {
  static void Main(string[] args) {
    ArrayList liste = new ArrayList {"Peter", "Andreas", "Conie", "Michael", 
                                     "Gerd", "Freddy"};
    PrintListe(liste);
    liste.Remove("Andreas");
    Console.WriteLine("--- Element gelöscht ---");
    PrintListe(liste);
    Console.ReadLine();
  }
  // Ausgabe der Liste
  static void PrintListe(IList liste) {
    foreach (string item in liste)
      Console.WriteLine("Index: {0,-3}{1}", liste.IndexOf(item), item);
  }
}

Listing 8.2 Beispiel mit einer einfachen ArrayList

Die benutzerdefinierte Methode PrintListe sorgt für die Ausgabe der Elemente an der Konsole. Das Übergabeargument ist als Typ IList definiert. Daher kann der Methode jedes Objekt übergeben werden, das die Schnittstelle IList implementiert, beispielsweise ein herkömmliches Array – vorausgesetzt, es verwaltet Zeichenfolgen.

Nach dem Füllen der Auflistung wird der Inhalt an der Konsole ausgegeben. Neben der Zeichenfolge wird dabei auch noch der aktuelle Index, unter dem die Zeichenfolge eingetragen ist, angezeigt. Der aktuelle Index eines Elements lässt sich mit der Methode IndexOf unter Übergabe des Elements sehr einfach ermitteln.

Nach der Ausgabe der Liste wird das an zweiter Position (Index = 1) befindliche Element mit Remove aus der Auflistung gelöscht. Die Ausgabe der aktualisierten Liste beweist die weiter oben angedeutete typische Charakteristik der indexbasierten Collections: Der Index, den das aus der Liste gelöschte Element innehatte, bleibt nicht leer. Stattdessen verschieben sich alle nachfolgenden Elemente in der Weise, dass kein leerer Index zurückbleibt (siehe auch Abbildung 8.1).

Abbildung 8.1 Element aus der Auflistung löschen

Möchten Sie während eines Schleifendurchlaufs ein Element aus der Liste löschen, ist eine foreach-Schleife als Schleifenkonstrukt denkbar ungeeignet, denn die Methoden des Interfaces IEnumerator funktionieren nur dann, wenn sich die Liste während des Schleifendurchlaufs nicht verändert.

Eine Lösung in solchen Fällen ist die Verwendung der for- oder while-Schleife, z. B.:

for(int index = 0; index < liste .Count; index++) 
{
  if( (string)liste[index] == "Andreas")
    liste.RemoveAt(index);
}

Listing 8.3 Löschen eines ArrayList-Elements in einer Schleife

Auf ein Listenelement wird über seinen Index zugegriffen, indem der Index in eckige Klammern gesetzt wird. Da die Elemente als Object-Typen in die ArrayList eingetragen werden, ist eine Konvertierung in den passenden Typ notwendig, in unserem Code also in string.

8.3.2 Datenaustausch zwischen einem Array und einer »ArrayList«

Auflistungen zeichnen sich durch die beiden Interfaces IEnumerable und ICollection aus. Aus dem letztgenannten Interface stammt die Methode CopyTo, die es ermöglicht, die Einträge einer Auflistung in ein Array zu kopieren.

ArrayList liste = new ArrayList();
liste.Add("Anton");
liste.Add("Gustaf");
liste.Add("Fritz");
string[] arr = new string[10];
liste.CopyTo(arr, 3);

Listing 8.4 ArrayList-Elemente in ein Array kopieren

Der zweite Parameter von CopyTo gibt den Startindex im Array an, ab dem die Elemente der ArrayList in das Array kopiert werden. Das Array muss groß genug sein, um alle Elemente aufzunehmen, sonst wird eine Exception ausgelöst. Handelt es sich bei den zu kopierenden Einträgen um Objektreferenzen, werden nicht die Objekte, sondern nur die Referenzen kopiert. ArrayList überlädt CopyTo, so dass auch spezifizierte Teilbereiche der Liste kopiert werden können.

8.3.3 Die Elemente einer »ArrayList« sortieren

Zum Sortieren der Mitglieder einer ArrayList dient die Methode Sort. Diese Methode ist mehrfach überladen. Wir wollen uns zunächst mit der parameterlosen Version beschäftigen.

Die parameterlose »Sort«-Methode

Um die Elemente einer ArrayList mit der parameterlosen Sort-Methode zu sortieren, müssen die Elemente das Interface IComparable unterstützen. Diese Schnittstelle beschreibt nur die Methode CompareTo:

public interface IComparable {
  int CompareTo(object obj);
}

Eine Klasse, die IComparable implementiert, garantiert die Existenz der Methode CompareTo. Darauf ist die parameterlose Variante der Sort-Methode angewiesen. Aus der .NET-Dokumentation zu CompareTo können wir entnehmen, dass das Objekt, auf dem Sort aufgerufen wird, mit dem an den Parameter übergebenen Objekt verglichen wird. Als Resultat liefert der Methodenaufruf eines der drei folgenden Ergebnisse:

• < 0, wenn das Objekt, auf dem die Methode aufgerufen wird, kleiner als das Objekt obj ist.
• 0, wenn das Objekt, auf dem die Methode aufgerufen wird, gleich dem Objekt obj ist.
• > 0, wenn das Objekt, auf dem die Methode aufgerufen wird, größer als das Objekt obj ist.

Da die parameterlose Sort-Methode das Interface IComparable voraussetzt, sind alle Klassen, die diese Schnittstelle implementieren, ohne zusätzlichen Programmcode dazu geeignet, innerhalb einer ArrayList sortiert zu werden. Das trifft insbesondere auf die elementaren Datentypen wie string, int oder double zu. Somit ist es uns auch möglich, die Listenelemente aus dem Beispiel ArrayListSample durch den Aufruf von Sort unkompliziert sortieren zu lassen.

static void Main(string[] args) {
  ArrayList liste = new ArrayList() {"Peter", "Andreas", "Conie", 
                                     "Michael", "Gerd", "Freddy"};
  liste.Sort();
  PrintListe(liste);
  Console.ReadLine();
}

Listing 8.5 Sortieren einer ArrayList

Die Ausgabe der sortierten Liste sehen Sie in Abbildung 8.2.

Abbildung 8.2 Die mit der Methode »Sort()« sortierten Listenelemente

Eigene Klassen mit »IComparable«

Viele Klassen des .NET Frameworks implementieren die IComparable-Schnittstelle. Das folgende Beispielprogramm soll zeigen, wie Sie dieses Interface auch für eigene Klassen einsetzen können. Dabei werden wir der Einfachheit halber nur mit einer sehr einfachen Klasse arbeiten, die neben der Schnittstellenimplementierung nur einen Integer-Wert in der Eigenschaft Value beschreibt.

public class Demo : IComparable {
  public int Value {get; set;}
  public int CompareTo(object obj) {
    if(obj == null) return 1;
    Demo demo = obj as Demo;
    if (demo != null) return Value.CompareTo(((Demo)obj).Value);
    throw new ArgumentException("Object ist nicht vom Typ Demo");
  }
}

Listing 8.6 Implementieren der Schnittstelle »IComparable«

Die Klasse Demo implementiert das Interface IComparable. Daher sind Objekte dieses Typs darauf vorbereitet, innerhalb einer ArrayList sortiert zu werden. Die Sortierreihenfolge soll sich am Inhalt des Felds Value orientieren. Da CompareTo den Parameter vom Typ Object definiert, müssen wir zwei besondere Situationen berücksichtigen:

• An den Parameter obj wird null übergeben.
• Da der Parameter vom Typ Object ist, könnte auch die Referenz auf ein Objekt übergeben werden, das nicht vom Typ Demo oder davon abgeleitet ist.

Daher überprüfen wir im ersten Schritt, ob die Übergabe an den Parameter null ist. Sollte das der Fall sein, wird die Methode unter Rückgabe des Wertes 1 verlassen. Sollte das Übergabeargument von null abweichen, wird im nächsten Schritt mit dem Operator as geprüft, ob es sich um ein Objekt vom Typ Demo handelt. Die Überprüfung mit as liefert null, falls es sich nicht um ein Demo-Objekt handelt.

Der konkrete Vergleich zwischen zwei Objekten vom Typ Demo ist sehr einfach. Da der Vergleich sich auf die Eigenschaft Value bezieht, die vom Typ Integer ist, können wir davon profitieren, dass Int32 selbst die Schnittstelle IComparable implementiert und somit auch die Methode CompareTo bereitstellt.

Generell sollten Sie die Methode CompareTo der Schnittstelle IComparable wie gezeigt implementieren, um gegen alle unzulässigen Aufrufe gewappnet zu sein und als robust zu gelten.

Natürlich wollen wir nun auch testen, ob wir unser Ziel erreicht haben. Dazu dient der folgende Code:

// Beispiel: ..\Kapitel 8\IComparableSample  
class Program {
  static void Main(string[] args) {
     Demo[] arr = new Demo[] { new Demo { Value = 56 }, new Demo{ Value = 72 }, 
                               new Demo { Value = 35 }, new Demo{ Value = 3 }};
    ArrayList liste = new ArrayList();
    liste.AddRange(arr);     
    liste.Sort();
    foreach (Demo item in liste) {
      Console.WriteLine("Index: {0}/Wert: {1}",liste.IndexOf(item), item.Value);
    }
    Console.ReadLine();
  }
}

Listing 8.7 Sortieren von Demo-Objekten (siehe Listing 8.5)

An der Konsole werden die Werte der Felder in der Reihenfolge 3, 35, 56 und 72 ausgegeben. Der Vergleich und die anschließende Sortierung finden also wie erwartet statt.

Vergleichsklassen mit »IComparer«

Das Sortieren einer ArrayList mit der parameterlosen Sort-Methode gestattet nur, ein durch das Interface IComparable vorgeschriebenes Vergleichskriterium zu nutzen. Manchmal ist es jedoch erforderlich, unterschiedliche Sortierkriterien zu berücksichtigen. Nehmen wir zum Beispiel die Klasse Person, die die beiden Felder Name und City beschreibt:

class Person {
  public string Name {get; set;}
  public string City {get; set;}
}

Listing 8.8 Die Definition der Klasse »Person«

Würde die Klasse die Schnittstelle IComparable implementieren, müsste die Entscheidung getroffen werden, nach welchem Feld Objekte dieser Klasse sortiert werden können. Nun sollen beide Möglichkeiten angeboten werden: sowohl die Sortierung nach City als auch nach Name.

Die Lösung des Problems führt über die Bereitstellung sogenannter Vergleichsklassen, die die Schnittstelle IComparer implementieren. Jede Vergleichsklasse beschreibt genau ein Vergleichskriterium. Wollen wir einen bestimmten Objektvergleich erzwingen, müssen wir der Sort-Methode mitteilen, welche Vergleichsklasse dafür bestimmt ist. Dafür stehen uns zwei Überladungen zur Verfügung, denen die Referenz auf ein Objekt übergeben wird, das die Schnittstelle IComparer implementiert:

public virtual void Sort(IComparer);
public virtual void Sort(int, int, IComparer);

Mit der Überladung, die zwei Integer erwartet, können der Startindex und die Länge des zu sortierenden Bereichs festgelegt werden. Bei sehr großen Auflistungen steigert eine solche Bereichseingrenzung die Performance, da Sortiervorgänge immer sehr rechenintensiv sind.

Die Schnittstelle IComparer stellt die Methode Compare für den Vergleich zweier Objekte bereit:

int Compare(object x, object y);

Compare funktioniert ähnlich wie die weiter oben erörterte Methode CompareTo und gibt die folgenden Werte zurück:

• < 0, wenn das erste Objekt kleiner als das zweite Objekt ist
• 0, wenn das erste Objekt gleich dem zweiten Objekt ist
• > 0, wenn das erste Objekt größer als das zweite Objekt ist

Für die Klasse Person wollen wir nun die beiden Vergleichsklassen NameComparer und CityComparer entwickeln, die gemäß unserer Anforderung die Schnittstelle IComparer implementieren und nach City bzw. Name sortieren.

// Vergleichsklasse – Kriterium City
class CityComparer : IComparer {
  public int Compare(object x, object y) {
    // Prüfen auf null-Übergabe
    if(x == null && y == null) return 0;
    if(x == null) return -1;
    if(y == null) return 1;
    // Typüberprüfung
    if(x.GetType() != y.GetType())
      throw new ArgumentException("Ungültiger Vergleich");
    // Vergleich
    return ((Person)x).City.CompareTo(((Person)y).City);
  }
}
// Vergleichsklasse – Kriterium Name
class NameComparer : IComparer {
  public int Compare(object x, object y) {
    // Prüfen auf null-Übergabe
    if(x == null && y == null) return 0;
    if(x == null) return -1;
    if(y == null) return 1;
    // Typüberprüfung
    if(x.GetType() != y.GetType())
      throw new ArgumentException("Ungültiger Vergleich");
    // Vergleich
    return ((Person)x).Name.CompareTo(((Person)y).Name);
  }
}

Listing 8.9 Vergleichsklassen für die Klasse »Person« aus Listing 8.8

Die Implementierung ähnelt der der Methode CompareTo. Zuerst sollte wieder ein Vergleich mit null durchgeführt werden und anschließend eine Prüfung, ob beide Parameter denselben Typ beschreiben oder zumindest einen vergleichbaren Typ besitzen. Sollte keine Bedingung zutreffen, kann der Vergleich der Objekte erfolgen. Dabei unterstützt uns die Klasse String, die selbst die IComparable-Schnittstelle implementiert und folglich die Methode CompareTo veröffentlicht.

Haben wir ein ArrayList-Objekt mit Person-Objekten gefüllt, steht es uns frei, welche Vergleichsklasse wir zur Sortierung der Objekte benutzen, denn beide sind auf dieselbe Schnittstelle zurückzuführen und gegenseitig austauschbar.

Natürlich können Sie auch jederzeit die Klasse Person um die Schnittstelle IComparer erweitern. Syntaktisch bereitet das zumindest bei einem erforderlichen Vergleichskriterium überhaupt kein Problem. Andererseits müssen Sie sich auch vor Augen halten, wie Sie die Sort-Methode aufrufen müssten:

liste.Sort(new Person());

Dieser Code suggeriert, dass wir es mit einem weiteren, neuen Person-Objekt zu tun haben, obwohl wir das Objekt doch eigentlich nur dazu missbrauchen, das Vergleichskriterium der Sort-Methode anzugeben. Ähnlich schlecht lesbarer und interpretierbarer Code wäre das Resultat, wenn wir mit

liste.Sort(person1);

irgendein existentes Person-Objekt übergeben. Daher sollten Sie von dieser Codeimplementierung Abstand nehmen.

Sehen wir uns nun das Beispielprogramm an, in dem die oben beschriebenen Vergleichskriterien benutzt werden.

// Beispiel: ..\Kapitel 8\IComparerSample
class Program {
  static void Main(string[] args) {
    ArrayList arrList = new ArrayList();
    // ArrayList füllen
    Person pers1 = new Person { Name = "Meier", City = "Berlin" };
    arrList.Add(pers1);
    Person pers2 = new Person { Name = "Arnhold", City = "Köln" };
    arrList.Add(pers2);
    Person pers3 = new Person { Name = "Graubär", City = "Aachen" };
    arrList.Add(pers3);
    // nach Cities sortieren
    arrList.Sort(new CityComparer());
    Console.WriteLine("Liste nach Wohnorten sortiert");
    ShowSortedList(arrList);
    // nach Namen sortieren
    arrList.Sort(new NameComparer());
    Console.WriteLine("Liste nach Namen sortiert");
    ShowSortedList(arrList);
  }
  static void ShowSortedList(IList liste) {
    foreach(Person temp in liste) {
      Console.Write("Name = {0,-12}", temp.Name);
      Console.WriteLine("Wohnort = {0}", temp.City);
    }
    Console.WriteLine();
  }
}

Listing 8.10 Das Beispielprogramm »IComparerSample«

Abbildung 8.3 Ausgabe des Beispiels »IComparerSample«

8.3.4 Sortieren von Arrays mit »ArrayList.Adapter«

Ein herkömmliches Array bietet von Hause aus keine Möglichkeit, die in ihm enthaltenen Elemente zu sortieren. Es gibt dennoch einen Weg, der über die klassische Methode Adapter der Klasse ArrayList führt.

public static ArrayList Adapter(IList list);

Der Methode wird ein IList-Objekt übergeben. Der »Zufall« will es, dass ein klassisches Array diese Schnittstelle implementiert. Adapter legt einen Wrapper (darunter ist eine Klasse zu verstehen, die gewissermaßen um eine andere herumgelegt wird) um das IList-Objekt. Der Rückgabewert ist die Referenz auf ein neues ArrayList-Objekt, auf dessen Methoden, unter anderem auch Sort, sich das IList-Objekt manipulieren lässt.

Wie Sie die Methode Adapter einsetzen können, möchte ich Ihnen an einem Beispiel zeigen. Dabei dient wieder die Klasse Person aus dem Beispiel IComparerSample als Grundlage. Zudem soll auch wieder die Möglichkeit eröffnet werden, entweder nach Name oder City zu sortieren. Dazu können die Vergleichsklassen des Beispiels IComparerSample des letzten Abschnitts wiederverwendet werden.

// Beispiel: ..\Kapitel 8\ArrayListAdapterSample
class Program {
  static void Main(string[] args){
    Person[] pers = new Person[3];
    pers[0] = new Person { Name = "Peter", City = "Celle" };
    pers[1] = new Person { Name = "Alfred", City = "München" };
    pers[2] = new Person { Name = "Hugo", City = "Aachen" };
    ArrayList liste = ArrayList.Adapter(pers);
    // Sortierung nach Namen
    liste.Sort(new NameComparer());
    Console.WriteLine("Sortiert nach den Namen:");
    for (int index = 0; index < 3; index ++)
      if( liste[index] != null)
        Console.WriteLine(((Person)liste[index]).Name);
    // Sortierung nach dem City
    Console.WriteLine("\nSortiert nach dem Wohnort:");
    liste.Sort(new CityComparer());
    for (int index = 0; index < 3; index ++)
      if( liste[index] != null)
        Console.WriteLine(((Person)liste[index]).City);
    Console.ReadLine();
  }
}

Listing 8.11 Beispielprogramm mit der Methode »ArrayList.Adapter«

Bei der Ausgabe der sortierten Listenelemente müssen wir ein wenig vorsichtiger sein. Denn im Gegensatz zur ArrayList, die uns garantiert, dass sich hinter jedem Index ein gültiges Objekt verbirgt, kann der Index in einem klassischen Array null sein. Der Versuch einer Ausgabe oder ganz allgemein des Zugriffs auf ein null-Element würde mit einer Ausnahme quittiert. Daher ist unbedingt darauf zu achten, vor der Ausgabe mit

if (liste[index] != null)

auf den Inhalt null zu prüfen.

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.