Initially,
Integer array: 1 2 3 4 5
Object array: 26 27 28 29 30
After copying the first two elements of the integer array to the Object array,
Integer array: 1 2 3 4 5
Object array: 1 2 28 29 30
After copying the last two elements of the Object array to the integer array,
Integerarray: 1 2 3 29 30
Objectarray: 1 2 28 29 30
*/
Рассмотрим пример, в котором массив генерируется случайным образом. Сформировать массив целых чисел X(N), N<100, элементами которого являются случайные числа в диапазоне [–20..20]. Найти максимальный элемент и его номер. Для генерации случайных чисел необходимо создать объект класса System.Random и в цикле при присвоении значения элементу массива использовать для этого объекта метод Next(), который возвращает целое число со знаком, которое больше или равно нулю и меньше, чем MaxValue. В нашем примере будем использовать метод Next(inta.intb), которые возвращает целевое число с диапазоне [a,b).
class Program
{
static void Main()
{
const int N = 100;
int n;
string buf;
do
{
Console.WriteLine("\nEnter n (1-" + N + "): ");
buf = Console.ReadLine();
n = Convert.ToInt32(buf);
}
while (n <= 0 || n > N);
sbyte[] A = new sbyte[n];
constintk= 20;// граница диапозона [-20,20]
sbyte max = -k-1, imax = -1;
Random r = new Random(); //
for (sbyte i=0; i<A.Length; i++)
{
A[i]=(sbyte)r.Next(-k,k+1); //генерируем массив случайных чисел
//в диапазоне [-k..k]
Console.WriteLine("A[{0}]={1}",i,A[i]);//вывод элемента массива на экран
if (A[i]>max) {max=A[i]; imax=i;}// поиск максисума
}
Console.WriteLine("\nmax=A[{0}]={1}" ,imax, max);
Array.Sort(A);
Console.WriteLine("Sorted array: ");
foreach (int a in A)
Console.WriteLine(a);
Console.ReadKey();
}
}
Если бы в задаче требовалось создать массив положительных чисел, то можно было бы воспользоваться методом NextBytes, который заполняет элементы указанного массива байтов случайными числами. Например,
Random rnd = new Random();
Byte[] b = new Byte[10];
rnd.NextBytes(b);
Console.WriteLine("The Random bytes are: ");
for (int i = 0; i < 10; i++) {
Console.Write(i);
Console.Write(":");
Console.WriteLine(b[i]);
}
Если вызывается метод класса Array, в качестве параметра которого требуется использовать предикат (например, методы Find, FindLast, FindAll), то надо знать, что в качестве предиката можно указать статический метод класса, обычно имеющий тип bool. Для примера рассмотрим метод FindAll. Он формирует новый массив из элементов заданного массива (указанного в качестве первого параметра метода), которые удовлетворяют предикату (указанному в качестве второго параметра метода). Если такие элементы не найдены, то создается пустой массив Array. Рассмотрим пример, в котором создается новый массива из элементов заданного массива, кратных двум. Для этого определим функцию f, которое проверяет целое число на четность. Именно ее имя будем использовать как второй параметр метода FindAll.
class Program
{
static bool f (int k)
{
if (k%2==0) return true;
return false;
}
static void Main()
{
int[] A = { 1, 2, 3, 4, 5, 6, 7 };
foreach (int a in A)
Console.Write("\t" + a);
Console.WriteLine();
int [] B = Array.FindAll(A, f);
foreach (int b in B)
Console.Write("\t" + b);
Console.WriteLine();
Console.ReadKey();
}
}
Результат работы программы:
1 2 3 4 5 6 7
2 4 6
Многомерный (прямоугольный) массив имеет более одной размерности. Чаще всего в программах используются двумерные массивы.
Простейшее описание двумерного массива имеет следующий вид:
тип [,] имя [инициализрующий_список];
Например, int [,]a,b;
В качестве инициирующего списка можно как и в случае с одномерным массивом использовать:
явный список констант, заключенный в инструктивные скобки, например,
int[,] c = {{1, 2, 3}, {4, 5, 6}};
конструкторы класса Array c помощью операции new, например
int[,] d = new int[2, 3];
int[,] e = new int[,] {{1, 2, 3}, {4, 5, 6}};
int[,]f=newint[2,3] {{1, 2, 3}, {4, 5, 6}};
Для обращения к элементу двумерного массива используется два индекса, например, с[i][j]. Для работы с двумерными массивами используется конструкция вложенных циклов.
Рассмотрим пример метода, выполняющего перемножение двух матриц
class Program
{
static int [,] MultMatr(int[,] A, int[,] B)
{
if (A.GetLength(1) != B.GetLength(0)) throw new Exception("Размерности матриц не равны");
int[,] C = new int[A.GetLength(0), B.GetLength(1)];
for (int i = 0; i < A.GetLength(0); i++)
for (int j = 0; j < B.GetLength(1); j++)
{
int s = 0;
for (int k = 0; k < A.GetLength(1); k++)
s += A[i, k] * B[k, j];
C[i, j] = s;
}
return C;
}//MultMatr
static void Main()
{
const int n1 = 2, m1 = 3, n2 = 3, m2 = 4;
int[,] a = new int[n1, m1] { { 1, 1, 1 }, { 2, 2, 2 } };
int[,] b = new int[n2, m2] { { 1, 2, 3, 4 }, { 1, 2, 3, 4 }, { 1, 2, 3, 4 } };
try
{
int[,] c =MultMatr(a, b);
for (int i = 0; i < c.GetLength(0); i++)
{
for (int j = 0; j < c.GetLength(1); j++) Console.Write("\t" + c[i, j]);
Console.WriteLine();
}
}
catch (Exception e) { Console.WriteLine(e.Message); }
Console.ReadKey();
}
}
Обратите внимание, что в циклах for индекс массива изменяется от нуля до значения, вычисляемого с помощью метода класса GetLength. Это предпочтительней, чем указывать в виде верхней границы константу, т.к. делает программу более надежной.
В ступенчатых массивах (массив массивов) количество элементов в разных строках может различаться. В памяти ступенчатый массив хранится иначе, чем прямоугольный: в виде нескольких внутренних массивов, каждый из которых имеет свой размер. Кроме того, выделяется отдельная область памяти для хранения ссылок на каждый из внутренних массивов (рис 1.).
Простейшее описание ступенчатого массива имеет следующий вид:
тип [][] имя [инициализрующий_список];
Например, int [][]a;
Для инициализации такого массива нельзя использовать запись new int[n][m]. Для каждого массива нижнего уровня нужно вызывать конструктор. В этом и состоит сложность объявления таких массивов. Рассмотрим примеры такой инициализации.
//массив массивов - формальный пример
//объявление и инициализация
int[][] jagger = new int[3][]
{
new int[] {5,7,9,11},
new int[] {2,8},
new int[] {6,12,4}
};
Массив jagger имеет два уровня. Можно считать, что у него три элемента, каждый из которых является массивом. Для каждого такого массива необходимо вызвать конструктор new, чтобы создать внутренний массив. В данном примере элементы внутренних массивов получают значение, будучи явно инициализированы константными массивами. Конечно, допустимо и такое объявление:
int[][]jagger1 =newint[3][]
{
newint[4],
newint[2],
newint[3]
};
В этом случае элементы массива получат при инициализации нулевые значения. Реальную инициализацию нужно будет выполнять программным путем. Стоит заметить, что в конструкторе верхнего уровня константу 3 можно опустить и писать просто new int[][].Вызов этого конструктора можно вообще опустить, он будет подразумеваться:
int[][] jagger2 =
{
new int[4],
new int[2],
newint[3]
};
Рассмотрим пример работы со ступенчатыми массивами: вывод массива на экран
int[][] a = new int[3][];
a[0] = new int [5] { 24, 50, 18, 3, 16 };
a[1] = new int [3] { 7, 9, -1 };
a[2] = new int [4] { 6, 15, 3, 1 };
Console.WriteLine( "Исходный массив:" );
foreach ( int [] mas1 in a )
{
foreach ( int x in mas1 )
Console.Write( "\t" + x );
Console.WriteLine();
}
Рассмотрим еще один пример для работы со ступенчатыми массивами. Написать и протестировать метод, который возвращает ступенчатый массив, сгенерированный на основе заданного ступенчатого массива следующим образом. В начало каждой строки заданного массива добавляется элемент, равный единице. Метод должен генерировать хотя бы одно исключение. Ступенчатый массив должен генерироваться случайным образом из нулей и единиц и выводиться на экран в методе Main.
class Program
{
static void Main()
{
/*Создание ступенчатого массива и генерация его элементов случайным образом*/
Console.Write("Введите количество строк в ступенчатом массиве: ");
int n = int.Parse(Console.ReadLine());
int[][] ar = new int[n][];
int m;
Random r = new Random();
for (int i = 0; i < n; i++)
{
Console.Write("Введите количество строк в {0} - ой строке ступенчатого массива: ",i);
m = int.Parse(Console.ReadLine());
ar[i] = new int[m];
for (int j = 0; j < m; j++)
ar[i][j] =r.Next(0, 2);
}
//Вывод массива на экран
Console.WriteLine ("Исходный массив: ");
foreach (int[] mas in ar)
{
foreach (int el in mas)
Console.Write("\t" + el);
Console.WriteLine();
}
try
{
int[][] ar_new = f(ar);
//Вывод массива на экран
Console.WriteLine("Новый массив: ");
foreach (int[] mas in ar_new)
{
foreach (int el in mas)
Console.Write("\t" + el);
Console.WriteLine();
}
}
catch (Exception e) { Console.WriteLine(e.Message); }
Console.ReadKey();
}
//Функция, возвращающая новый ступенчатый массив
static int [][] f (int [][] a)
{
intn=a.GetLength(0);// количество строк
if(n==0)thrownewException("Невозможно преобразовать заданный массив, так как нем 0 строк ");
int[][] b = new int[n][];
for (int i = 0; i < n; i++)
{
b[i] = new int[a[i].Length+1];
b[i][0] = 1;
for (int j = 1; j < b[i].Length; j++)
b[i][j] = a[i][j-1];
}
return b;
}
}