List<T> Construtores

Definição

Namespace:

System.Collections.Generic

Assembly:

System.Collections.dll

Inicializa uma nova instância da classe List<T>.

Sobrecargas

List<T>()	Inicializa uma nova instância da classe List<T> que está vazia e tem a capacidade inicial padrão.
List<T>(IEnumerable<T>)	Inicializa uma nova instância da classe List<T>, que contém os elementos copiados da coleção especificada e tem capacidade suficiente para acomodar o número de elementos copiados.
List<T>(Int32)	Inicializa uma nova instância da classe List<T> que está vazia e tem a capacidade inicial especificada.

List<T>()

Origem:

List.cs

Inicializa uma nova instância da classe List<T> que está vazia e tem a capacidade inicial padrão.

C#

public List ();

Exemplos

O exemplo a seguir demonstra o construtor sem parâmetros da List<T> classe genérica. O construtor sem parâmetros cria uma lista com a capacidade padrão, conforme demonstrado exibindo a Capacity propriedade .

O exemplo adiciona, insere e remove itens, mostrando como a capacidade muda conforme esses métodos são usados.

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
 */

Comentários

A capacidade de um List<T> é o número de elementos que o List<T> pode conter. À medida que os elementos são adicionados a um List<T>, a capacidade é automaticamente aumentada conforme exigido pela realocação da matriz interna.

Se o tamanho da coleção puder ser estimado, usar o List<T>(Int32) construtor e especificar a capacidade inicial eliminará a necessidade de executar várias operações de redimensionamento ao adicionar elementos ao List<T>.

A capacidade pode ser reduzida chamando o TrimExcess método ou definindo a Capacity propriedade explicitamente. Diminuir a capacidade realoca a memória e copia todos os elementos no List<T>.

Este construtor é uma operação O(1).

List<T>(IEnumerable<T>)

Origem:

List.cs

Inicializa uma nova instância da classe List<T>, que contém os elementos copiados da coleção especificada e tem capacidade suficiente para acomodar o número de elementos copiados.

C#

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

Parâmetros

collection

IEnumerable<T>

A coleção cujos elementos são copiados para a nova lista.

Exceções

ArgumentNullException

collection é null.

Exemplos

O exemplo a seguir demonstra o List<T> construtor e vários métodos da List<T> classe que atuam em intervalos. Uma matriz de cadeias de caracteres é criada e passada para o construtor, preenchendo a lista com os elementos da matriz. Em Capacity seguida, a propriedade é exibida para mostrar que a capacidade inicial é exatamente o que é necessário para manter os elementos de entrada.

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
 */

Comentários

Os elementos são copiados para o List<T> na mesma ordem em que são lidos pelo enumerador da coleção.

Esse construtor é uma operação O(n), em que n é o número de elementos em collection.

Confira também

• IEnumerable<T>
• Capacity

List<T>(Int32)

Origem:

List.cs

Inicializa uma nova instância da classe List<T> que está vazia e tem a capacidade inicial especificada.

C#

public List (int capacity);

Parâmetros

capacity

Int32

O número de elementos que a nova lista pode armazenar inicialmente.

Exceções

ArgumentOutOfRangeException

capacity é menor que 0.

Exemplos

O exemplo a seguir demonstra o List<T>(Int32) construtor . Um List<T> de cadeias de caracteres com uma capacidade de 4 é criado, pois o tamanho final da lista é conhecido por ser exatamente 4. A lista é preenchida com quatro cadeias de caracteres e uma cópia somente leitura é criada usando o AsReadOnly método .

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
 */

Comentários

A capacidade de um List<T> é o número de elementos que o List<T> pode conter. À medida que os elementos são adicionados a um List<T>, a capacidade é automaticamente aumentada conforme exigido pela realocação da matriz interna.

Se o tamanho da coleção puder ser estimado, especificar a capacidade inicial eliminará a necessidade de executar várias operações de redimensionamento ao adicionar elementos ao List<T>.

A capacidade pode ser reduzida chamando o TrimExcess método ou definindo a Capacity propriedade explicitamente. Diminuir a capacidade realoca a memória e copia todos os elementos no List<T>.

Este construtor é uma operação O(1).

Confira também

• Capacity