Глава 3. Массивы

Ну и что вы скажете обо всем этом, Ватсон?

Из к/ф «Приключения Шерлока Холмса

и доктора Ватсона»

Как известно, под массивом подразумевают набор однотипных данных (пере- менных), к которым можно обращаться по общему имени. Массивы бывают статическими и динамическими. Под статические массивы память выделяется при компиляции программы. Для динамических массивов память выделяется в процессе выполнения программы. В Java все массивы динамические!

Создание одномерного массива

Это дело очень интересное. И простое!

Из к/ф «Приключения Шерлока Холмса

и доктора Ватсона»

Переменные, относящиеся к одному массиву, называются элементами этого мас- сива. Чтобы однозначно идентифицировать элемент массива, необходимо знать имя массива и позицию (размещение) элемента в массиве. Позиция элементов в массиве определяется с помощью целочисленных индексов. Количество ин- дексов, необходимых для идентификации элемента массива, называется размер- ностью массива. Одномерный массив — это такой массив, в котором идентифи- кация элементов осуществляется с помощью одного индекса.

Для объявления одномерного массива необходимо задать тип, к которому от- носятся элементы массива, название массива, а также количество элементов, входящих в массив. Синтаксис объявления одномерного массива имеет вид: тип[] имя=new тип[размер];

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

Создание одномерного массива 81

(количество элементов в массиве). Например, командой int nums=new int[20]

объявляется целочисленный массив nums из 20 элементов.

Строго говоря, представленная здесь команда объявления массива является симбиозом двух команд: команды int[] nums объявления переменной nums типа

«целочисленный массив» и команды nums=new int[20] выделения памяти под массив и присваивания ссылки на этот массив переменной nums. Другими слова- ми, процесс объявления массива можно выполнить двумя командами:

int[] nums; nums=new int[20];

Допускается указывать квадратные скобки либо после имени типа массива, либо после имени массива. Например, вместо команды int[] nums можно ис- пользовать команду int nums[].

Обращение к элементу одномерного массива осуществляется через имя массива с указанием в квадратных скобках индекса элемента. Индексация элементов массива начинается с нуля. Таким образом, ссылка на первый элемент массива nums будет иметь вид nums[0]. Если в массиве 20 элементов, то последний эле- мент массива имеет индекс 19, то есть nums[19].

Длину массива можно узнать с помощью свойства length. Это такая переменная, которая создается при объявлении массива, и ее значением является количество элементов массива. Поскольку для каждого массива создается своя переменная length, обращение к таким переменным осуществляется с одновременным ука- занием имени массива. В частности, сначала указывается имя массива, а затем, через точку, имя переменной length. Например, чтобы в программе узнать значе- ние длины массива nums, можно воспользоваться инструкцией nums.length. Ссыл- ка на последний элемент массива может быть записана как nums[nums.length-1], поскольку индекс последнего элемента на единицу меньше длины массива.

Здесь уместно будет обратить внимание читателей, знакомых с языком про- граммирования С++, что в Java, в отличие от С++, выполняется автоматическая проверка факта выхода за пределы массива. Поэтому если в программном коде по ошибке выполняется обращение к несуществующему элементу массива, про- грамма не скомпилируется.

При объявлении массива для него выделяется память. В Java элементы масси- ва автоматически инициализируются с «нулевыми» значениями — выделенные ячейки обнуляются, а значения этих обнуленных ячеек интерпретируются в за- висимости от типа массива. Тем не менее на такую автоматическую инициализа- цию полагаться не стоит. Разумно инициализировать элементы массива в явном виде. Для этого используют инструкцию цикла или задают список значений элементов при объявлении массива.

При инициализации массива списком значений при объявлении переменной массива после нее указывается (через оператор присваивания) заключенный в фигурные скобки список значений. Например:

int[] data={3,8,1,7};

Если в квадратных скобках размер массива не указан, он определяется автома- тически в соответствии с количеством элементов в списке значений. В данном случае создается целочисленный массив data из четырех элементов со значения- ми data[0]=3, data[1]=8, data[2]=1 и data[3]=7. Того же результата можно добить- ся, воспользовавшись такими командами:

int[] data;

data=new int[]{3,8,1,7};

Первой командой int[] data объявляется переменная массива. Командой new int[]{3,8,1,7} создается массив из четырех целых чисел, а ссылка на этот мас- сив присваивается в качестве значения переменной data командой data=new int[]

{3,8,1,7}.

Пример объявления, инициализации и использования массивов приведен в ли- стинге 3.1.

Листинг 3.1. Объявление и инициализация одномерного массива

class MyArray{

public static void main(String[] args){

// Индексная переменная и размер массива: int i,n;

// Объявление переменной массива: int[] data;

// Инициализация массива: data=new int[]{3,8,1,7};

// Длина второго массива: n=data.length;

// Объявление второго массива: int[] nums=new int[n];

// Заполнение второго массива: for(i=0;i<n;i++){ nums[i]=2*data[i]-3;

System.out.println("nums["+i+"]="+nums[i]);}

}

}

В программе объявляется и инициализируется массив data из четырех элемен- тов. Длина массива, возвращаемая инструкцией data.length, присваивается в ка- честве значения целочисленной переменной n (команда n=data.length). Далее командой int[] nums=new int[n] объявляется целочисленный массив nums. Коли- чество элементов в этом массиве определяется значением переменной n, поэто- му совпадает с размером массива data. Заполнение массива nums выполняется с помощью инструкции цикла. Значения элементов массива nums заполняются на основе значений элементов массива data (командой nums[i]=2*data[i]-3). Вы- численные значения выводятся на экран командой System.out.println("nums["+i

+"]="+nums[i]).

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

nums[0]=3 nums[1]=13 nums[2]=-1 nums[3]=11

Еще раз обращаем внимание читателя на то, что индексация элементов массива начинается с нуля. Поэтому в инструкции цикла индексная переменная i ини- циализируется с начальным нулевым значением, а в проверяемом условии (i<n) использован оператор строгого неравенства.

Немаловажно и то обстоятельство, что при создании массива nums его размер определяется с помощью переменной n, значение которой вычисляется в про- цессе выполнения программы. Такой способ определения размера массива воз- можен исключительно благодаря тому, что массивы в Java динамические.

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

— Вы хотите сказать, что вам уже все ясно?

— Не хватает некоторых деталей. Но не в этом суть!

Из к/ф «Приключения Шерлока Холмса

и доктора Ватсона»

В Java массивы могут иметь размерность выше единичной. Но на практике мас- сивы размерности выше второй используют редко. Вначале рассмотрим спосо- бы объявления, инициализации и использования двухмерных массивов.

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

Объявляются двухмерные массивы практически так же, как и одномерные, с той лишь разницей, что при этом используются две пары квадратных скобок (как при объявлении переменной массива, так и при выделении для массива области памяти). При этом размер массива указывается по каждому из индексов. Син- таксис объявления двухмерного массива может быть следующим:

тип[][] имя=new тип[размер_1][размер_2];

Как и в случае одномерного массива, данная команда представляет собой объ- единение двух отдельных команд:

тип[][] имя;

имя=new тип[размер_1][размер_2];

Первой из них объявляется переменная двухмерного массива имя. Второй ко- мандой создается двухмерный массив с размерами размер_1 и размер_2, а ссылка

на этот массив присваивается в качестве значения переменной массива имя. На- пример, командой double[][] data=new double[3][4] создается массив с именем data. Элементами массива являются значения типа double. Размер массива по первому индексу равен 3, а по второму — 4. К тому же результату приведет вы- полнение команд

double[][] data; data=new double[3][4];

Обращение к элементам двухмерного массива выполняется в следующем фор- мате: указывается имя массива, в квадратных скобках первый индекс элемента и в квадратных же скобках второй элемент массива. Индексация по всем раз- мерностям начинается с нуля. Например, ссылка data[0][3] является обращени- ем к элементу массива data с индексами 0 и 3.

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

double data[][]={{0.1,0.2,0.3},{0.4,0.5,0.6}}; int nums[][]={{1,2,3},{4,5}};

Первой командой создается и инициализируется двухмерный массив data раз- мерами 2 на 3 (по первому индексу размер массива 2, по второму индексу — 3). Другими словами, массив data — это массив из двух элементов, которые, в свою очередь, являются массивами из трех элементов. Так, элемент data[0][0] полу- чает значение 0.1, элемент data[0][2] — значение 0.3, элемент data[1][0] — зна- чение 0.4, а элемент data[1][2] — значение 0.6.

Интереснее вторая команда. Этой командой создается целочисленный массив nums, который состоит из двух элементов-массивов. Однако первый массив име- ет размерность 3, а второй — 2! Здесь мы находим подтверждение того, что в Java двухмерные массивы не обязаны быть прямоугольными, то есть иметь такую же размерность по второму индексу. В данном случае элемент nums[0][0] имеет значение 1, элемент nums[0][1] — значение 2, элемент nums[0][2] — значение 3, элемент nums[1][0] — значение 4, а элемент nums[1][1] — значение 5. Элемента nums[1][2] не существует вообще!

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

Листинг 3.2. Объявление и инициализация двухмерного массива

class MyDArray{

public static void main(String[] args){

// Индексные переменные и размерность массива: int i,j,n=3;

// Создание двухмерного массива: int[][] nums=new int[n-1][n];

// Вложенные инструкции цикла:

for(i=0;i<n-1;i++){ for(j=0;j<n;j++){

// Заполнение элементов массива: nums[i][j]=10*(i+1)+j+1;

// Вывод значений в одну строку: System.out.print(nums[i][j]+" ");}

// Переход на новую строку System.out.println();}

}

}

Командой int[][] nums=new int[n-1][n] создается целочисленный массив nums с размерами n-1 по первому индексу и n по второму. Переменная n предва- рительно инициализирована со значением 3. Заполняется массив с помощью вложенных инструкций цикла (команда nums[i][j]=10*(i+1)+j+1). Значения эле- ментов массива выводятся на экран. В результате выполнения программы по- лучаем:

11 12 13

21 22 23

В листинге 3.3 приведен код программы, в которой создается двухмерный «не- прямоугольный» массив.

Листинг 3.3. Создание непрямоугольного массива

class ArrayDemo{

public static void main(String[] args){

// Индексные переменные и размер массива: int i,j,n;

// Создание массива (второй размер не указан): int[][] nums=new int[5][];

// Определение первого размера массива: n=nums.length;

// Цикл для создания треугольного массива: for(i=0;i<n;i++){

nums[i]=new int[i+1];}

// Вложенные циклы для заполнения элементов массива: for(i=0;i<n;i++){

for(j=0;j<nums[i].length;j++){

// Присваивание значения элементу массива: nums[i][j]=10*(i+1)+j+1;

// Вывод значения на экран: System.out.print(nums[i][j]+" ");}

продолжение

Листинг 3.3 (продолжение)

// Переход на новую строку: System.out.println();}

}

}

Обращаем внимание читателя на команду int[][] nums=new int[5][], которой создается двухмерный целочисленный массив nums. Этот массив состоит из пяти элементов, каждый из которых также является массивом. Однако размер этих массивов не указан — вторая пара квадратных скобок в конце програм- мы пуста! Определяются размеры каждого из элементов-массивов в рамках инструкции цикла, но предварительно переменной n командой n=nums.length присваивается значение размера массива по первому индексу. Ранее уже упо- миналось, что двухмерный массив является массивом массивов. Поэтому ссылка nums.length возвращает размер массива nums, то есть число 5 в данном случае.

В первой инструкции цикла индексная переменная i получает значения от 0 до n-1. Командой nums[i]=new int[i+1] определяются размеры каждого из мас- сивов — элементов массива nums. Учитывая, что nums является двухмерным мас- сивом, инструкция вида nums[i] является ссылкой на i-й одномерный элемент- массив массива nums. Командой new int[i+1] выделяется место в памяти для массива, размер этого массива устанавливается равным i+1, а ссылка на массив записывается в переменную nums[i]. В результате мы получаем двухмерный мас- сив «треугольного» вида: в первой «строке» массива один элемент, во второй — два элемента и т. д., до пятой «строки» массива.

С помощью вложенных инструкций цикла выполняется заполнение созданно- го массива. Внешняя индексная переменная i получает значения от 0 до n-1 и определяет первый индекс двухмерного массива nums. Верхняя граница диа- пазона изменения второй индексной переменной j, определяющей второй ин- декс элемента массива nums, зависит от текущего значения переменной i. Для определения размера массива nums[i] используется инструкция nums[i].length. Индекс j изменяется от 0 до nums[i].length-1. Значение элементам массива при- сваивается командой nums[i][j]=10*(i+1)+j+1. Результат выполнения программы имеет вид:

11

21 22

31 32 33

41 42 43 44

51 52 53 54 55

Практически также создаются многомерные (размерности выше второй) мас- сивы. В листинге 3.4 приведен пример создания трехмерного массива размером три по каждому из индексов, определяющего тензор Леви–Чевита. Компоненты этого тензора имеют три индекса и отличны от нуля, только если все индексы различны. Элемент с индексами 0, 1 и 2 равен единице. Любой элемент, который получается циклической перестановкой этих индексов, также равен 1. Прочие

Символьные массивы 87

элементы равны –1. Таким образом, всего три единичных элемента и три эле- мента со значением –1, остальные равны нулю.

Листинг 3.4. Создание трехмерного массива

class MyTArray{

public static void main(String[] args){

// Индексные переменные: int i,j,k;

// Объявление трехмерного массива: byte[][][] epsilon=new byte[3][3][3];

// Обнуление элементов массива: for(i=0;i<3;i++) for(j=0;j<3;j++) for(k=0;k<3;k++) epsilon[i][j][k]=0;

// Единичные элементы массива: epsilon[0][1][2]=epsilon[1][2][0]=epsilon[2][0][1]=1;

// Элементы со значением -1: epsilon[1][0][2]=epsilon[0][2][1]=epsilon[2][1][0]=-1;

}

}

Объявляется трехмерный массив epsilon командой byte[][][] epsilon=new byte[3][3][3]. Для надежности всем элементам массива присваиваются нулевые значения, для чего используется три вложенных инструкции цикла. Далее ко- мандой epsilon[0][1][2]=epsilon[1][2][0]=epsilon[2][0][1]=1 задаются единичные значения для трех элементов массива и еще для трех элементов значение -1 (ко- мандой epsilon[1][0][2]=epsilon[0][2][1]=epsilon[2][1][0]=-1).

Символьные массивы

— Что вы делаете?

— Не видите? Стреляю!

— Странный способ украшать дом

монограммой королевы.

Из к/ф «Приключения Шерлока Холмса

и доктора Ватсона»

В языке программирования С++ символьные массивы имеют особый ареол, поскольку там символьные массивы — одно из средств реализации текстовых строк. В Java в отношении символьных массивов все обстоит намного про- ще — это обычный, с точки зрения создания и применения, массив, элемента- ми которого являются символы. Правда, и в Java в использовании символьных массивов есть некоторые особенности. Однако эти особенности скорее связаны

со спецификой типа char, чем со структурой или свойствами непосредственно массива. В листинге 3.5 приведен простой пример.

Листинг 3.5. Символьный массив

class CharArray{

public static void main(String[] args){ char[] words=new char[]

{'С','и','м','в','о','л','ь','н','ы','й',' ','м','а','с','с','и','в'};

System.out.println(words);

}

}

Символьный массив создается стандартным способом: одновременно с объявле- нием переменной массива words списком символов инициализируются элементы массива. В результате выполнения команды System.out.println(words) на экран выводится сообщение Символьный массив. Интересно здесь то, что для вывода зна- чений элементов символьного массива аргументом метода println() указано имя массива (переменная массива words). Причина такого удобства кроется в спосо- бах автоматического преобразования разных объектов (в том числе символьного массива) в текстовый формат. Эта тема рассматривается в главе 8, посвященной работе с текстом (классы String и StringBuffer).

Другой пример объявления и использования символьных массивов приведен в листинге 3.6.

Листинг 3.6. Кодирование слова

class CharArray2{

public static void main(String[] args){ char[] words=new char[]{'С','л','о','в','о'}; char[] code=new char[words.length];

for(int i=0;i<words.length;i++) code[i]=(char)(words[i]+i+1); System.out.println(words); System.out.println(code);

}

}

В программе выполняется достаточно простое кодирование слова, записан- ного по буквам в массив words. Этот массив объявляется и инициализируется значениями элементов, соответствующими слову Слово. Далее объявляется еще один символьный массив code. Его размер равен размеру массива words. Заполнение элементов массива code выполняется в рамках инструкции цикла. Для этого в теле цикла использована команда code[i]=(char)(words[i]+i+1). В данном случае при вычислении выражения words[i]+i+1 символ words[i] преобразуется в числовой формат (код символа) и к нему прибавляется зна- чение i+1. Полученное число благодаря инструкции явного приведения типа

преобразуется в символ. Этот символ записывается в массив code. Далее оба массива выводятся на экран. В результате выполнения программы получаем следующее:

Слово Тнсжу

Для «расшифровки» полученного «слова» можно применить обратную проце- дуру. Предлагаем читателю сделать это самостоятельно.

Присваивание и сравнение массивов

Простые вещи разучились делать!

Из к/ф «Приключения Шерлока Холмса

и доктора Ватсона»

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

Напомним наиболее существенные моменты, связанные с объявлением масси- вов в Java.

Переменная, обозначающая массив (переменная массива), объявляется незави- симо от фактического выделения памяти под массив. Другими словами, непо- средственно массив и переменная массива — это далеко не одно и то же. В этом смысле показательным является двухэтапный (двумя командами) процесс со- здания массива. Например:

int[] nums;

nums=new int[]{1,2,3,4};

В данном случае команда int[] nums есть не что иное, как объявление перемен- ной nums. Тип этой переменной — «массив целых чисел». Значением перемен- ной может быть ссылка (адрес) на какой-нибудь массив, состоящий из целых чисел.

Оператор new в общем случае служит для динамического выделения памяти под различные объекты, в том числе массивы. Командой new int[]{1,2,3,4} в памяти выделяется место для целочисленного массива из четырех элементов, соответствующие значения присваиваются элементам массива. У этого вновь созданного массива есть адрес (ссылка на массив). В качестве значения опера- тор new возвращает ссылку на созданный объект. В данном случае возвраща- ется ссылка на массив. Эта ссылка в качестве значения присваивается пере-

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

int[] nums,data; nums=new int[]{1,2,3,4}; data=nums;

Все достаточно просто. Первой командой int[] nums,data объявляются две пере- менные массива nums и data. Второй командой nums=new int[]{1,2,3,4} создается массив, а ссылка на него присваивается в качестве значения переменной nums. Далее командой data=nums значение переменной nums присваивается переменной data. Однако значение переменой nums — это ссылка на массив. Поэтому после присваивания переменная data ссылается на тот же массив! Например, элемент data[1] имеет такое же значение, что и nums[1] (значение 2). Точнее, это один и тот же элемент. Более того, если теперь изменить какой-нибудь элемент мас- сива data (например, data[3]=-1), автоматически изменится и соответствующий элемент массива nums. Причина та же — массив на самом деле один, просто на него ссылаются две переменные.

При сравнении массивов с помощью операторов равно == и не равно != (на- пример, nums==data или nums!=data) сравниваются значения переменных массива, а не элементы в этих массивах. Поэтому результатом выражения nums==data яв- ляется true, если обе переменные массива nums и data ссылаются на один и тот же массив.

Пример программы, в которой имеет место присваивание массива, приведен в листинге 3.7.

Листинг 3.7. Присваивание массива

class MyArrayDemo{

public static void main(String[] args){

int i;

int[] nums=new int[10]; int[] data=new int[20]; for(i=0;i<10;i++){ nums[i]=2*i+1; data[i]=2*i; data[i+10]=2*(i+10);} data=nums;

for(i=0;i<data.length;i++) System.out.print(data[i]+" ");}

}

В программе объявляются два целочисленных массива: массив nums из 10 эле- ментов и массив data из 20 элементов. С помощью инструкции цикла эти мас- сивы заполняются: массив nums заполняется нечетными числами, массив data — четными. После этого командой data=nums массиву data в качестве значения присваивается массив nums. Обращаем внимание, что хотя эти массивы имеют

одинаковый тип, у них разные размеры. Далее с помощью еще одной инструк- ции цикла элементы массива data выводятся с интервалом в одну строку (для вывода значений без перехода к новой строке используем метод print()). В ре- зультате мы получаем числовой ряд:

1 3 5 7 9 11 13 15 17 19

Это те значения, которыми инициализировался массив nums. Интерес в данном случае представляет то обстоятельство, что в инструкции цикла, обеспечиваю- щей вывод значений массива data, верхняя граница для индексов элементов массива определяется через свойство length массива data. Массив инициализи- ровался с размером 20, а в конечном итоге его размер оказался равным 10! При- чина очевидна. После выполнения команды data=nums переменная массива data начинает ссылаться на тот же массив, что и переменная массива nums.

Особенности сравнения массивов на предмет равенства (неравенства) иллю- стрируются программным кодом листинга 3.8.

Листинг 3.8. Сравнение массивов

class MyArrayDemo2{

public static void main(String[] args){

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

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

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

// Комментирование следующей команды можно отменить:

// data=nums;

// Проверка совпадения ссылок: if(data==nums){ System.out.println("Совпадающие массивы!"); return;}

// Проверка размеров массивов: if(data.length!=nums.length){ System.out.println("Разные массивы!"); return;}

// Поэлементная проверка массивов: for(int i=0;i<data.length;i++){ if(data[i]!=nums[i]){

System.out.println("Несовпадающие элементы!"); return;}}

System.out.println("Одинаковые массивы!");

}}

Программа предназначена для сравнения двух целочисленных массивов. В про- грамме объявляются два целочисленных массива nums и data и инициализиру- ются одинаковыми наборами значений. Далее непосредственно выполняется проверка. Состоит она из трех этапов. Сначала выполняется проверка равенства переменных массивов nums и data. Если ссылки равны, то, очевидно, массивы одинаковы (совпадают). Проверка равенства ссылок на массивы выполняется

с помощью условной инструкции if() с условием data==nums. При выполненном условии выводится сообщение Совпадающие массивы!. При этом работа программы завершается, для чего используется команда return.

Если ссылки различны, выполняется поэлементная проверка массивов. Мас- сивы считаются одинаковыми, если у них совпадают соответствующие эле- менты. Но прежде необходимо проверить, совпадают ли размеры массивов. Проверка равенства размеров массивов также выполняется с помощью услов- ной инструкции if(), при этом проверяется условие data.length!=nums.length. Условие является истинным, если массивы имеют разные размеры. В этом случае выводится сообщение Несовпадающие элементы!, и работа программы за- вершается.

При совпадающих размерах массивов запускается цикл, в рамках которого срав- ниваются элементы двух массивов. Для этого использована условная инструк- ция if() с проверяемым условием data[i]!=nums[i] (i — индексная переменная). Если встречаются несовпадающие элементы, выводится сообщение Несовпадаю- щие элементы!, и работа программы завершается.

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

В данном случае для списков инициализации массивов, приведенных в листин- ге 3.8, в результате выполнения программы появляется сообщение Одинаковые массивы!. Программа содержит закомментированную команду data=nums. Если отменить комментирование, результатом будет сообщение Совпадающие массивы!. Чтобы увидеть прочие сообщения, следует, не отменяя комментирование, вне- сти изменения в списки инициализации массивов.