Одномерные массивы

Одномерный массив - набор элементов одного типа, тип элементов стандартный или определен в разрабатываемой программе.

double[] a;

a=new double[3];

Тип может быть любой, например строковый:

string[] w;

w=new string[]{“ МОСКВА ”, “ МАРСЕЛЬ ”, “ РИМ ”};

w =>

string s=“”; // пустая строка

s=s+w[0][0]+w[2][1]+w[1][2]; // s => МИР

Тип массива определен как класс Array (т.е. ссылочный тип) в пространстве имен System.

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

Дополнительные возможности определяются полями и методами.

Для массива определено поле объекта – Length, определяющее количество элементов в массиве.

Статические методы:

- Sort

- Reverse

Метод Copy выполняет копирование элементов из массива оригинала в массив копию. Метод Sort сортирует заданную часть массива по возрастанию значения элементов. Метод Reverse выполняет переворот заданной части массива.

int [] a , b ; //массивы a и b

a=new int[]{10,20,30,40};

b=new int[a.Length]; // 2- ой массив той же длины

Array.Copy (a, 1, b, 0, 2); // копирование

Array.Sort (b, 0, b.Length); // отсортировали все элементы из b

Array.Reverse (b, 1, 2);

// Массив a:                             10 20 30 40

//Массив b после копирования: 20 30 0 0

//Массив b после сортировки:    0 0 20 30

//Массив b после переворота:    0 20 0 30

Динамические массивы

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

Альтернативой массиву в этом случае является динамический массив. Динамический массив определен как класс ArrayList в пространстве имен System . Collections.

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

Поле объекта: Count – количество элементов в массиве

Методы объекта для добавления элементов в массив:

Add (значение) // добавление элемента в конец массива

AddRange (массив) // добавление массива в конец массива

Insert (номер позиции, значение) //добавление элемента в заданную позицию

InsertRange (номер позиции, массив) // добавление массива с заданной позиции

Методы объекта для удаления элементов из массива:

Remove (значение)

RemoveAt (номер позиции)

RemoveRange (номер позиции, количествово элементов)

Clear () // удаление всех элементов

Пример:

ArrayList_a;

int[] b,c;

b=new int[]{10, 20};

c=new int[100];

a=new ArrayList();                                   a         Count

                                                                     пусто   0

a . Add (5);                                                        5         1

a . Insert (0,77); // в позицию 0 значение 77         77 5     2

a.AddRange(b);                                         77 5 10 20 4

a.CopyTo(1,c,0,3);                                                 4

a.InsertRange(0,b);                          10 20 77 5 10 20 6

a.Remove(20);                                    10 77 5 10 20 5

a.RemoveAt(3);                                  10 77 5 20    4

a.RemoveRange(1,2);                               10 20          2

a.Clear();                                                        пусто   0

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

Выбор, каким массивом пользоваться, зависит от ситуации. Обычный массив структурно проще, доступ к элементу быстрее, методов больше.

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

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

динамический массив(a) → обычный массив(b)

a . CopyTo ( позиция в дин.мас-ве ,обычный массив , позиция в об.мас-ве , кол-во элементов )

обычный массив(b) → динамический массив(a)

a . AddRange ( b ) //добавление обычного массива в пустой динамический

Строки

Понятие строки и операции со строками были рассмотрены ранее. Остановимся на дополнительных возможностях, которые предоставляются методами класса string .

Поле объекта: Length

Методы объекта:

сравнение строк на предмет больше-меньше

ИмяСтроки.CompareTo (строка, с которой сравниваем)

Сравнение выполняется лексикографичекси (по алфавиту), метод возвращает целое число:

-1, если строка < той, с которой сравниваем

 0, если строка = той, с которой сравниваем

+1, если строка > той, с которой сравниваем

поиск подстроки

позиция key в вызываемой строке, начиная с заданной позиции

                             IndexOf – первое вхождение key

                             LastIndexOf – последнее вхождение key

Возвращает -1, если key отсутствует

Замена в вызывающей строке всех подстрок s1 на новую подстроку s2.

Вставка в вызывающую строку строки s1 с заданной позиции.

Удаление в строке заданного количества символов, начиная с заданной позиции.

Разбиение вызывающей строки на слова. Возможные разделители между словами указываются в массиве символов.

Если несколько разделителей идут подряд, первый из них считается разделителем, а на месте остальных формируется пустая строка.

Формирование строки путем соединения строк, указанных в массиве. Слова в объединенной строке разделяются строкой-разделителем.

Метод Join - статический

string s 1=”око , за”;

string[] word;

char[] sep; // массив разделителей

sep = new char[]{‘ ’, ‘,’};

s1=s1.Insert(8, “_ око ”);

s1=s1.Replace(“ око ”, “ зуб ”);

word=s1.Split(sep);

s1=string.Join (“>”, word);

Динамические строки

Тип динамической строки определен как класс – StringBuilder, пространство имен System . Text.

Создание динамической строки

StringBuilder ИмяСтроки;

ИмяСтроки= new StringBuilder ();

Отличия от обычной строки:

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

2. В операциях ==, !=, = участвуют не элементы строки, а адреса (аналогично массиву).

Поле объекта: Length

Методы:

ИмяСтроки.Append (символ) //добавление символа в конец строки

ИмяСтроки.Append (символ, кол-во) //добавление заданного количества символов в конец строки

ИмяСтроки.Remove (номер позиции, кол-во символов) //удаление заданного кол-ва символов с заданной позиции

По сравнению со строками динамические строки имеют меньший набор методов, поэтому при решении задач используется комбинация строк и динамических строк, что порождает проблему их преобразования.

Схема выполнения преобразований:

string s => char [] a

     s.ToCharArray;

char[] a => string s

     s=new_string(a);

string s => StringBuilder b

     b=new_ StringBuilder(s);

StringBuilder b => string s

     s=b.ToString();

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

Предназначены для хранения данных, организованных в виде прямоугольной таблицы (матрицы). Таблица имеет определенное количество строк и столбцов, которые нумеруются, начиная с нуля.

Обработка массива производится поэлементно. Для доступа к элементу матрицы необходимо указать номер строки и столбца, на пересечении которых находится этот элемент.

Объявление двумерного массива:

Тип элементов [,] ИмяМассива;

ИмяМассива= new Тип элементов [кол-во строк, кол-во столбцов];

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

int[,] a, b;                                    a              b

a=new int[3,2];

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

Свойство Length применительно к двумерному массиву соответствует общему количеству элементов: b.Length => 6

Пример:

Сформировать и выдать на экран целочисленную единичную матрицу размером m×n.

int [,] a ;

int i , j ; // номера строк и столбцов

string s ; // строка, формирующая символьное значение строки матрицы

int n=5;

a=new int [n,n];

for (i=0; i<n; i++)

a [i,i]=1;

for (i=0; i<n; i++)

{ s=””;

for (j=0; j<n; j++)

     s=s + a[i,j] + “_”;

Console.WriteLine (s);

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

Для двумерных массивов невозможно выделить в качестве отдельного семантического понятия строку. Следовательно, нет возможности применять стандартные методы обработки массивов применительно к строке.

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

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

Массив        

Строка          

Элементы            

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

Тип элементов [][] ИмяМассива;

//память под ссылки

ИмяМассива= new _ Тип элементов [кол-во строк][];

//память под каждую строку

ИмяМассива[№строки]= new _Тип[кол-во элементов в строке]

                                                             100

int[][] a;

a=new int[2][];

a[0]=new int[3];

a[1]=new int[2];                                      200

// инициализация

a[0]=new int[] {1, 2, 3};

a[1]=new int[] {5,6};

Свойство Length определено как для всего массива, так и для каждой строки отдельно:

a.Length => 2 (2 строки)

a[0].Length => 3 (3 элемента в строке)

Для каждой строки можно использовать методы обработки одномерных массивов. При поэлементной обработке массива для доступа к элементу необходимо указать номер строки и номер элемента внутри строки. Каждый номер указывается в своей паре скобок:

a[0][1]=88;

МЕТОДЫ

Определение метода

Метод определяет некоторую процедуру обработки данных. Выполнение объектно-ориентированной программы можно рассматривать как взаимодействие объектов путем передачи сообщений. Сообщение равносильно вызову метода. Т.е. выполнение программы можно рассматривать как взаимодействие методов с точки зрения двух аспектов:

- по управлению (вызов/возврат)

- по обмену данных

Определение метода может быть выполнено только в составе класса.

Определение метода должно содержать:

1. Имя метода

2. Доступ к данному методу со стороны других

3. Принадлежность методу конкретному объекту или классу

4. Параметры, которые принимаются методом для обработки и тип возвращаемого результата

5. Собственно процедуру обработки параметров

<модификаторы>_ТипВозвращаемогоОбъекта Имя (параметры)

{

<локальные переменные> + процедура

}