ЛАБОРАТОРНАЯ РАБОТА 3
МАССИВЫ В
JAVA
ЦЕЛЬ РАБОТЫ
Целью настоящей работы является изучение методов программирования на
JAVA с использованием массивов.
ТЕОРЕТИЧЕСКАЯ ЧАСТЬ
Массивы Как известно, под массивом подразумевают набор однотипных данных (переменных), к которым можно обращаться по общему имени. Массивы бывают статическими и динамическими. Под статические массивы память выделяется при компиляции программы. Для динамических массивов память выделяется в процессе выполнения программы. В
Jаvа все массивы динамические!
Создание одномерного массива Переменные, относящиеся к одному массиву, называются элементами этого массива. Чтобы однозначно идентифицировать элемент массива, необходимо знать имя массива и позицию (размещение) элемента в массиве. Позиция элементов в массиве определяется с помощью целочисленных индексов. Количество индексов, необходимых для идентификации элемента массива, называется размерностью массива. Одномерный массив - это такой массив, в котором идентификация элементов осуществляется с помощью одного индекса.
Для объявления одномерного массива необходимо задать тип, к которому относятся элементы массива, название массива, а также количество элементов, входящих в массив. Синтаксис объявления одномерного массива имеет вид:
тип[] имя=nеw тип[размер]; Вначале указывается тип элементов массива. Обращаем внимание, что для массива после идентификатора типа ставятся пустые квадратные скобки. Далее следует имя массива, оператор присваивания, инструкция динамического выделения памяти
new, снова
тип элементов массива и в квадратных скобках
размер массива (количество элементов в массиве). Например, командой
int nums=new int[20] объявляется целочисленный массив
nums из 20 элементов.
Строго говоря, представленная здесь команда объявления массива является симбиозом двух команд: команды
int[] nums объявления переменной nums типа «целочисленный массив» и команды
nums=new iпt[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[] dаtа={3,8,1,7}; Если в квадратных скобках размер массива не указан, он определяется автоматически в соответствии с количеством элементов в списке значений. В данном случае создается целочисленный массив
data из четырех элементов со значениями
dаtа[0]=3, data[1]=8, data[2]=1 и dаtа[3]=7. Того же результата можно добиться, воспользовавшись такими командами:
int[] data; data=new int[]{3,8,1,7}; Первой командой
int[]data объявляется переменная массива. Командой new
int[]{3,8,1,7} создается массив из четырех целых чисел, а ссылка на этот массив присваивается в качестве значения переменной
data командой
data=newint[]{3,8,1,7}. Пример объявления, инициализации и использования массивов приведен в листинге 1.
Листинг 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
nums[i]=2*dаtа[i]-3;
System.out.println("nums["+i+"]="+nums[i]);}
}
}
В программе объявляется и инициализируется массив data из четырех элементов. Длина массива, возвращаемая инструкцией data.length, присваивается в качестве значения целочисленной переменной n (команда n=data.length). Далее командой int[]nums=new int[n] объявляется целочисленный массив nums. Количество элементов в этом массиве определяется значением переменной п, поэтому совпадает с размером массива data. Заполнение массива nums выполняется с помощью инструкции цикла. Значения элементов-массива nums заполняются на основе значений элементов массива data (командой nums[i]=2*dаtа[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 его размер определяется с помощью переменной п, значение которой вычисляется в процессе выполнения программы. Такой способ определения размера массива возможен исключительно благодаря тому, что массивы в Jауа динамические.
Двухмерные и многомерные массивы
В Jаvа массивы могут иметь размерность выше единичной. Но на практике массивы размерности выше второй используют редко. Вначале рассмотрим способы объявления, инициализации и использования двухмерных массивов.
Двухмерный массив в Jаvа с технической точки зрения является одномерным массивом, элементами которого являются также одномерные массивы. Это на первый взгляд несущественное обстоятельство приводит к исключительной гибкости в использовании таких структур, как двухмерные массивы.
Объявляются двухмерные массивы практически так же, как и одномерные, с той лишь разницей, что при этом используются две пары квадратных скобок (как при объявлении переменной массива, так и при выделении для массива области памяти). При этом размер массива указывается по каждому из индексов. Синтаксис объявления двухмерного массива может быть следующим:
тип[][] имя=nеw тип[размер_1][размер_2];
Как и в случае одномерного массива, данная команда представляет собой объединение двух отдельных команд:
тип[][] имя;
имя=nеw тип[размер_1][размер_2];
Первой из них объявляется переменная двухмерного массива имя. Второй командой создается двухмерный массив с размерами размер_1 и размер_2, а ссылка на этот массив присваивается в качестве значения переменной массива имя. Например, командой double[][]data=new double[3][4] создается массив с именем data. Элементами массива являются значения типа doublе. Размер массива по первому индексу равен 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] не существует вообще!
В листинге 2 приведен пример программы, в которой создается двухмерный массив и инициализируется с помощью вложенных инструкций цикла.
Листинг 2. Объявление и инициализация двухмерного массива
class МуDАrrау{
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. Создание непрямоугольного массива
class ArrayDemo{
public static void main(String[] args){
// Индексные переменные и размер массива:
int i,j,n:
// Создание массива (второй размер не указан):
int[][] nums=new int[5][];
// Определение первого размера массива:
n=nums.length;
// Цикл для создания треугольного массива:
for(i=0; i
nums[i]=new int[i+1];}
// Вложенные циклы для заполнения элементов массива:
for(i=0; i
for(j=0; j
// Присваивание значения элементу массива:
nums[i][j]=10*(i+1)+j+1;
// Вывод значения на экран:
System.out.print (nums[i][j]+" ");}
// Переход на новую строку;
System.out.println():}
}
}
Обращаем внимание читателя на команду int[][] nums=new int[5][], которой создается двухмерный целочисленный массив nums. Этот массив состоит из пяти элементов, каждый из которых также является массивом. Однако размер этих массивов не указан - вторая пара квадратных скобок в конце программы пуста! Определяются размеры каждого из элементов-массивов в рамках инструкции цикла, но предварительно переменной n командой n=nums.length присваивается значение размера массива по первому индексу. Ранее уже упоминалось, что двухмерный массив является массивом массивов. Поэтому ссылка nums.length возвращает размер массива nums, то есть число 5 в данном случае.
В первой инструкции цикла индексная переменная i получает значения от О до 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 изменяется от О до 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
Практически также создаются многомерные (размерности выше второй) массивы. В листинге 4 приведен пример создания трехмерного массива размером три по каждому из индексов, определяющего тензор Леви-Чевита. Компоненты этого тензора имеют три индекса и отличны от нуля, только если все индексы различны. Элемент с индексами 0, 1 и 2 равен единице. Любой элемент, который получается циклической перестановкой этих индексов, также равен 1. Прочие элементы равны -1. Таким образом, всего три единичных элемента и три элемента со значением -1, остальные равны нулю. 