C# Dynamisches Array (ArrayList)
ArrayList ist eine dynamische Array-Klasse, die in C# bereitgestellt wird und sich im Namespace System.Collections befindet.
Dynamische Arrays (ArrayList) unterscheiden sich von gewöhnlichen Arrays dadurch, dass ihre Größe dynamisch angepasst werden kann, ohne dass im Voraus eine feste Länge definiert werden muss.
Das dynamische Array (ArrayList) stellt eine geordnete Sammlung von Objekten dar, die einzeln indiziert werden können, und ermöglicht außerdem dynamische Speicherzuweisung, Hinzufügen, Suchen und Sortieren von Elementen innerhalb der Liste.
ArrayListDie Klasse eignet sich für Array-Operationen, die häufige Größenänderungen erfordern, aber aufgrund ihrer nicht-generischen Natur wird sie in der modernen C#-Entwicklung allmählich [durch List<T> ersetzt].List<T>Ersetzung.
Grundstruktur
public class ArrayList : ICollection, IEnumerable, IList, ICloneable
Schnittstelle implementieren:
- Schnittstelle implementieren：
IList: Unterstützt den Zugriff auf Elemente über den Index.ICollection: Unterstützt grundlegende Sammlungsoperationen wie Hinzufügen, Entfernen und Zählen.IEnumerable: Unterstützt das Iterieren über Elemente mithilfe eines Enumerators.ICloneable: Unterstützt das KlonenArrayList。
Funktionen
Dynamische Erweiterung：
ArrayListDie Kapazität kann bei Bedarf automatisch angepasst werden, ohne dass eine feste Größe angegeben werden muss.- Wenn die Anzahl der hinzugefügten Elemente die aktuelle Kapazität überschreitet,
ArrayListerhöht es automatisch die Kapazität (normalerweise Verdopplung der ursprünglichen Kapazität).
Nicht generische Sammlungen：
ArrayListEs ist eine nicht generische Sammlung, und alle Elemente werden alsobjectTyp gespeichert. Das bedeutet, dass sie Objekte jeden Typs speichern kann, aber auf die Leistungsauswirkungen von Boxing und Unboxing geachtet werden sollte.
Ungeordnete Funktionsweise：
- Obwohl die Reihenfolge der Elementspeicherung der Reihenfolge des Hinzufügens entspricht, bietet sie keine integrierte Sortierfunktion.
Threadsicherheit：
- Es ist standardmäßig nicht threadsicher. Wenn eine threadsichere [Implementierung benötigt wird],
ArrayList, kann man verwendenArrayList.SynchronizedDie Methode erstellt eine threadsichere Version.
Methoden und Eigenschaften der ArrayList-Klasse
Die folgende Tabelle listetArrayListEinige häufige Verwendungen der KlasseEigenschaft：
| Attributname | Type | Beschreibung |
|---|---|---|
Count | int | AbrufenArrayListDie Anzahl der enthaltenen Elemente. |
Capacity | int | Abrufen oder festlegenArrayListDie Kapazität (Speicherplatz). |
IsFixedSize | bool | Gibt anArrayListOb es eine feste Größe hat. |
IsReadOnly | bool | Gibt anArrayListOb es schreibgeschützt ist. |
IsSynchronized | bool | Gibt anArrayListOb es threadsicher ist. |
SyncRoot | object | Ruft ein Objekt ab, das für den synchronisierten Zugriff verwendet werden kann. |
The table below listsArrayListEinige gängige Verwendungen der KlasseMethoden：
| Methodenname | Rückgabetyp | Beschreibung |
|---|---|---|
| Hinzufügen und Einfügen | ||
Add(object value) | int | Fügt das Objekt hinzu zuArrayListAm Ende gibt sie den Index des neuen Elements zurück. |
AddRange(ICollection c) | void | Fügt alle Elemente der angegebenen Sammlung hinzu zuArrayListdas Ende erreicht wird. |
Insert(int index, object value) | void | Fügt ein Objekt am angegebenen Index ein. |
InsertRange(int index, ICollection c) | void | Fügt alle Elemente der angegebenen Sammlung am angegebenen Index ein. |
| Delete | ||
Remove(object value) | void | Entfernt das erste Vorkommen des angegebenen Objekts. |
RemoveAt(int index) | void | Entfernt das Element am angegebenen Index. |
RemoveRange(int index, int count) | void | Entfernt eine angegebene Anzahl von Elementen ab dem angegebenen Index. |
Clear() | void | Alle Elemente entfernen. |
| Zugriff und Abfrage | ||
Contains(object item) | bool | EntscheidungsfindungArrayListOb es das angegebene Objekt enthält. |
IndexOf(object value) | int | Ruft den Index des ersten Vorkommens des angegebenen Objekts ab. |
LastIndexOf(object value) | int | Ruft den Index des letzten Vorkommens des angegebenen Objekts ab. |
| Sortieren und Kopieren | ||
Sort() | void | Sortiert in der Standardreihenfolge.ArrayListDie darin enthaltenen Elemente. |
Sort(IComparer comparer) | void | Sortiert nach einem benutzerdefinierten Vergleich. |
Reverse() | void | ReverseArrayListDie Reihenfolge der Elemente in |
CopyTo(Array array) | void | wirdArrayListDie Elemente in das angegebene Array kopieren. |
| Sonstiges | ||
GetRange(int index, int count) | ArrayList | Ruft eine Teilmenge einer angegebenen Anzahl von Elementen ab, beginnend am angegebenen Index. |
ToArray() | object[] | wirdArrayListKopiert die Elemente in das Array. |
TrimToSize() | void | Passt die Kapazität an die tatsächliche Anzahl der Elemente an, um Speicher zu sparen. |
Beispiel
Das folgende Beispiel veranschaulicht das Konzept dynamischer Arrays (ArrayList):
Beispiel
using System;
using System.Collections;
namespace CollectionApplication
{
class Program
{
static void Main(string[] args)
{
// Ein dynamisches Array erstellen und initialisieren
ArrayList numbers = InitializeArrayList();
// Kapazität und Elementanzahl des Arrays anzeigen
DisplayArrayListInfo(numbers);
// Inhalt des Arrays anzeigen
Console.Write("Originaler Inhalt: ");
DisplayArrayListContent(numbers);
// Sortiere den Inhalt des Arrays
numbers.Sort();
// Sortierten Inhalt anzeigen
Console.Write("Sortierter Inhalt: ");
DisplayArrayListContent(numbers);
Console.ReadKey(); // Warten auf Tastendruck, um zu beenden
}
/// <summary>
/// Initialisiert und füllt die ArrayList
/// </summary>
/// <returns>Eine ArrayList, die die Anfangsdaten enthält</returns>
static ArrayList InitializeArrayList()
{
ArrayList al = new ArrayList();
Console.WriteLine("Zahlen werden zur ArrayList hinzugefügt:");
// Anfangswerte hinzufügen
int[] initialNumbers = { 45, 78, 33, 56, 12, 23, 9 };
foreach (int num in initialNumbers)
{
al.Add(num);
Console.WriteLine($"Hinzugefügt: {num}");
}
return al;
}
/// <summary>
/// Zeigt die Kapazität und die Elementanzahl von ArrayList an
/// </summary>
/// <param name="al">ArrayList-Objekt</param>
static void DisplayArrayListInfo(ArrayList al)
{
Console.WriteLine($"\nKapazität: {al.Capacity}"); // aktuell
Console.WriteLine($"Anzahl: {al.Count}"); // Aktuelle Elementanzahl
}
/// <summary>
/// Zeigt den Inhalt der ArrayList an
/// </summary>
/// <param name="al">ArrayList-Objekt</param>
static void DisplayArrayListContent(ArrayList al)
{
foreach (int num in al)
{
Console.Write(num + " ");
}
Console.WriteLine(); // Zeilenumbruch
}
}
}
using System.Collections;
namespace CollectionApplication
{
class Program
{
static void Main(string[] args)
{
// Ein dynamisches Array erstellen und initialisieren
ArrayList numbers = InitializeArrayList();
// Kapazität und Elementanzahl des Arrays anzeigen
DisplayArrayListInfo(numbers);
// Inhalt des Arrays anzeigen
Console.Write("Originaler Inhalt: ");
DisplayArrayListContent(numbers);
// Sortiere den Inhalt des Arrays
numbers.Sort();
// Sortierten Inhalt anzeigen
Console.Write("Sortierter Inhalt: ");
DisplayArrayListContent(numbers);
Console.ReadKey(); // Warten auf Tastendruck, um zu beenden
}
/// <summary>
/// Initialisiert und füllt die ArrayList
/// </summary>
/// <returns>Eine ArrayList, die die Anfangsdaten enthält</returns>
static ArrayList InitializeArrayList()
{
ArrayList al = new ArrayList();
Console.WriteLine("Zahlen werden zur ArrayList hinzugefügt:");
// Anfangswerte hinzufügen
int[] initialNumbers = { 45, 78, 33, 56, 12, 23, 9 };
foreach (int num in initialNumbers)
{
al.Add(num);
Console.WriteLine($"Hinzugefügt: {num}");
}
return al;
}
/// <summary>
/// Zeigt die Kapazität und die Elementanzahl von ArrayList an
/// </summary>
/// <param name="al">ArrayList-Objekt</param>
static void DisplayArrayListInfo(ArrayList al)
{
Console.WriteLine($"\nKapazität: {al.Capacity}"); // aktuell
Console.WriteLine($"Anzahl: {al.Count}"); // Aktuelle Elementanzahl
}
/// <summary>
/// Zeigt den Inhalt der ArrayList an
/// </summary>
/// <param name="al">ArrayList-Objekt</param>
static void DisplayArrayListContent(ArrayList al)
{
foreach (int num in al)
{
Console.Write(num + " ");
}
Console.WriteLine(); // Zeilenumbruch
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:
Adding numbers to the ArrayList: Added: 45 Added: 78 Added: 33 Added: 56 Added: 12 Added: 23 Added: 9 Capacity: 16 Count: 7 Original Content: 45 78 33 56 12 23 9 Sorted Content: 9 12 23 33 45 56 78
und generische SammlungenList<T>comparison
| Funktionen | ArrayList | List<T> |
|---|---|---|
| Typsicherheit | Nein (Speicherobjecttyp) | Ja (generisch, stark typisierte Einschränkung) |
| Boxing und Unboxing | Ja (erforderlich für Werttypen) | nein |
| Leistung | Relativ niedrig | Höher |
| Generische Unterstützung | Keine | Ja |
| Anwendungsfall | Legacy-Code oder einfache Szenarien | In der modernen Entwicklung bevorzugt |
Hinweise
Häufiges Boxing und Unboxing vermeiden：
- Wenn die Daten hauptsächlich aus Werttypen bestehen, wird die Verwendung von [List<T>] empfohlen
List<T>um Performance-Overhead zu vermeiden.
Gemischte Datentypen mit Vorsicht verwenden.：
- Versuchen Sie, Objekte unterschiedlichen Typs nicht zu mischen und zu speichern, um das Risiko von Laufzeitfehlern zu verringern.
Alternative Lösung：
- In der modernen C#-Entwicklung wird die Verwendung generischer Sammlungen empfohlen (wie z. B.
List<T>、Dictionary<TKey, TValue>), um die Sicherheit und Effizienz des Codes zu verbessern.