Lädt...

List

Erstelle eine List<int> namens bag mit new List<int>(). Füge 3 hinzu, dann 8. Schreibe zuerst bag[0], dann bag.Count. Halte die Arbeit in Pine mit Main. Setze using System.Collections.Generic; unter using System;, damit der Kurzname List funktioniert. Starte mit dotnet run. Der Bildschirm soll zwei Zeilen zeigen: 3 dann 2. Eine Liste wächst mit Add. Ein Index liest einen gespeicherten Wert. Count sagt, wie viele Werte in der Liste sind. Behalte den öffentlichen Startklassennamen Pine.

Eine wachsende Folge

Auf der using-Seite hast du eine Box mit einem size gebaut. Hier speicherst du mehrere int-Werte in einer List. Die Liste startet leer. Jedes Add hängt am Ende an. Der erste Wert sitzt am Index 0. Die Anzahl ist Count, kein Feld, das du selbst erfindest. Denk an die Liste als Beutel: du wirfst Zahlen hinein und fragst dann, was im ersten Slot liegt und wie oft du geworfen hast.
Öffne die Pine-Datei. Der Startklassenname bleibt Pine. Diese Seite benennt den Starter nicht um. Lösche Reste Box b = new Box(4);, wenn das in Main noch die ganze Demo ist. Lösche Reste namespace Pack / Box. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Tippen. Ein sauberes Main macht die zwei Bildschirmzeilen vertrauenswürdig.
Oben behältst du using System;. Füge using System.Collections.Generic; hinzu. In Main schreibst du List<int> bag = new List<int>();. Dann bag.Add(3);. Dann schreibst du Console.WriteLine(bag[0]); als ersten Check. Speichere vor dem Lauf und erweitere dann auf zwei Adds und Count als behaltene Demo. Der Ein-Add-Lauf ist nur ein Checkpoint; die behaltene Antwort der Seite bleibt 3 dann 2.
List braucht auf dieser Seite das generische Argument <int>, damit jeder Slot ein int hält. Schreibe in der Lehrdatei kein bloßes List bag ohne Typargument. Die spitzen Klammern gehören zum Typnamen, den du im Editor tippst.

List one Add

csharp
using System;
using System.Collections.Generic;

public class Pine
{
    public static void Main()
    {
        List<int> bag = new List<int>();
        bag.Add(3);
        Console.WriteLine(bag[0]);
    }
}

Pine addiert zweimal und schreibt Count

In Main schreibst du nach der leeren Liste bag.Add(3); dann bag.Add(8);. Schreibe zuerst bag[0], damit der Bildschirm den ersten Wert zeigt. Dann schreibe bag.Count, damit du siehst, wie viele Werte du gespeichert hast. Du schreibst auf dieser Seite kein Box b = new Box(4);. Das war die using-Lektion.

Pine two Adds and Count

csharp
using System;
using System.Collections.Generic;

public class Pine
{
    public static void Main()
    {
        List<int> bag = new List<int>();
        bag.Add(3);
        bag.Add(8);
        Console.WriteLine(bag[0]);
        Console.WriteLine(bag.Count);
    }
}

Lies die behaltene Datei von oben. using System; bereitet Konsolennamen vor. using System.Collections.Generic; bereitet List vor. public class Pine ist der Starter. public static void Main() ist der Einstieg zur Laufzeit. new List<int>() baut eine leere Liste. Das erste Add speichert 3 am Index 0. Das zweite Add speichert 8 am Index 1. Schreiben von bag[0] druckt 3. Schreiben von bag.Count druckt 2.
Starte mit dotnet run. Das Programm schreibt zwei Zeilen und stoppt. Es wartet nicht auf Tippen. Wenn dotnet run wartet, steckt noch ReadLine in der Datei. Lösche diese Zeile und behalte die Listenarbeit. Der Bildschirm zeigt 3 dann 2. Zeigt er 4, läuft vielleicht noch eine Box-Demo. Findet der Build List nicht, fehlt vielleicht using System.Collections.Generic; — setze es zurück.
Schreibst du bag[2] vor einem dritten Add, kann der Lauf werfen, weil der Index noch fehlt. Bleib beim Hauptdemo dieser Seite bei bag[0] und Count. Vergisst du beide Add-Aufrufe, ist Count 0 und bag[0] scheitert — füge zuerst die Werte hinzu.

Vergleich mit Box und fester Array-Gewohnheit

Auf der using-Seite hielt ein Objekt ein size. Eine Liste hält viele Werte unter einem Namen. Reste Box b = new Box(4); Console.WriteLine(b.size); sind eine andere Lektion. Für diese Seite behalte List<int> bag und die Add-Aufrufe. Beide Demos in einem Main zu mischen kann eine Boxgröße statt der Listenzeilen drucken — entferne die Box-Arbeit, während du List übst.
Arrays fixieren bei der Erstellung eine Länge. List wächst mit Add, ohne jedes Mal eine neue Größe zu deklarieren. Diese Seite ersetzt nicht jedes Array. Sie zeigt die wachsende Beutel-Form, die du auf der list-methods-Seite erweiterst. Bleib hier bei int-Werten, damit Index und Count auf dem Bildschirm leicht lesbar bleiben.

📊 Index vs Count

Ausdruck Bedeutung auf dieser Seite
bag[0] der Wert im ersten Slot
bag.Count wie viele Werte die Liste jetzt hält

Drei Adds teilen noch eine Liste

Du kannst einen dritten Wert Adden und einen anderen Index lesen. Schreibe bag.Add(3);, bag.Add(8);, bag.Add(5);, dann bag[1] und bag.Count. Der mittlere Wert ist 8. Die Anzahl wird 3.

Pine three Adds

csharp
using System;
using System.Collections.Generic;

public class Pine
{
    public static void Main()
    {
        List<int> bag = new List<int>();
        bag.Add(3);
        bag.Add(8);
        bag.Add(5);
        Console.WriteLine(bag[1]);
        Console.WriteLine(bag.Count);
    }
}

Starte erneut mit dotnet run. Der Bildschirm soll 8 dann 3 zeigen. Zeigt er noch 3 dann 2, bist du auf der Zwei-Add-Demo — der erste Checkpoint ist in Ordnung; nutze die Drei-Add-Datei für den zweiten Check. Wirft bag[1], fehlt vielleicht ein Add vor dem Schreiben.
List<int> other = bag; kopiert die Werte nicht in eine zweite Liste. Beide Namen teilen dasselbe Listenobjekt. Für diese Seite reichen ein bag und klare Add-Aufrufe.

Was diese Seite für list-methods lässt

Diese Seite baut eine Liste, fügt Werte hinzu, liest einen Index und liest Count. Eine spätere Seite — list-methods — zeigt mehr Listenaktionen wie Entfernen oder Suchen. Bleib hier bei Erstellen, Add, Index und Count. Erfinde nicht jede Listenmethode auf dieser Seite; das Lernziel ist der wachsende Beutel selbst. Wenn dotnet run aus der Zwei-Add-Datei 3 dann 2 druckt, hast du den Checkpoint dieser Seite.
Verschachtele kein zweites Main. Lass kein Pack / Box in der Datei. Findet der Build List nicht, prüfe using System.Collections.Generic;. Zeigt der Bildschirm nur eine Zeile, hast du vielleicht die zweite WriteLine vergessen — behalte beide bag[0] und bag.Count auf der Zwei-Add-Demo. Zeigt er 8 dann 3, bist du auf der Drei-Add-Datei; das ist für den zweiten Check in Ordnung, kehre dann zur Zwei-Add-Form zurück, wenn du die Quizantwort auf dem Bildschirm willst.

Du kannst List<int> bag = new List<int>(); schreiben, bag.Add(3); und bag.Add(8); aufrufen, dann bag[0] und bag.Count schreiben. Starte mit dotnet run. Der Bildschirm zeigt 3 dann 2. Die Liste wuchs. Der Index las den ersten Wert. Count meldete die Länge. Denk an List als Beutel, in den du Zahlen wirfst, ohne die Größe vorher festzulegen. Pine bleibt die Tür, die du mit dotnet run öffnest. Die nächste Seite ist list-methods, wo derselbe Beutel mehr Aktionen lernt.
Behalte using System.Collections.Generic;. Behalte <int> am Listentyp. Halte Rest-Box-Demos aus Main, damit der Bildschirm nicht versehentlich eine Boxgröße zeigt. Diese Gewohnheiten sind der Checkpoint vor dem Weitergehen.

🧠 Testen Sie Ihr Wissen

Bereit zum Start

Testen Sie Ihr Wissen

Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen

❓
5
Fragen
🎯
70%
Zum Bestehen
♾️
∞
Zeit
🔄
∞
Versuche

📝 Anweisungen

  • Lesen Sie jede Frage sorgfältig
  • Wählen Sie die beste Antwort für jede Frage
  • Sie können das Quiz so oft wiederholen, wie Sie möchten
  • Ihr Fortschritt wird oben angezeigt