Energy
education

сайт для тех, кто хочет изучать энергетику

13. Массивы

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

Вместо определения каждой переменной, таких как number0, number1, ..., и number99, можно определить один массив переменных такой как numbers и использовать numbers[0], numbers[1], и ..., numbers[99] для работы с одной переменной. Необходимую переменную можно найти по ее индексу.

Все массивы содержаться в смежных ячейках памяти. Самый меньший адрес соответствует первому элементу и наибольший адрес последнему элементу.

Arrays in C#

Определение массивов

Определение массива в C#, следующее

    
datatype[] arrayName;
    

где,

  • datatype используется для определения типа данных елементов массива.
  • [ ] определяет ранг массива. Ранг определяется размером массива.
  • arrayName определяет имя массива.

Например,

    
double[] balance;
    

Инициализация массива

Определение массива не инициализирует массив в памяти. Когда переменная массива инициализируется, вы можете добавлять данные в массив.

Массив это ссылочный тип, поэтому вы должны использовать ключевое слово new для создания экземпляра массива.

Например,

    
double[] balance = new double[10];
    

Присвоение значений массиву

Вы можете присваивать значения индивидуальным элементам массива, используя их порядковый номер:

    
double[] balance = new double[10];
balance[0] = 4500.0;
    

Вы можете присваивать значения массиву во время его определения:

    
double[] balance = { 2340.0, 4523.69, 3421.0};
    

Вы также можете создать и инициализировать массив:

    
int [] marks = new int[5]  { 99,  98, 92, 97, 95};
    

В предидущем случае, вы можете также не задавать размер массива:

    
int [] marks = new int[]  { 99,  98, 92, 97, 95};
    

Вы также можете скопировать переменную массива в другую переменную массива. В этом случае, обе переменные будут ссылаться на одну область памяти:

    
int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;
    

Когда вы создаете массив, компилятор C# инициализирует каждый элемент массива и присваивает ему значение по умочанию типа значений массива. Например для массива типа int всем элементам будет присвоено значение 0.

Доступ к элементам массива

Элемент доступен по индексу имени массива. Для этого поместите индекс в квадратные скобки после имени массива. Например:

    
double salary = balance[9];
    

Следующий пример показывает использование массивов:

    
using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n массив 10 целых чисел */
         int i,j;
         /* инициализация элементов масива n */         
         for ( i = 0; i < 10; i++ )
         {
            n[ i ] = i + 100;
         }
         /* вывод значений каждого элемена массива */
         for (j = 0; j < 10; j++ )
         {
            Console.WriteLine("Элемент[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
Элемент[0] = 100
Элемент[1] = 101
Элемент[2] = 102
Элемент[3] = 103
Элемент[4] = 104
Элемент[5] = 105
Элемент[6] = 106
Элемент[7] = 107
Элемент[8] = 108
Элемент[9] = 109
    

Испльзование цикла foreach

В предидущем примере, был использован цикл for для доступа к каждому элементу массива. Вы также можете использовать оператор foreach для перебора элементов массива.

    
using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n массив 10 целых чисел */
         /* инициализация элементов масива n */         
         for ( int i = 0; i < 10; i++ )
         {
            n[i] = i + 100;
         }
            int i = 0;
         /* вывод значений каждого элемена массива */
         foreach (int j in n )
         {
            Console.WriteLine("Элемент[{0}] = {1}", i, j);
            i++;
         }
         Console.ReadKey();
      }
   }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
Элемент[0] = 100
Элемент[1] = 101
Элемент[2] = 102
Элемент[3] = 103
Элемент[4] = 104
Элемент[5] = 105
Элемент[6] = 106
Элемент[7] = 107
Элемент[8] = 108
Элемент[9] = 109
    

Массивы в деталях

Существуют несколько важных понятий, связанных с массивами которые должны быть понятны для программиста C#:

ПонятиеОписание
Многомерные массивыC# поддерживает многомерные массивы. Самый простой из многомерных массивов двумерный массив.
Массив массивовC# поддерживает многомерные массивы, тиапа массив массивов.
Передача массивов в методыВозможно передавать в метод указатель на массив указав имя массива без индекса.
Массивы paramЭто используется для передачи неизвестного числа параметров в метод.
Класс ArrayОпределен в пространстве имен System, это базовый класс для всех массивов, и содержит различные свойства и методы для работы с массивами.

Многомерные массивы

C# поддерживает многомерные массивы. Многомерные массивы также называются прямоугольными массивами.

Вы можете определить двухмерный массив строк следующим образом:

    
string [,] names;
    

или, трехмерный массив целых чисел:

    
int [ , , ] m;
    

Двухмерные массивы:

Самый простой из многомерных массивов двумерный массив. Двумерный массив это список одномерных массивов.

Двумерный массив может быть рассмотрен как таблица, которая будет иметь х строк и y столбцов. Ниже приведен двухмерный массив, который состоит из трех строк и четырех столбцов:

Two Dimensional Arrays in C#

Таким образом, каждый элемент в массиве идентифицируется именем элемента a[ i , j ], где a это имя массива, а i и j являются индексами, которые уникально идентифицируют каждый элемент a.

Инициализация двухмерных массивов

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

    
int [,] a = int [3,4] = {  
 {0, 1, 2, 3} ,   /*  инициализация для строки с индексом 0 */
 {4, 5, 6, 7} ,   /*  инициализация для строки с индексом 1 */
 {8, 9, 10, 11}   /*  инициализация для строки с индексом 2 */
};
    

Доступ к элементам двухмерного массива

Элемент в двухмерном массиве доступен с помощью индексов т.е. индекса строки и индекса столбца массива. Например:

    
int val = a[2,3];
    

Данный оператор берет четвертый элемент из третьего ряда массива. Ниже показано использование вложенного цикла для обработки двумерного массива:

    
using System;
namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* массив с пятью строками и двумя столбцами */
            int[,] a = new int[5, 2] { {0,0}, {1,2}, {2,4}, {3,6}, {4,8} };
            int i, j;
            /* вывод значения каждого элемента массива */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);
                }
            }
           Console.ReadKey();
        }
    }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
a[0,0]: 0
a[0,1]: 0
a[1,0]: 1
a[1,1]: 2
a[2,0]: 2
a[2,1]: 4
a[3,0]: 3
a[3,1]: 6
a[4,0]: 4
a[4,1]: 8
    

Массив массивов

Вы можете определить массив массивов целых чисел так:

    
int [][] scores;
    

Определение массива не выделяет под него память. Для этого необходимо определить его вложенные массивы:

    
int[][] scores = new int[5][];
for (int i = 0; i < scores.Length; x++) 
{
   scores[i] = new int[4];
}
    

Вы можете инициализировать массив массивов так:

    
int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};
    

Где scores это массив двух массивов целых чисел - scores[0] это массив трех целых чисел и scores[1] это массив четырех целых чисел.

Пример

Следующий пример илюстрирует использование массива массивов:

    
using System;
namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* Массив массивов содержащий пять массивов целых чисел */
            int[][] a = new int[][]{new int[]{0,0},new int[]{1,2}, 
            new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } }; 
            int i, j;
            /* вывод значения каждого элемента массива */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j <; 2; j++)
                {
                    Console.WriteLine("a[{0}][{1}] = {2}", i, j, a[i][j]);
                }
            }
           Console.ReadKey();
        }
    }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8
    

Передача массивов в методы

Вы можете передавать массив в качестве параметра метода в C#. Следующий пример демонстрирует это:

    
using System;
namespace ArrayApplication
{
   class MyArray
   {
      double getAverage(int[] arr, int size)
      {
         int i;
         double avg;
         int sum = 0;
         for (i = 0; i < size; ++i)
         {
            sum += arr[i];
         }
         avg = (double)sum / size;
         return avg;
      }
      static void Main(string[] args)
      {
         MyArray app = new MyArray();
         /* массив целых чисел с пятью элементами */
         int [] balance = new int[]{1000, 2, 3, 17, 50};
         double avg;
         /* указатель массива в качестве аргумента */
         avg = app.getAverage(balance, 5 ) ;
         /* вывод возвращаемого значения */
         Console.WriteLine( "Среднее значение: {0} ", avg );
         Console.ReadKey();
      }
   }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
Среднее значение: 214.4
    

Массивы Param

Время от времени, при объявлении метода вы не уверены сколько аргументов нужно передать в качестве параметров. В С# массивы Param (или массивы параметров) могут помочь в этих случаях.

Следующий пример демонстрирует это:

    
using System;
namespace ArrayApplication
{
   class ParamArray
   {
      public int AddElements(params int[] arr)
      {
         int sum = 0;
         foreach (int i in arr)
         {
            sum += i;
         }
         return sum;
      }
   }
      
   class TestClass
   {
      static void Main(string[] args)
      {
         ParamArray app = new ParamArray();
         int sum = app.AddElements(512, 720, 250, 567, 889);
         Console.WriteLine("Сумма: {0}", sum);
         Console.ReadKey();
      }
   }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
Сумма: 2938
    

Класс Array

Класс Array это базовый класс для всех массивов в C#. Он определен в пространстве имен System. Класс Array содержит различные свойства и методы для работы с массивами.

Свойства класса Array

Следующая таблица показывает некоторые наиболее часто используемые свойства класса Array:

НомерИмя и описание свойства
1IsFixedSize
Получает значение, указывающее, является ли массив массивом фиксированного размера.
2IsReadOnly
Получает значение, указывающее, является ли массив массивом только для чтения.
3Length
Получает 32-разрядное целое число, представляющее общее число элементов во всех измерений массива.
4LongLength
Получает 64-разрядное целое число, представляющее общее число элементов во всех измерениях массива.
5Rank
Возвращает ранг (число измерений) массива.

Методы класса Array

Следующая таблица показывает некоторые наиболее часто используемые методы класса Array:

НомерИмя и описание метода
1Clear
Устанавливает значение элементов массива равным нулю или лжи в зависимости от типа элемента.
2Copy(Array, Array, Int32)
Копирует диапазон элементов из массива, начиная с первого элемента и вставляет его в другой массив, начиная с первого элемента. Длина задается в виде 32-разрядного целого числа.
3CopyTo(Array, Int32)
Копирует все элементы текущего одномерного массива в заданный одномерный массив, начиная с указанного индекса массива назначения. Индекс определен как 32-разрядное целое число.
4GetLength
Получает 32-разрядное целое число, представляющее число элементов в указанном измерении массива.
5GetLongLength
Получает 64-разрядное целое число, представляющее число элементов в указанном измерении массива.
6GetLowerBound
Возвращает нижнюю границу заданного измерения в массиве.
7GetType
Возвращает тип текущего экземпляра. (Наследуется от Object.)
8GetUpperBound
Возвращает верхнюю границу указанного измерения массива.
9GetValue(Int32)
Получает значение в указанной позиции в одномерном массиве. Индекс определен как 32-разрядное целое число.
10IndexOf(Array, Object)
Осуществляет поиск указанного объекта и возвращает индекс первого вхождения в одномерный массив.
11Reverse(Array)
Изменяет последовательность элементов во всем одномерном массиве.
12SetValue(Object, Int32)
Устанавливает значение элементу в заданной позиции в одномерном массиве. Индекс определен как 32-разрядное целое число.
13Sort(Array)
Сортирует элементы в одномерном массиве с помощью IComparable.
14ToStringk
Возвращает строку, которая представляет текущий объект. (Наследуется от Object.)

Для получения полного списка свойств и методов класса Array, пожалуйста обратитесь к документации по C#.

Пример

Следующая программа демонстрирует использование некоторых методов класса Array:

    
using System;
namespace ArrayApplication
{
    class MyArray
    {
        
        static void Main(string[] args)
        {
            int[] list = { 34, 72, 13, 44, 25, 30, 10 };
            int[] temp = list;
            Console.Write("Оригинальный массив: ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           
            // обратный массив
            Array.Reverse(temp);
            Console.Write("Обратный массив: ");
            foreach (int i in temp)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            
            // сортированный массив
            Array.Sort(list);
            Console.Write("Сортированный массив: ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           Console.ReadKey();
        }
    }
}
    

Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:

    
Оригинальный массив: 34 72 13 44 25 30 10
Обратный массив: 10 30 25 44 13 72 34
Сортированный массив: 10 13 25 30 34 44 72