Массивы в C#: объявление, Length, сортировка, двумерные и зубчатые массивы

Массив хранит фиксированное число элементов одного типа, расположенных в памяти подряд. Вы выбираете длину при создании, читаете и записываете элементы по индексу, начиная с нуля, и после этого длина никогда не меняется.

Объявление и инициализация массива

Тип массива это тип элемента, за которым следует []. Создать массив можно несколькими способами:

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");
    }
}

Вывод:

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

new int[4] заполняет каждый элемент значением по умолчанию для типа: 0 для чисел, false для bool, null для строк и других ссылочных типов. Короткая форма { "Ana", "Ben" } работает только в объявлении; при присваивании существующей переменной нужно names = new[] { "Dev", "Eli" };.

Length, индексация и последний элемент

Индексы идут от 0 до Length - 1. Length это свойство, поэтому у него нет скобок (в отличие от метода LINQ Count()).

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);
        }
    }
}

Вывод:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Чтение или запись за границами выбрасывает IndexOutOfRangeException во время выполнения; компилятор это не ловит. Обычная причина это условие цикла, записанное как i <= arr.Length вместо i < arr.Length.

C# 8 и новее добавляют синтаксис индекса с конца и диапазонов, который короче для последнего элемента и для срезов:

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

Обход массива

Цикл for даёт индекс; foreach даёт каждый элемент и понятнее, когда вы только читаете.

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);
    }
}

Вывод:

4.95 | 13.20 | 3.58
Total: 21.73

Переменная foreach доступна только для чтения: p = 0; внутри цикла это ошибка компиляции. Чтобы менять элементы, используйте цикл с индексом.

Сортировка, переворот и поиск

Вспомогательные методы находятся в статическом классе Array. Array.Sort сортирует на месте и ничего не возвращает, поэтому исходный порядок теряется.

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));
    }
}

Вывод:

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 возвращает -1, если значения нет. Array.Find возвращает значение по умолчанию для типа (здесь 0), когда ничего не найдено, что для чисел неоднозначно; когда это важно, используйте Array.FindIndex. Сортировка по убыванию одним вызовом: Array.Sort(scores, (a, b) => b.CompareTo(a)).

Если нужен отсортированный результат без изменения оригинала, LINQ возвращает новый массив: var sorted = scores.OrderBy(s => s).ToArray();. См. LINQ.

Изменение размера: массив не может расти

Длина фиксирована. Array.Resize создаёт новый массив нужного размера, копирует элементы и обновляет переменную, переданную через 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));
    }
}

Вывод:

4
2
True
False

Каждое изменение размера копирует все элементы. Наращивание массива по одному элементу в цикле медленное, и именно это List<T> делает за вас эффективнее, удваивая свой внутренний массив.

Массивы это ссылочные типы: копирование

Присваивание массива другой переменной копирует ссылку, а не элементы. После этого оба имени указывают на один и тот же массив.

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));
    }
}

Вывод:

100
2
0, 100, 2, 3, 0

То же самое происходит, когда массив передаётся в метод: метод может изменить элементы вызывающего кода. Clone, Array.Copy, CopyTo и ToArray() из LINQ делают поверхностную копию. Для массива объектов новый массив хранит ссылки на те же объекты, поэтому изменение copy[0].Name всё равно меняет то, что видит original[0].

Сравнение массивов через == сравнивает ссылки. Чтобы сравнить содержимое, используйте a.SequenceEqual(b) из System.Linq.

Двумерные массивы (многомерные)

Прямоугольная сетка объявляется с запятой внутри квадратных скобок. Индексируйте её через [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();
        }
    }
}

Вывод:

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

Length у двумерного массива это общее число элементов (6 для сетки 2 на 3), поэтому вложенные циклы используют GetLength(0) и GetLength(1). Rank это число измерений. Три измерения работают так же: new int[4, 4, 4] и cube[x, y, z]. foreach по двумерному массиву посещает каждый элемент строка за строкой.

Зубчатые массивы (массивы массивов)

Зубчатый массив int[][] это массив, элементы которого сами являются массивами, и у каждого внутреннего массива может быть своя длина. Он подходит для данных вроде «заказы каждого клиента», где строки разного размера.

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);
    }
}

Вывод:

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

new int[3][] создаёт только внешний массив; каждая строка сначала равна null, и обращение к orders[0][0] до присваивания строки выбрасывает NullReferenceException. Синтаксис new int[3][4] недопустим; каждую строку вы создаёте сами.

Используйте [,] для настоящей сетки (доска, матрица, пиксели) и [][], когда строки разной длины или нужно менять местами целые строки.

Массив или List

Преобразование в любую сторону это один вызов: new List<int>(arr) или arr.ToList(), а также list.ToArray(). List<T> это растущая версия массива.

Частые ошибки

• i <= arr.Length в цикле. Последний допустимый индекс Length - 1; такое условие выбрасывает IndexOutOfRangeException.
• Вывод массива напрямую. Console.WriteLine(arr) печатает System.Int32[]; используйте string.Join.
• Ожидание, что Array.Sort вернёт отсортированный массив. Он возвращает void и сортирует на месте.
• Копирование через =. Так копируется ссылка; используйте Clone() или ToArray().
• Использование строк зубчатого массива до их создания. Каждая строка new T[n][] равна null, пока ей не присвоят значение.
• Length для числа строк двумерного массива. Он считает все элементы; используйте GetLength(0).