Zusammenfassung der grundlegenden Verwendung der generischen C#-Liste List

Der Beispielcode lautet wie folgt:
namespace SampleListT
{
class Program
{
static void Main(string[] args)
{
//using System.Collections .Generic; List
//Verwenden von System.Collections; im Namespace ArrayList
//Beide implementieren Listensammlungen, eine ist eine generische Sammlung und die andere ist eine nicht generische Sammlung
//Als nächstes fügen wir das Person-Objekt zur Sammlung hinzu

Person p1 = new Person( "aladdin" , 20);
Person p2 = new Person("zhao", 10);
Person p3 = new Person("jacky", 40);

//Wenn die Containergröße der Liste nicht angegeben ist, ist der Standardwert 0. Solange ein Element hinzugefügt wird, wird es automatisch auf 4 erweitert . Wenn das fünfte Element hinzugefügt wird, wird es zu 8, und wenn das neunte hinzugefügt wird, wird es zu 16
//Es ist ersichtlich, dass es beim Erweitern immer wieder geöffnet werden muss Wenn die Anzahl der Elemente im Voraus bekannt ist oder möglich ist, ist es am besten, einen möglichst großen Kompromisswert anzugeben
//Wir fügen 3 Elemente hinzu und setzen die Containergröße auf 4 . Hinweis: Die Einstellung auf 4 bedeutet nicht, dass nur 4 Elemente platziert werden können. Es wird auch exponentiell erweitert. Dies dient nur dazu, den durch die Erweiterung verursachten Overhead zu maximieren ;Person>(4);

list.Add(p1);
list.Add(p2);
list.Add(p3);

//Diese Methode besteht darin, überschüssigen ungenutzten Speicherplatz zu löschen. Wenn die Zuordnungsgröße beispielsweise 100 beträgt, ist es nicht verschwenderisch, 4 zu verwenden und den Rest zu belassen? Wenn die Anzahl der Elemente mehr als 90 % der Behältergröße ausmacht, wird sie nicht recycelt.

list.TrimExcess();

//Die ArrayList-Methode wird genauso verwendet wie List<> Der Unterschied besteht darin, dass es sich um eine Sammlung von Objekten handelt und der Parameter Object ist ist die Möglichkeit des Ein- und Auspackens. Versuchen Sie, List zu verwenden Die Initialisierungsfunktion wird bereitgestellt, es gibt jedoch keine Antwort. In IL wird sie auch in die ADD-Methode konvertiert, um

List() { 1 ,2 , 3 ,4 ,5 };

// 2 Elemente hinzufügen AddRange() Diese Methode kann einen Stapel von Objekten auf einmal hinzufügen

List issues = new List(10 );
//Der Parameter ist ein Muss. Objekte, die gelöscht werden dürfen, können auch Arrays sein
list.AddRange( new Person[] { new Person( "aladdin" ,20) , new Person("zhao", 6)});

//Konstruiere und übergebe Batch-Parameter, der Effekt ist der gleiche wie AddRange
List(new Person> new Person( "aladdin" ,20) , new Person("zhao" ,6)});


// 3 Element einfügen
// Mit der Methode Insert() können Sie Fügen Sie ein Element an der angegebenen Position ein

// Wenn wir beispielsweise an Position 1 einfügen, ist es das letzte Es wurde Aladdin Jacky Zhao. Das Einfügen bedeutet, dass ich diese Position besetze. Die Person, die diese Position zuvor besetzt hat und derjenige nach ihm wird alle um eine Stelle zurückrücken

mylist.Insert( 1 , new Person( "jacky" , 88 ));

foreach (Person p in mylist)

{
Console.WriteLine(p.name);
}

// 4 Auf Elemente zugreifen

// ArrayList und List stellen beide Indexer für den Zugriff bereit
Console.WriteLine ( "----------------Zugriff auf Elemente-- -----------------------");

for (int i = 0; i < mylist.Count; i++)

{

Console.WriteLine(mylist[i].name);
}
//Sie können Verwenden Sie auch foreach, um dies zu implementieren, aber hier werden keine Beispiele angegeben

//Verwenden Sie die Foreach-Methode

//public Delegate void Action(T obj); Beispiel mit Delegat als Parameter
//Wir verwenden an einigen Stellen den Day-Ausdruck zur Implementierung
Console.WriteLine( "--- ---------------Verwenden Sie die ForEach-Methode zur Ausgabe------- ----------------------");

mylist.ForEach( param => Console.WriteLine(param.name) ) ;

// 5 Elemente löschen
//Elemente löschen können mit RemoveAt() Value direkt an den Indexer übergeben werden
//Das erste Element direkt löschen

mylist.RemoveAt(0 );

//Sie können das zu löschende Element auch an die Remove-Methode übergeben

List issues2 = new List(10);

Person per1 = new Person( "aladdin" , 100 );
Person per2 = new Person("zhao", 100);
Person per3 = new Person("jacky", 100);

lists2. Add(per1);

lists2.Add(per2);

lists2.Add(per3);

lists2 .Remove(per3);

Console.WriteLine( "- -----Gelöschtes Element---------");

foreach (Person pro in Listen2)
{
Console.WriteLine(per.name);
}
//Aus den Ergebnissen ist ersichtlich, dass das Element namens Jacky gelöscht wurde
//Sprechen wir über den Löschvorgang der Remove-Methode
// Verwenden Sie die IndexOf-Methode, um den Index des Objekts zu ermitteln, und löschen Sie es dann entsprechend dem Index
// In der IndexOf-Methode Überprüfen Sie zunächst, ob das Element die IEquatable-Schnittstelle implementiert. Wenn ja, rufen Sie einfach die Equals-Methode in dieser Schnittstelle auf
// Wenn sie nicht implementiert ist, rufen Sie die Equals-Methode in Object auf, um Elemente zu vergleichen (d. h. Adressvergleich)
// Oben haben wir per3 gelöscht, es ist offensichtlich, dass es eine Adresse gibt, also wurde sie gelöscht

// Als nächstes haben wir Person geändert und IEquatable implementiert. In der Vergleichsmethode wird immer false zurückgegeben. dann schlägt per3 den Vergleich fehl und wird nicht gelöscht
// Das Ergebnis ist, dass alle drei in
// Wenn Sie ein Objekt löschen möchten, löschen Sie es am besten direkt über den Index, da die Die Remove-Methode durchläuft eine Reihe von Prozessen, bevor sie schließlich gemäß dem Index löscht!

// RemoveRange() zum Löschen eines Bereichs
//Die zweite Zahl der Startposition des ersten Parameters
//lists2.RemoveRange( 1, 2);
//Console.WriteLine( "Nach der Stapellöschung----- -----------");

/ /foreach (Person pro in Listen2)
//{
// Console.WriteLine(per.name);
//}

// 6 Suche
// Es gibt viele Möglichkeiten zum Suchen. Sie können IndexOf LastIndexOf FindIndex FindLasIndex Find FindLas verwenden. Wenn Sie nur überprüfen möchten, ob das Element vorhanden ist, können Sie die Methode Exists() verwenden.
//Die Methode IndexOf() erfordert ein Objekt als Parameter. Wenn es getroffen wird, wird der Index des Elements in der Sammlung zurückgegeben. Wenn es nicht gefunden wird, kann IndexOf auch die IEquatable-Schnittstelle zum Vergleichen von Elementen verwenden

List< ;Person> ls3 = new List(10);

Person person1 = neue Person("aladdin", 100);
Person person2 = neue Person("zhao ", 100);
Person person3 = neue Person("jacky", 100);

ls3.Add(person1);
ls3.Add(person2);
ls3.Add (person3);

// Um ​​den Standard-Adressvergleich zu verwenden, entfernen wir vorübergehend die Person-Schnittstelle
int index = ls3.IndexOf(person3);
Console.WriteLine( "index of per3 :" + index) ; //2
// Sie können den Suchbereich auch so angeben, dass er ab dem 3. beginnt. Die Bereichslänge beträgt 1
int index2 = ls3.IndexOf(person3,2,1);
Console . WriteLine(index2);
//Die IEquatable-Vergleichsmethode wurde bereits geschrieben, es werden keine Beispiele angegeben

//Die FindIndex()-Methode wird verwendet, um nach Elementen mit bestimmten Eigenschaften zu suchen
/ / Beispiel: Verwenden Sie Delegaten als Parameter. public Delegate bool Predicate(T obj);

int index3 = ls3.FindIndex(param => param.name.Equals("jacky"));
Console. WriteLine( index3 );// 2
// FindLastIndex sucht nach dem ersten Element, das von hinten erscheint, und spiegelt nicht den Effekt wider, nur eines zu finden und dann anzuhalten.
int index4 = ls3.FindLastIndex(p => p.name.Equals("aladdin"));
Console.WriteLine(index4);
//Die Find-Methode wird genauso verwendet wie der FindIndex Methode, der Unterschied besteht darin, dass es das Element selbst ist.
Person ppp = ls3.Find( p => p.name.Equals("jacky")) ;
Console.WriteLine(ppp);

// if Um alle passenden Elemente zu finden, verwenden Sie die FindAll-Methode, anstatt anzuhalten, wenn Sie das erste finden.
// Wir finden alle Objekte, deren Alter 100 beträgt, und 3 davon stimmen überein
List newList = ls3. FindAll(p => p.age == 100);

Console.WriteLine( "----------Find all-- -------");

foreach (Person p in newList)
{
Console.WriteLine(p.name);
}

// 7 Sortierung
// Liste kann mit der Sort-Methode sortiert werden, und der Implementierungsalgorithmus ist Schnellsortierung
//Diese Methode weist mehrere Überladungen auf

//public void Sort() ; //Dies kann nur verwendet werden, wenn IComparable für die Elementmethode implementiert ist. Wenn es implementiert ist, können Sie sort einmal direkt aufrufen und die Reihenfolge wird sortiert
//public void Sort(ComparisonVergleich); Unsere Person implementiert diese Schnittstelle nicht, daher müssen wir eine generische Methode mit dem Typdelegaten als Parameter verwenden. T x, T y);
//public void Sort(int index, int count, IComparer Comparer); //Sie können den Bereich angeben

List ;Person>(10);

Person person4 = neue Person("aladdin", 100);

Person person5 = neue Person("zhao", 33);
Person person6 = neue Person ("jacky", 44);

ls4 .Add(person4);

ls4.Add(person5);
ls4.Add(person6);

ls4.Sort (MyComparFunc);

Console.WriteLine( "--- ----------sorted-------------");

foreach ( Person p in ls4)

{
Console .WriteLine(p.name+ p.age );
}

Console.WriteLine( "--------Umkehren Sie die Reihenfolge -------------- ----");

ls4.Reverse();

foreach (Person p in ls4)

{
Console.WriteLine(p.name+ p.age);
}

// 8 Typkonvertierung
//Sie können die Elemente in der Sammlung in jede Art von Elementen konvertieren. Beispielsweise möchten wir die Person in der Sammlung in ein Racer-Objekt umwandeln der Name und kein Alter
// public List ConvertAll(Converter Converter);
// public Delegate TOutput Converter(TInput input);
List((input) => new Racer(input.name)) ;

Console.WriteLine( "-------- --Converted Stuff--------");
foreach (Racer r in ls5)
{
Console.WriteLine(r.name);
}

// 9 Schreibgeschützte Sammlung
// Nachdem die Sammlung erstellt wurde, muss sie lesbar und beschreibbar sein. Andernfalls können keine neuen Elemente hinzugefügt werden ausgefüllt, keine Änderungen vornehmen.
// Sie können eine schreibgeschützte Sammlung verwenden, um den Typ ReadOnlyCollection<> zurückzugeben. aber sobald es eine Operation zum Ändern der Sammlung gibt, wird eine Ausnahme ausgelöst
// Er blockiert die üblichen ADD- und anderen Methoden

ReadOnlyCollection persss = ls5.AsReadOnly();

Console.WriteLine("Ausgabe schreibgeschützte Sammlung");

foreach (Racer r in persss)
{
Console.WriteLine(r.name);
}

Console.ReadLine();

}

//Delegierungsimplementierungsmethode zum Vergleich geschrieben
public static int MyComparFunc(Person p1, Person p2)
{
if (p1.age == p2.age)
{
return 0;
}
else if (p1.age > p2.age)
{
return 1;
}
else
{
return -1;
}
}
}

//zwei Hilfsklassen
class Person //:IEquatable
{
public string name;
public int age;

public Person( string name, int age)
{
this.name = name;
this.age = age;>
////Immer einen False-Wert angeben

//public bool Equals(Person other)

//{
// false zurückgeben ;
//}

}

class Racer

{

public string name;

public Racer(string name)

{

this.name= name;
}
}
}

Weitere verwandte Artikel über die Grundlegende Verwendungszusammenfassung der generischen C#-Liste Liste, bitte folgen Sie der chinesischen PHP-Website!