Docs executáveis de C#: Arrays

Q: Como obter o tamanho de um array em C#?

Use a propriedade Length: scores.Length. É uma propriedade, não um método, então não leva parênteses. Para um array 2D, Length é o número total de elementos; use GetLength(0) para o número de linhas e GetLength(1) para o número de colunas.

Q: Como ordenar um array em C#?

Array.Sort(arr) ordena o próprio array em ordem crescente. Para ordem decrescente, chame Array.Reverse(arr) depois de ordenar, ou passe uma comparação: Array.Sort(arr, (a, b) => b.CompareTo(a)). Para obter uma cópia ordenada e manter o original, use LINQ: arr.OrderBy(x => x).ToArray().

Q: Qual a diferença entre um array 2D e um array jagged em C#?

Um array 2D int[,] é um único bloco retangular: toda linha tem o mesmo número de colunas, e você o indexa como grid[row, col]. Um array jagged int[][] é um array de arrays: cada linha é um array separado que pode ter o próprio tamanho, e você o indexa como rows[i][j]. Cada linha de um array jagged precisa ser criada antes do uso, senão é null.

Q: Dá para mudar o tamanho de um array em C#?

Não. O tamanho de um array é fixado na criação. Array.Resize(ref arr, newSize) parece redimensionar, mas aloca um array novo, copia os elementos e faz sua variável apontar para o novo. Se o tamanho muda com frequência, use uma List .

Q: Por que imprimir um array mostra System.Int32[]?

Console.WriteLine(arr) chama arr.ToString(), e arrays não o sobrescrevem, então você recebe o nome do tipo. Junte os elementos em uma única string: Console.WriteLine(string.Join(", ", arr)).

Um array guarda um número fixo de elementos de um só tipo, armazenados lado a lado na memória. Você escolhe o tamanho ao criá-lo, lê e escreve elementos por um índice que começa em zero, e o tamanho nunca muda depois disso.

Declarando e inicializando um array

O tipo de um array é o tipo do elemento seguido de []. Há várias formas de criar um:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Saída:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] preenche cada elemento com o valor padrão do tipo: 0 para números, false para bool, null para strings e outros tipos de referência. A forma curta { "Ana", "Ben" } só funciona em uma declaração; ao atribuir a uma variável que já existe, você precisa de names = new[] { "Dev", "Eli" };.

Length, índices e o último elemento

Os índices vão de 0 a Length - 1. Length é uma propriedade, então não leva parênteses (ao contrário do método Count() do LINQ).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Saída:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Ler ou escrever fora dos limites lança IndexOutOfRangeException em tempo de execução; o compilador não pega isso. A causa comum é uma condição de laço escrita como i <= arr.Length em vez de i < arr.Length.

O C# 8 em diante adiciona a sintaxe de índice a partir do fim e de intervalos, que é mais curta para o último elemento e para fatias:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Percorrendo um array

Um laço for dá o índice; foreach dá cada elemento e é a escolha mais clara quando você só lê.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Saída:

4.95 | 13.20 | 3.58
Total: 21.73

A variável do foreach é somente leitura: p = 0; dentro do laço é um erro de compilação. Para mudar elementos, percorra com índice.

Ordenando, invertendo e buscando

A classe static Array reúne os auxiliares. Array.Sort ordena no próprio array e não retorna nada, então a ordem original se perde.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Saída:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf retorna -1 quando o valor não existe. Array.Find retorna o valor padrão do tipo (0 aqui) quando nada corresponde, o que é ambíguo para números; use Array.FindIndex quando isso importar. Uma ordenação decrescente em uma só chamada é Array.Sort(scores, (a, b) => b.CompareTo(a)).

Se você precisa do resultado ordenado sem mexer no original, o LINQ retorna um array novo: var sorted = scores.OrderBy(s => s).ToArray();. Veja LINQ.

Redimensionando: um array não cresce

O tamanho é fixo. Array.Resize cria um array novo do tamanho pedido, copia os elementos e atualiza a variável que você passa por ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Saída:

4
2
True
False

Cada redimensionamento copia todos os elementos. Aumentar um array um item por vez em um laço é lento, e é exatamente o que a List<T> faz por você de forma mais eficiente, dobrando o array interno.

Arrays são tipos de referência: copiando

Atribuir um array a outra variável copia a referência, não os elementos. Os dois nomes passam a apontar para o mesmo array.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Saída:

100
2
0, 100, 2, 3, 0

O mesmo vale quando você passa um array para um método: o método pode mudar os elementos de quem chamou. Clone, Array.Copy, CopyTo e o ToArray() do LINQ fazem todos uma cópia rasa. Em um array de objetos, o array novo guarda referências para os mesmos objetos, então mudar copy[0].Name ainda muda o que original[0] vê.

Comparar arrays com == compara referências. Para comparar o conteúdo, use a.SequenceEqual(b) de System.Linq.

Arrays 2D (multidimensionais)

Uma grade retangular é declarada com uma vírgula dentro dos colchetes. Indexe-a com [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

        int[,] grid =
        {
            { 1, 2, 3 },
            { 4, 5, 6 },
        };

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Saída:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X

Length em um array 2D é o número total de elementos (6 em uma grade de 2 por 3), e é por isso que laços aninhados usam GetLength(0) e GetLength(1). Rank é o número de dimensões. Três dimensões funcionam do mesmo jeito: new int[4, 4, 4] e cube[x, y, z]. Um foreach sobre um array 2D visita todos os elementos linha por linha.

Arrays jagged (arrays de arrays)

Um array jagged int[][] é um array cujos elementos são arrays, e cada array interno pode ter o próprio tamanho. Ele combina com dados como "pedidos por cliente", em que as linhas têm tamanhos diferentes.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Saída:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] cria só o array externo; cada linha começa como null, e orders[0][0] antes de atribuir uma linha lança NullReferenceException. A sintaxe new int[3][4] não é permitida; você cria cada linha.

Use [,] para uma grade de verdade (um tabuleiro, uma matriz, pixels) e [][] quando as linhas têm tamanhos diferentes ou você quer trocar linhas inteiras.

Array vs List

	Array `T[]`	`List<T>`
Tamanho	Fixo na criação	Cresce e diminui
Contagem	Propriedade `Length`	Propriedade `Count`
Adicionar ou remover	Não é possível (só `Array.Resize`)	`Add`, `Insert`, `Remove`
Multidimensional	`[,]` e `[][]`	Só listas de listas
Uso típico	Tamanho conhecido, tabelas de consulta, buffers	Coleções que mudam

Converter é uma chamada em qualquer direção: new List<int>(arr) ou arr.ToList(), e list.ToArray(). A List<T> é a versão que cresce.

Erros comuns

i <= arr.Length em um laço. O último índice válido é Length - 1; isso lança IndexOutOfRangeException.
Imprimir o array diretamente. Console.WriteLine(arr) imprime System.Int32[]; use string.Join.
Esperar que Array.Sort retorne o array ordenado. Ele retorna void e ordena no próprio array.
Copiar com =. Isso copia a referência; use Clone() ou ToArray().
Usar linhas jagged antes de criá-las. Cada linha de new T[n][] é null até ser atribuída.
Usar Length para as linhas de um array 2D. Ele conta todos os elementos; use GetLength(0).

Perguntas frequentes

Como obter o tamanho de um array em C#?

Use a propriedade Length: scores.Length. É uma propriedade, não um método, então não leva parênteses. Para um array 2D, Length é o número total de elementos; use GetLength(0) para o número de linhas e GetLength(1) para o número de colunas.

Como ordenar um array em C#?

Array.Sort(arr) ordena o próprio array em ordem crescente. Para ordem decrescente, chame Array.Reverse(arr) depois de ordenar, ou passe uma comparação: Array.Sort(arr, (a, b) => b.CompareTo(a)). Para obter uma cópia ordenada e manter o original, use LINQ: arr.OrderBy(x => x).ToArray().

Qual a diferença entre um array 2D e um array jagged em C#?

Um array 2D int[,] é um único bloco retangular: toda linha tem o mesmo número de colunas, e você o indexa como grid[row, col]. Um array jagged int[][] é um array de arrays: cada linha é um array separado que pode ter o próprio tamanho, e você o indexa como rows[i][j]. Cada linha de um array jagged precisa ser criada antes do uso, senão é null.

Dá para mudar o tamanho de um array em C#?

Não. O tamanho de um array é fixado na criação. Array.Resize(ref arr, newSize) parece redimensionar, mas aloca um array novo, copia os elementos e faz sua variável apontar para o novo. Se o tamanho muda com frequência, use uma List<T>.

Por que imprimir um array mostra System.Int32[]?

Console.WriteLine(arr) chama arr.ToString(), e arrays não o sobrescrevem, então você recebe o nome do tipo. Junte os elementos em uma única string: Console.WriteLine(string.Join(", ", arr)).

Devo usar um array ou uma List em C#?

Use um array quando o número de elementos é conhecido e fixo, como os 12 meses ou um tabuleiro de jogo. Use List<T> quando elementos são adicionados ou removidos ao longo do tempo. Os dois acessam por índice em tempo constante, e uma List<T> guarda os elementos em um array internamente.

Conceitos relacionados