поддержка массивов в Java. реферат Java. Поддержка массивов в Java

Название	Поддержка массивов в Java
Анкор	поддержка массивов в Java
Дата	26.11.2022
Размер	22.86 Kb.
Формат файла
Имя файла	реферат Java.docx
Тип	Реферат #813532

Реферат

на тему: поддержка массивов в Java

Поддержка массивов в Java

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

Синтаксис массивов Java близок к синтаксису C и C++ (и имеет много общего с другими языками), однако у поддержки массивов Java есть свои специфические особенности.

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

Данные Java делятся на две категории: примитивные типы (int, double и т. д.) и объекты. Во многих языках программирования (даже в объектно-ориентированных, как C++) массивы считаются примитивными типами, но в Java они относятся к объектам. Соответственно для создания массива необходимо использовать оператор new:

int[] intArray;	// Определение ссылки на массив
intArray = new int[100];	// Создание массива
	// и сохранение ссылки на него в intArray

Также можно воспользоваться эквивалентной объединенной конструкцией:

int[] intArray = new int[100];

Оператор [] сообщает компилятору, что имя принадлежит объекту массива, а необычной переменной. В альтернативной форме этого оператора квадратные скобки ставятся после имени, а не после типа:

int intArray[] = new int[100]; // Альтернативный синтаксис

Однако размещение [] после int ясно показывает, что [] является частью типа, а не имени.

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

Массивы содержат поле length, которое может использоваться для определения размера (количества элементов) массива:

int arrayLength = intArray.length; // Определение размера массива

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

Обращение к элементам массива

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

temp = intArray[3]; // Получение содержимого четвертого элемента массива

intArray[7] = 66; // Вставка значения 66 в восьмую ячейку

Следует помнить, что в Java, как и в C и C++, индекс первого элемента равен 0, так что индексы массива из 10 элементов лежат в диапазоне от 0 до 9.

Если индекс меньше 0 или больше размера массива без 1, генерируется исключение выхода за границы массива.

Инициализация

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

autoData[] carArray = new autoData[4000];

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

Для инициализации массива примитивного типа значениями, отличными от 0, используется следующий синтаксис:

int[] intArray = { 0, 3, 6, 9, 12, 15, 18, 21, 24, 27 };

Эта команда совмещает объявление ссылки с созданием массива оператором new (хотя на первый взгляд это и не очевидно). Числа в фигурных скобках называются списком инициализации. Размер массива определяется по количеству значений в этом списке.

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

Рассмотрим традиционную процедурную версию, а затем перейдем к объектно-ориентированному аналогу. В листинге представлена традиционная версия array.java.

Листинг Программа array java

// array.java

// Работа с массивами Java

// Запуск программы: C>java arrayApp

////////////////////////////////////////////////////////////////

class ArrayApp

{

public static void main(String[] args)

{

long[] arr; // Ссылка на массив

arr = new long[100]; // Создание массива

int nElems = 0; // Количество элементов

int j; // Счетчик цикла

long searchKey; // Ключи искомого элемента

//--------------------------------------------------------------

arr[0] = 77; // Вставка 10 элементов

arr[1] = 99;

arr[2] = 44;

arr[3] = 55;

arr[4] = 22;

arr[5] = 88;

arr[6] = 11;

arr[7] = 00;

arr[8] = 66;

arr[9] = 33;

nElems = 10; // Массив содержит 10 элементов

//--------------------------------------------------------------

for(j=0; j
System.out.print(arr[j] + " ");

System.out.println("");

//--------------------------------------------------------------

searchKey = 66; // Поиск элемента с ключом 66

for(j=0; j
if(arr[j] == searchKey) // Значение найдено?

break; // Да - выход из цикла

if(j == nElems) // Достигнут последний элемент?

System.out.println("Can't find " + searchKey); // Да

еlse

System.out.println("Found " + searchKey); // Нет

//--------------------------------------------------------------

searchKey = 55; // Удаление элемента с ключом 55

for(j=0; j
if(arr[j] == searchKey)

break;

for(int k=j; k
arr[k] = arr[k+1];

nElems--; // Уменьшение размера

//--------------------------------------------------------------

for(j=0; j
System.out.print( arr[j] + " ");

System.out.println("");

}

} // Конец класса ArrayApp

Программа создает массив с именем arr, помещает в него 10 элементов данных (номера игроков), ищет элемент с ключом 66, выводит все элементы, удаляет игрока с ключом 55 и выводит оставшиеся 9 элементов. Результат работы программы выглядит так:

77 99 44 55 22 88 11 0 66 33

Found 66

77 99 44 22 88 11 0 66 33

В массиве сохраняются данные типа long. Этот тип выбран для того, чтобы более наглядно показать, что это данные; тип int используется для значений индексов. Примитивный тип выбран для упрощения кода. В общем случае данные, сохраняемые в структуре данных, состоят из нескольких полей, поэтому для их представления обычно используются объекты вместо примитивных типов.

Вставка

Вставка нового элемента в массив выполняется просто — с использованием обычного синтаксиса массива:

arr[0] = 77;

Количество элементов, добавленных в массив, хранится в переменной nElems.

Поиск

Переменная searchKey содержит искомое значение. Чтобы найти нужный элемент, мы перебираем содержимое массива, сравнивая текущий элемент с searchKey. Если переменная цикла j достигает последней занятой ячейки, а совпадение так и не найдено, значит, значение отсутствует в массиве. В зависимости от результата поиска программа выводит соответствующее сообщение (Found 66 или Can’t find 27).

Удаление

Удаление начинается с поиска заданного элемента. Для простоты мы (оптимистично) предполагаем, что элемент в массиве присутствует. Обнаружив его, мы сдвигаем все элементы с большими значениями индекса на один элемент вниз, чтобы заполнить «дыру», оставшуюся от удаленного элемента, а значение nElems уменьшается на 1. В реальной программе также необходимо предусмотреть действия на тот случай, если удаляемое значение отсутствует в массиве.

Вывод

Операция вывода всех элементов весьма тривиальна: программа перебирает содержимое массива и последовательно выводит каждый текущий элемент arr[j].

Структура программы

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

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