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

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

Создание и манипуляции одномерными массивами

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

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

Нумерация элементов в Java array начинается с 0. Так, индекс первого элемента в данном массиве будет равен 0, а шестого - 5. Чтобы обратиться к конкретному элементу массива, например, пятому, достаточно указать имя массива и индекс элемента в квадратных скобках рядом с именем. Таким образом можно как присваивать значение элементу, так и извлекать его. Однако следует быть внимательным, поскольку если передать индекс, по которому не существует элемента, то возникнет ошибка.

Многомерные массивы в Java

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

Как видим, синтаксис не особо отличается от одномерных массивов. Давайте разберем структуру. В первых скобках мы выделили место под 5 элементов. Эти элементы являются ничем иным как ссылками на отдельные массивы. При этом размер каждого из них определен числом во вторых скобках. По сути, аналогом двумерных массивов в математике являются матрицы. Обратите внимание, что помимо элементов, в памяти выделяется отдельное место, где хранится значение длины массива (length). Как правило, работа с многомерными массивами осуществляется посредством вложенных циклов for.

Нерегулярные массивы

Двумерный массив является массивом массивов. Это мы уже выяснили. Но могут ли массивы, содержащиеся в нем, иметь разную длину? Ответ - да, могут. Для этого в Java предусмотрена возможность объявлять двумерный массив специальным образом. К примеру, мы хотим создать двумерный массив, который хранил бы в себе три одномерных массива длиной 2, 3 и 4 соответственно. Объявляется он следующим образом:

intarr = newint;

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

Обращаясь к элементу под индексом 0, указывающему на первый массив, мы объявляем его с размерностью 2. Под элементом с индексом 1 будет храниться массив размерностью 3, и так далее. Все довольно просто.

Альтернативный синтаксис объявления java array

Инициализировать массивы можно и непосредственно при их создании. Это довольно просто.

Обратите внимание на объявление массивов jerseyNumber и playerName.

В случае с двумерными массивами данное объявление выглядит так:

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

Вспомогательный класс Arrays

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

Разберем некоторые самые полезные Java array методы:

CopyOf (массив, длина) - возвращает копию переданного массива соответствующей длины. Если переданная длина больше оригинального массива, то все «лишние» элементы заполняются значением по умолчанию (0, если простой тип, и null , если ссылочный).

CopyOfRange (массив, первый индекс, последний индекс) - не указанный на рисунке, но полезный метод. Он копирует часть переданного массива, определенную соответствующими индексами, начиная с первого и заканчивая последним.

Sort (массив) - сортирует элементы массива по возрастанию.

Fill (массив, значение) - заполняет переданный массив соответствующим значением.

BinarySearch (массив, значение) - возвращает индекс, под которым элемент с соответствующим значением находится в переданном отсортированном массиве. Если же такой элемент отсутствует, то возвращается отрицательное число.

Поскольку методы статические, то для их вызова не требуется создавать экземпляр класса Arrays. Они вызываются напрямую из него: Arrays.sort(arr).

Заключение

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

Вспомогательный класс Array Java используется уже в «боевых» условиях, поэтому для начала рекомендуется учиться производить все основные операции с массивами вручную.

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

Для наглядности картинка, взятая мною с The Java Tutorial .

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

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

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

Int myFirstArray;

Можно также объявить массив так:

Int mySecondArray;

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

Исходя из данного примера, мы объявили 2 массива с именами myFirstArray и mySecondArray . Оба массива будут содержать элементы типа int .

Подобным образом можно объявить массив любого типа:

Byte anArrayOfBytes; short anArrayOfShorts; long anArrayOfLongs; float anArrayOfFloats; double anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; String anArrayOfStrings; ...

Тип массива задается следующим образом type, где type это тип данных содержащихся в нем элементов. Скобки являются специальным обозначением того, что переменные содержатся в массиве. Имя массива может быль любым, однако, оно должно соответствовать .

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

При объявлении массива в языке Java не указывается его размер и не резервируется память для него. Происходит лишь создание ссылки на массив.

Резервация памяти для массива и его инициализация.

Int myFirstArray; myFirstArray = new int;

В нашем примере мы создали массив из 15 элементов типа int и присвоили его ранее объявленной переменной myFirstArray .

Объявлять имя массива и резервировать для него память также можно на одной строке.

Int myArray = new int;

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

MyFirstArray = 10; // инициализация первого элемента myFirstArray = 20; // инициализация второго элемента myFirstArray = 30; // и т.д.

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

For(int i = 0; i < 15; i++){ myFirstArray[i] = 10; }

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

Рассмотрим создание и инициализацию массива на следующем примере. В нем мы создаем массив, содержащий цифры 0-9 и выводим значения на консоль.

//создание и инициализация массива int numberArray = new int; for(int i = 0; i < 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Упрощенная форма записи

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

Int myColor = {255, 255, 0};

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

Определение размера массива

Размер массива не всегда очевиден, поэтому для того, чтобы его узнать следует использовать свойство length, которое возвращает длину массива.

MyColor.length;

Данный код поможет нам узнать, что длина массива myColor равна 3.

Пример: Задано 4 числа, необходимо найти минимальное

Int numbers = {-9, 6, 0, -59}; int min = numbers; for(int i = 0; i < numbers.length; i++){ if(min>numbers[i]) min = numbers[i]; } System.out.println(min);

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

1. Создайте массив, содержащий 10 первых нечетных чисел. Выведете элементы массива на консоль в одну строку, разделяя запятой.
2. Дан массив размерности N, найти наименьший элемент массива и вывести на консоль (если наименьших элементов несколько — вывести их все).
3. В массиве из задания 2. найти наибольший элемент.
4. Поменять наибольший и наименьший элементы массива местами. Пример: дан массив {4, -5, 0, 6, 8}. После замены будет выглядеть {4, 8, 0, 6, -5}.
5. Найти среднее арифметическое всех элементов массива.

Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ i ] равно i-му целому числу в массиве. Массив объявляется следующим образом: сначала указывается тип массива, т.е тип элементов, содержащихся в массиве, за которым ставится пара пустых квадратных скобок, а затем - имя переменной. Например, вот как объявляется массив, состоящий из целых чисел: int a; Однако этот оператор лишь объявляет переменную а, не инициализируя ее настоящим массивом. Чтобы создать массив, нужно применить оператор new . int a = new int [ 100 ] ; Этот оператор создает массив, состоящий из 100 целых чисел. Элементы этого массива нумеруются от 0 до 99 (а не от 1 до 100). После создания массив можно заполнять, например, с помощью цикла. int а = new int [ 100 ] ; for (int i = 0 ; i < 100 ; i++ ) a[ i] = i; //Заполняет массив числами от 0 до 99 Если вы попытаетесь обратиться к элементу а (или любому другому элементу, индекс которого выходит за пределы диапазона от 0 до 99), создав массив, состоящий из 100 элементов, программа прекратит работу, поскольку возникнет исключительная ситуация, связанная с выходом индекса массива за пределы допустимого диапазона. Чтобы подсчитать количество элементов в массиве, используйте метод имя Массива.length . Например, for (int i = 0 ; i < a. length; i++ , System. out. println (a[ i] ) ) ; После создания массива изменить его размер невозможно (хотя можно, конечно, изменять отдельные его элементы). Если в ходе выполнения программы необходимо часто изменять размер массива, лучше использовать другую структуру данных, называемую списком массивов (array list). Массив можно объявить двумя способами: int a; или int a ; Большинство программистов на языке Java предпочитают первый стиль, поскольку в нем четче отделяется тип массива int (целочисленный массив) от имени переменной.

Инициализаторы массивов и безымянные массивы

В языке Java есть средство для одновременного создания массива и его инициализации. Вот пример такой синтаксической конструкции: int smallPrimes = { 2 , 3 , 5 , 7 , 11 , 13 } ; Отметим, что в этом случае не нужно применять оператор new . Кроме того, можно даже инициализировать безымянный массив: new int { 16 , 19 , 23 , 29 , 31 , 37 } Это выражение выделяет память для нового массива и заполняет его числами, указанными в фигурных скобках. При этом подсчитывается их количество и, соответственно, определяется размер массива. Эту синтаксическую конструкцию удобно применять для повторной инициализации массива без образования новой переменной. Например, выражение smallPrimes = new int { 17 , 19 , 23 , 29 , 31 , 37 } ; представляет собой укороченную запись выражения int anonymous = { 17 , 19 , 23 , 29 , 31 , 37 } ; smallPrimes = anonymous; Можно создать массив нулевого размера. Такой массив может оказаться полезным при написании метода, вычисляющего некий массив, который оказывается пустым. Массив нулевой длины объявляется следующим образом: new тип Элементов Заметим, что такой массив не эквивалентен объекту null .

Копирование массивов arrays

Один массив можно скопировать в другой, но при этом обе переменные будут ссылаться на один и тот же массив. int luckyNumbers = smallPrimes; luckyNumbers[ 5 ] = 12 ; //Теперь элемент smallPrimesтакже равен 12 Результат показан на рис. 3.1. Если необходимо скопировать все элементы одного массива в другой, следует использовать метод arraycopy из класса System . Его вызов выглядит следующим образом: System. arraycopy (from, fromlndex, to, tolndex, count) ; Массив to должен иметь достаточный размер, чтобы в нем поместились все копируемые элементы. Рис.3.1. Копирование массива Например, показанные ниже операторы, результаты работы которых изображены на рис. 3.2, создают два массива, а затем копируют последние четыре элемента первого массива во второй. Копирование начинается со второй позиции в исходном массиве, а копируемые элементы помещаются в целевой массив, начиная с третьей позиции. int smallPrimes = { 2 , 3 , 5 , 7 , 11 , 13 } ; int luckyNumbers = { 1001 , 1002 , 1003 , 1004 , 1005 , 1006 , 1007 } ; System. аrrаусору(smallPrimes, 2 , luckyNumbers, 3 , 4 ) ; for (int i = 0 ; i < luckyNumbers. length; i++ ) System. out. println (i + ": " + luckyNumbers[ i] ) ; Выполнение этих операторов приводит к следующему результату. 0 : 1001 1 : 1002 2 : 1003 3 : 5 4 : 7 5 : 11 6 : 13 Рис. 3.2. Копирование элементов массива Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив. Это значит, что оператор int a = new int [ 100 ] ; //Java эквивалентен оператору int * = new int [ 100 ] ; //C++, а не int a[ 100 ] ; //C++ В языке Java оператор пo умолчанию проверяет диапазон изменения индексов. Кроме того, в языке Java нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива. Ссылка на перво

Массив - это конечная последовательность упорядоченных элементов одного типа, доступ к каждому элементу в которой осуществляется по его индексу.

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

Индекс начального элемента - 0, следующего за ним - 1 и т. д. Индекс последнего элемента в массиве - на единицу меньше, чем размер массива.

В Java массивы являются объектами. Это значит, что имя, которое даётся каждому массиву, лишь указывает на адрес какого-то фрагмента данных в памяти. Кроме адреса в этой переменной ничего не хранится. Индекс массива, фактически, указывает на то, насколько надо отступить от начального элемента массива в памяти, чтоб добраться до нужного элемента.

Чтобы создать массив надо объявить для него подходящее имя, а затем с этим именем связать нужный фрагмент памяти, где и будут друг за другом храниться значения элементов массива.Возможные следующие варианты объявления массива: тип имя; тип имя;

Где тип - это тип элементов массива, а имя - уникальный (незанятый другими переменными или объектами в этой части программы) идентификатор, начинающийся с буквы.

Примеры: int a; double ar1; double ar2;

В примере мы объявили имена для трёх массивов. С первом именем a сможет быть далее связан массив из элементов типа int, а с именами ar1 и ar2 далее смогут быть связаны массивы из вещественных чисел (типа double). Пока мы не создали массивы, а только подготовили имена для них.

Теперь создать (или как ещё говорят инициализировать) массивы можно следующим образом: a = new int; // массив из 10 элементов типа int int n = 5; ar1 = new double[n]; // Массив из 5 элементов double ar2 = {3.14, 2.71, 0, -2.5, 99.123}; // Массив из 6 элементов типа double То есть при создании массива мы можем указать его размер, либо сразу перечислить через запятую все желаемые элементы в фигурных скобках (при этом размер будет вычислен автоматически на основе той последовательности элементов, которая будет указана). Обратите внимание, что в данном случае после закрывающей фигурной скобки ставится точка с запятой, чего не бывает когда это скобка закрывает какой-то блок.

Если массив был создан с помощью оператора new , то каждый его элемент получает значение по умолчанию. Каким оно будет определяется на основании типа данных (0 для int, 0.0 для double и т. д.).

Объявить имя для массива и создать сам массив можно было на одной строке по следующей схеме: тип имя = new тип[размер]; тип имя = {эл0, эл1, …, элN}; Примеры: int mas1 = {10,20,30}; int mas2 = new int;

Чтобы обратиться к какому-то из элементов массива для того, чтобы прочитать или изменить его значение, нужно указать имя массива и за ним индекс элемента в квадратных скобках. Элемент массива с конкретным индексом ведёт себя также, как переменная. Например, чтобы вывести последний элемент массива mas1 мы должны написать в программе:

System.out.println("Последний элемент массива " + mas1);

А вот так мы можем положить в массив mas2 тот же набор значений, что хранится в mas1:

Mas2 = 10; mas2 = 20; mas2 = 30;Уже из этого примера видно, что для того, чтоб обратиться ко всем элементам массива, нам приходится повторять однотипные действия. Как вы помните для многократного повторения операций используются циклы. Соответственно, мы могли бы заполнить массив нужными элементами с помощью цикла: for(int i=0; iПонятно, что если бы массив у нас был не из 3, а из 100 элементов, до без цикла мы бы просто не справились.

Длину любого созданного массива не обязательно запоминать, потому что имеется свойство, которое его хранит. Обратиться к этому свойству можно дописав.length к имени массива. Например:

Int razmer = mas1.length; Это свойство нельзя изменять (т. е. ему нельзя ничего присваивать), можно только читать. Используя это свойство можно писать программный код для обработки массива даже не зная его конкретного размера.

Например, так можно вывести на экран элементы любого массива с именем ar2:

For(int i = 0; i <= ar2.length - 1; i++) { System.out.print(ar2[i] + " "); } Для краткости удобнее менять нестрогое неравенство на строгое, тогда не нужно будет вычитать единицу из размера массива. Давайте заполним массив целыми числами от 0 до 9 и выведем его на экран: for(int i = 0; i < ar1.length; i++) {ar1[i] = Math.floor(Math.random() * 10); System.out.print(ar1[i] + " "); }

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

For(int i = 0; i < ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); } В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.

Для обработки массивов всегда используются циклы типа «n раз» (for) потому, что нам заранее известно сколько раз должен повториться цикл (столько же раз, сколько элементов в массиве).

Задачи

Создайте массив из всех чётных чисел от 2 до 20 и выведите элементы массива на экран сначала в строку, отделяя один элемент от другого пробелом, а затем в столбик (отделяя один элемент от другого началом новой строки). Перед созданием массива подумайте, какого он будет размера.

2 4 6 … 18 20
2
4
6
…
20

Создайте массив из всех нечётных чисел от 1 до 99, выведите его на экран в строку, а затем этот же массив выведите на экран тоже в строку, но в обратном порядке (99 97 95 93 … 7 5 3 1).

Создайте массив из 15 случайных целых чисел из отрезка . Выведите массив на экран. Подсчитайте сколько в массиве чётных элементов и выведете это количество на экран на отдельной строке.

Создайте массив из 8 случайных целых чисел из отрезка . Выведите массив на экран в строку. Замените каждый элемент с нечётным индексом на ноль. Снова выведете массив на экран на отдельной строке.

Создайте 2 массива из 5 случайных целых чисел из отрезка каждый, выведите массивы на экран в двух отдельных строках. Посчитайте среднее арифметическое элементов каждого массива и сообщите, для какого из массивов это значение оказалось больше (либо сообщите, что их средние арифметические равны).

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

Создайте массив из 20-ти первых чисел Фибоначчи и выведите его на экран. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий - сумме двух предыдущих.

Создайте массив из 12 случайных целых чисел из отрезка [-15;15]. Определите какой элемент является в этом массиве максимальным и сообщите индекс его последнего вхождения в массив.

Создайте два массива из 10 целых случайных чисел из отрезка и третий массив из 10 действительных чисел. Каждый элемент с i-ым индексом третьего массива должен равняться отношению элемента из первого массива с i-ым индексом к элементу из второго массива с i-ым индексом. Вывести все три массива на экран (каждый на отдельной строке), затем вывести количество целых элементов в третьем массиве.

Создайте массив из 11 случайных целых чисел из отрезка [-1;1], выведите массив на экран в строку. Определите какой элемент встречается в массиве чаще всего и выведите об этом сообщение на экран. Если два каких-то элемента встречаются одинаковое количество раз, то не выводите ничего.

Пользователь должен указать с клавиатуры чётное положительное число, а программа должна создать массив указанного размера из случайных целых чисел из [-5;5] и вывести его на экран в строку. После этого программа должна определить и сообщить пользователю о том, сумма модулей какой половины массива больше: левой или правой, либо сообщить, что эти суммы модулей равны. Если пользователь введёт неподходящее число, то программа должна требовать повторного ввода до тех пор, пока не будет указано корректное значение.

Программа должна создать массив из 12 случайных целых чисел из отрезка [-10;10] таким образом, чтобы отрицательных и положительных элементов там было поровну и не было нулей. При этом порядок следования элементов должен быть случаен (т. е. не подходит вариант, когда в массиве постоянно выпадает сначала 6 положительных, а потом 6 отрицательных чисел или же когда элементы постоянно чередуются через один и пр.). Вывести полученный массив на экран.

Пользователь вводит с клавиатуры натуральное число большее 3, которое сохраняется в переменную n. Если пользователь ввёл не подходящее число, то программа должна просить пользователя повторить ввод. Создать массив из n случайных целых чисел из отрезка и вывести его на экран. Создать второй массив только из чётных элементов первого массива, если они там есть, и вывести его на экран.

Сортировка массива

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

Сортировка выбором

Рассмотрим пример сортировки по возрастанию. То есть на начальной позиции в массиве должен стоять минимальный элемент, на следующей - больший или равный и т. д., на последнем месте должен стоять наибольший элемент.Суть алгоритма такова. Во всём отыскиваем минимальный элемент, меняем его местами с начальным. Затем в оставшейся части массива (т. е. среди всех элементов кроме начального) снова отыскиваем минимальный элемент, меняем его местами уже со вторым элементом в массиве. И так далее.

Иллюстрация:

For (int i = 0; i

Сортировка методом пузырька

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

2 9 1 4 3 5 2 → порядок правильный, не будет перестановки

2 9 1 4 3 5 2 → 2 1 9 4 3 5 2

2 1 9 4 3 5 2 → 2 1 4 9 3 5 2

2 1 4 9 3 5 2 → 2 1 4 3 9 5 2

2 1 4 3 9 5 2 → 2 1 4 3 5 9 2

2 1 4 3 5 9 2 → 2 1 4 3 5 2 9

Код: /* Внешний цикл постоянно сужает фрагмент массива, * который будет рассматриваться, ведь после каждого прохода * внутреннего цикла на последнем месте фрагмента будет * оказываться нужный элемент (его не надо рассматривать снова). */ for (int i = a.length - 1; i >= 2; i--) { /* В переменной sorted мы будем хранить признак того, * отсортирован ли массив. Перед каждым проходом внутреннего * цкла будем предполагать, что отсортирован, но если совершим * хоть одну перестановку, то значит ещё не конца отсортирован. * Этот приём, упрощающий сортировку, называется критерием Айверсона. */ boolean sorted = true; /* Во внутреннем цикле мы проходимся по фрагменту массива, который * определяется внешним циклом. В этом фрагменте мы устанавливаем * правильный порядок между соседними элементами, так попарно * обрабатывая весь фрагмент. */ for (int j = 0; j a) { int temp = a[j]; a[j] = a; a = temp; sorted = false; } } /* Если массив отсортирован (т.е. не было ни одной перестановки * во внутреннем цикле, значит можно прекращать работу внешнего * цикла. */ if(sorted) { break; } }

Многомерные массивы

Массив может состоять не только из элементов какого-то встроенного типа (int, double и пр.), но и, в том числе, из объектов какого-то существующего класса и даже из других массивов.

Массив который в качестве своих элементов содержит другие массивы называется многомерным массивом.Чаще всего используются двумерные массивы. Такие массивы можно легко представить в виде матрицы. Каждая строка которой является обычным одномерным массивом, а объединение всех строк - двумерным массивом в каждом элементе которого хранится ссылка на какую-то строку матрицы.Трёхмерный массив можно представить себе как набор матриц, каждую из которых мы записали на библиотечной карточке. Тогда чтобы добраться до конкретного числа сначала нужно указать номер карточки (первый индекс трёхмерного массива), потому указать номер строки (второй индекс массива) и только затем номер элемент в строке (третий индекс).

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

Объявляются массивы так: int d1; //Обычный, одномерный int d2; //Двумерный double d3; //Трёхмерный int d5; //Пятимерный При создании массива можно указать явно размер каждого его уровня: d2 = int; // Матрица из 3 строк и 4 столбцов Но можно указать только размер первого уровня: int dd2 = int; /* Матрица из 5 строк. Сколько элементов будет в каждой строке пока не известно. */ В последнем случае, можно создать двумерный массив, который не будет являться матрицей из-за того, что в каждой его строке будет разное количество элементов. Например: for(int i=0; i<5; i++) { dd2[i] = new int; } В результате получим такой вот массив: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Мы могли создать массив явно указав его элементы. Например так: int ddd2 = {{1,2}, {1,2,3,4,5}, {1,2,3}};

При этом можно обратиться к элементу с индексом 4 во второй строке ddd2 , но если мы обратимся к элементу ddd2 или ddd2 - произойдёт ошибка, поскольку таких элементов просто нет. Притом ошибка это будет происходить уже во время исполнения программы (т. е. компилятор её не увидит).

Обычно всё же используются двумерные массивы с равным количеством элементов в каждой строке.Для обработки двумерных массивов используются два вложенных друг в друга цикла с разными счётчиками.Пример (заполняем двумерный массив случайными числами от 0 до 9 и выводим его на жкран в виде матрицы): int da = new int; for(int i=0; i

Задачи

Создать двумерный массив из 8 строк по 5 столбцов в каждой из случайных целых чисел из отрезка . Вывести массив на экран.

Создать двумерный массив из 5 строк по 8 столбцов в каждой из случайных целых чисел из отрезка [-99;99]. Вывести массив на экран. После на отдельной строке вывести на экран значение максимального элемента этого массива (его индекс не имеет значения).

Cоздать двумерный массив из 7 строк по 4 столбца в каждой из случайных целых чисел из отрезка [-5;5]. Вывести массив на экран. Определить и вывести на экран индекс строки с наибольшим по модулю произведением элементов. Если таких строк несколько, то вывести индекс первой встретившейся из них.

Создать двумерный массив из 6 строк по 7 столбцов в каждой из случайных целых чисел из отрезка . Вывести массив на экран. Преобразовать массив таким образом, чтобы на первом месте в каждой строке стоял её наибольший элемент. При этом изменять состав массива нельзя, а можно только переставлять элементы в рамках одной строки. Порядок остальных элементов строки не важен (т.е. можно соврешить только одну перестановку, а можно отсортировать по убыванию каждую строку). Вывести преобразованный массив на экран.

Для проверки остаточных знаний учеников после летних каникул, учитель младших классов решил начинать каждый урок с того, чтобы задавать каждому ученику пример из таблицы умножения, но в классе 15 человек, а примеры среди них не должны повторяться. В помощь учителю напишите программу, которая будет выводить на экран 15 случайных примеров из таблицы умножения (от 2*2 до 9*9, потому что задания по умножению на 1 и на 10 - слишком просты). При этом среди 15 примеров не должно быть повторяющихся (примеры 2*3 и 3*2 и им подобные пары считать повторяющимися).

2010, Алексей Николаевич Костин. Кафедра ТИДМ математического факультета МПГУ.

В языке Java присутствуют массивы. Эти массивы типизированы. Декларация

Point myPoints;

описывает переменную myPointsкак массив объектов типаPoint. Завести массив определенного размера можно с помощью инструкции вида

myPoints = new Point;

Значения элементов массива при этом устанавливаются равными специальной величине null.

Размер массива может быть получен во время выполнения программы:

howMany = myPoints.length;

Для создания массива вы можете пользоваться квадратными скобками, расположив их справа от имени массива или от типа объектов, из которых составлен массив, например:

int nAnotherNumbers;

Допустимы оба варианта, поэтому вы можете выбрать тот, который вам больше нравится.

При определении массивов в языке Java нельзя указывать их размер. Приведенные выше две строки не вызывают резервирования памяти для массива. Здесь просто создаются ссылки на массивы, которые без инициализации использовать нельзя.

Для того чтобы заказать память для массива, вы должны создать соответствующие объекты с помощью ключевого слова new, например:

int nAnotherNumbers;

nAnotherNumbers = new int;

Как выполнить инициализацию ячеек таблицы?

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

int nColorRed = {255, 255, 100, 0, 10};

Динамическая инициализация выполняется с использованием индекса массива, например, в цикле:

int nInitialValue = 7;

int nAnotherNumbers;

nAnotherNumbers = new int;

for(int i = 0; i < 15; i++)

Возможно создавать массивы не только из переменных базовых типов, но и из произвольных объектов. Каждый элемент такого массива должен инициализироваться оператором new.

Массивы могут быть многомерными и, что интересно, несимметричными.

Ниже создается массив массивов. В нулевом и первом элементе создается массив из четырех чисел, а во втором - из восьми:

int nDim = new int;

nDim = new int ;

nDim = new int ;

nDim = new int ;

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

Массивы в языке Java являются объектами некоторого встроенного класса. Для этого класса существует возможность определить размер массива, обратившись к элементу данных класса с именем length, например:

int nAnotherNumbers;

nAnotherNumbers = new int;

for(int i = 0; i < nAnotherNumbers.length; i++)

nAnotherNumbers[i] = nInitialValue;

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

Других структурных типов (не являющихся объектами) в языке Java нет, то есть нет структур, объединений и т.п. Нет в Java и указателей.

Строки символов являются объектами типа String(текстовые константы) илиStringBuffer(изменяемые строки). Пример:

String hello = "Hello world!";