List<T> Konstruktory

Definicja

Przestrzeń nazw:

System.Collections.Generic

Zestaw:

System.Collections.dll

Inicjuje nowe wystąpienie klasy List<T>.

Przeciążenia

List<T>()	Inicjuje List<T> nowe wystąpienie klasy, która jest pusta i ma domyślną pojemność początkową.
List<T>(IEnumerable<T>)	Inicjuje List<T> nowe wystąpienie klasy zawierające elementy skopiowane z określonej kolekcji i ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów.
List<T>(Int32)	Inicjuje List<T> nowe wystąpienie klasy, która jest pusta i ma określoną początkową pojemność.

List<T>()

Źródło:

List.cs

Inicjuje List<T> nowe wystąpienie klasy, która jest pusta i ma domyślną pojemność początkową.

C#

public List ();

Przykłady

W poniższym przykładzie pokazano konstruktor bez parametrów List<T> klasy ogólnej. Konstruktor bez parametrów tworzy listę z domyślną pojemnością, jak pokazano, wyświetlając Capacity właściwość .

W przykładzie dodamy, wstawimy i usuniemy elementy, pokazując, jak zmienia się pojemność, gdy są używane te metody.

C#

List<string> dinosaurs = new List<string>();

Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

dinosaurs.Add("Tyrannosaurus");
dinosaurs.Add("Amargasaurus");
dinosaurs.Add("Mamenchisaurus");
dinosaurs.Add("Deinonychus");
dinosaurs.Add("Compsognathus");
Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count);

Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
    dinosaurs.Contains("Deinonychus"));

Console.WriteLine("\nInsert(2, \"Compsognathus\")");
dinosaurs.Insert(2, "Compsognathus");

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

// Shows accessing the list using the Item property.
Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

Console.WriteLine("\nRemove(\"Compsognathus\")");
dinosaurs.Remove("Compsognathus");

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

dinosaurs.TrimExcess();
Console.WriteLine("\nTrimExcess()");
Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count);

dinosaurs.Clear();
Console.WriteLine("\nClear()");
Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count);

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */

Uwagi

Pojemność obiektu List<T> to liczba elementów, które List<T> mogą być przechowywane. W miarę List<T>dodawania elementów do obiektu pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez przeniesienie tablicy wewnętrznej.

Jeśli można oszacować rozmiar kolekcji, użycie List<T>(Int32) konstruktora i określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiaru podczas dodawania elementów do klasy List<T>.

Pojemność można zmniejszyć przez wywołanie TrimExcess metody lub jawne Capacity ustawienie właściwości. Zmniejszenie pojemności powoduje cofnięcie przydziału pamięci i skopiowanie wszystkich elementów w obiekcie List<T>.

Ten konstruktor jest operacją O(1).

List<T>(IEnumerable<T>)

Źródło:

List.cs

Inicjuje List<T> nowe wystąpienie klasy zawierające elementy skopiowane z określonej kolekcji i ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów.

C#

public List (System.Collections.Generic.IEnumerable<T> collection);

Parametry

collection

IEnumerable<T>

Kolekcja, której elementy są kopiowane do nowej listy.

Wyjątki

ArgumentNullException

collection to null.

Przykłady

W poniższym przykładzie pokazano List<T> konstruktor i różne metody List<T> klasy, które działają na zakresach. Tablica ciągów jest tworzona i przekazywana do konstruktora, wypełniając listę elementami tablicy. Następnie zostanie wyświetlona Capacity właściwość , aby pokazać, że początkowa pojemność jest dokładnie tym, co jest wymagane do przechowywania elementów wejściowych.

C#

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        string[] input = { "Brachiosaurus",
                           "Amargasaurus",
                           "Mamenchisaurus" };

        List<string> dinosaurs = new List<string>(input);

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nAddRange(dinosaurs)");
        dinosaurs.AddRange(dinosaurs);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nRemoveRange(2, 2)");
        dinosaurs.RemoveRange(2, 2);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        input = new string[] { "Tyrannosaurus",
                               "Deinonychus",
                               "Velociraptor"};

        Console.WriteLine("\nInsertRange(3, input)");
        dinosaurs.InsertRange(3, input);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\noutput = dinosaurs.GetRange(2, 3).ToArray()");
        string[] output = dinosaurs.GetRange(2, 3).ToArray();

        Console.WriteLine();
        foreach( string dinosaur in output )
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Capacity: 3

Brachiosaurus
Amargasaurus
Mamenchisaurus

AddRange(dinosaurs)

Brachiosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Amargasaurus
Mamenchisaurus

RemoveRange(2, 2)

Brachiosaurus
Amargasaurus
Amargasaurus
Mamenchisaurus

InsertRange(3, input)

Brachiosaurus
Amargasaurus
Amargasaurus
Tyrannosaurus
Deinonychus
Velociraptor
Mamenchisaurus

output = dinosaurs.GetRange(2, 3).ToArray()

Amargasaurus
Tyrannosaurus
Deinonychus
 */

Uwagi

Elementy są kopiowane do elementu List<T> w tej samej kolejności, w której są odczytywane przez moduł wyliczający kolekcji.

Ten konstruktor jest operacją O(n), gdzie n jest liczbą elementów w .collection

Zobacz też

• IEnumerable<T>
• Capacity

List<T>(Int32)

Źródło:

List.cs

Inicjuje List<T> nowe wystąpienie klasy, która jest pusta i ma określoną początkową pojemność.

C#

public List (int capacity);

Parametry

capacity

Int32

Liczba elementów, które może początkowo przechowywać nowa lista.

Wyjątki

ArgumentOutOfRangeException

capacity wartość jest mniejsza niż 0.

Przykłady

W poniższym przykładzie List<T>(Int32) pokazano konstruktor. Tworzona List<T> jest liczba ciągów o pojemności 4, ponieważ ostateczny rozmiar listy wynosi dokładnie 4. Lista jest wypełniana czterema ciągami, a kopia tylko do odczytu jest tworzona AsReadOnly przy użyciu metody .

C#

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>(4);

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");

        Console.WriteLine();
        foreach(string s in dinosaurs)
        {
            Console.WriteLine(s);
        }

        Console.WriteLine("\nIList<string> roDinosaurs = dinosaurs.AsReadOnly()");
        IList<string> roDinosaurs = dinosaurs.AsReadOnly();

        Console.WriteLine("\nElements in the read-only IList:");
        foreach(string dinosaur in roDinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\ndinosaurs[2] = \"Coelophysis\"");
        dinosaurs[2] = "Coelophysis";

        Console.WriteLine("\nElements in the read-only IList:");
        foreach(string dinosaur in roDinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Capacity: 4

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

IList<string> roDinosaurs = dinosaurs.AsReadOnly()

Elements in the read-only IList:
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

dinosaurs[2] = "Coelophysis"

Elements in the read-only IList:
Tyrannosaurus
Amargasaurus
Coelophysis
Deinonychus
 */

Uwagi

Pojemność obiektu List<T> to liczba elementów, które List<T> mogą być przechowywane. W miarę List<T>dodawania elementów do obiektu pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez przeniesienie tablicy wewnętrznej.

Jeśli można oszacować rozmiar kolekcji, określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiaru podczas dodawania elementów do elementu List<T>.

Pojemność można zmniejszyć przez wywołanie TrimExcess metody lub jawne Capacity ustawienie właściwości. Zmniejszenie pojemności powoduje cofnięcie przydziału pamięci i skopiowanie wszystkich elementów w obiekcie List<T>.

Ten konstruktor jest operacją O(1).

Zobacz też

• Capacity