Главная › Услуги › Одномерные и многомерные. Массивы в Java

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

Tutorial

Думаю, мало кто из готовящихся к своему первому интервью, при приеме на первую работу в должности (pre)junior программиста, ответит на этот вопрос отрицательно. Или хотя бы усомнится в положительном ответе. Конечно, такая простая структура данных с прямым доступом по индексу - никаких подвохов! Нет, в некоторых языках типа JavaScript или PHP массивы, конечно, реализованы очень интересно и по сути являются много большим чем просто массив. Но речь не об этом, а о «традиционной» реализации массивов в виде «сплошного участка памяти». В этом случае на основании индексов и размера одного элемента просто вычисляется адрес и осуществляется доступ к соответствующему значению. Что тут сложного?
Давайте разберемся. Например, на Java. Просим ничего не подозревающего претендента создать массив целых чисел n x n . Человек уверено пишет что-то в духе:
int g = new int[n][n];
Отлично. Теперь просим инициализировать элементы массива чем-нибудь. Хоть единицами, хоть суммой индексов. Получаем:
for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } }
Даже чаще пишут
for(int i = 0; i < g.length; i++) { for(int j = 0; j < g[i].length; j++) { g[i][j] = i + j; } }
что тоже повод для беседы, но сейчас речь о другом. Мы ведь пытаемся выяснить, что человек знает и посмотреть, как он думает. По этому обращаем его внимание на тот факт, что значения расположены симметрично и просим сэкономить на итерациях циклов. Конечно, зачем пробегать все значения индексов, когда можно пройти только нижний треугольник? Испытуемый обычно легко соглашается и мудро выделяя главную диагональ старательно пишет что-то в духе:
for(int i = 0; i < n; i++) { g[i][i] = 2* i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } }
Вместо g[i][i] = 2* i; часто пишут g[i][i] = i + i; или g[i][i] = i << 1; и это тоже повод поговорить. Но мы идем дальше и задаем ключевой вопрос: На сколько быстрее станет работать программа? . Обычные рассуждения такие: почти в 2 раза меньше вычислений индексов; почти в 2 раза меньше вычислений значений (суммирование); столько же присваиваний. Значит быстрее процентов на 30. Если у человека за плечами хорошая математическая школа, то можно даже увидеть точное количество сэкономленных операций и более аргументированную оценку эффективности оптимизации.
Теперь самое время для главного удара. Запускаем оба варианта кода на каком-нибудь достаточно большом значении n (порядка нескольких тысяч), например, так .

Код с контролем времени

class A { public static void main(String args) { int n = 8000; int g = new int[n][n]; long st, en; // one st = System.nanoTime(); for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nOne time " + (en - st)/1000000.d + " msc"); // two st = System.nanoTime(); for(int i = 0; i < n; i++) { g[i][i] = i + i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nTwo time " + (en - st)/1000000.d + " msc"); } }

Что же мы видим? Оптимизированный вариант работает в 10-100 раз медленнее! Теперь самое время понаблюдать за реакцией претендента на должность. Какая будет реакция на необычную (точнее обычную в практике разработчика) стрессовую ситуацию. Если на лице подзащитного изобразился азарт и он стал жать на кнопочки временно забыв о Вашем существовании, то это хороший признак. До определенной степени. Вы ведь не хотите взять на работу исследователя, которому плевать на результат проекта? Тогда не задавайте ему вопрос «Почему?». Попросите переделать второй вариант так, чтобы он действительно работал быстрее первого.
Теперь можно смело заниматься некоторое время своими делами. Через пол часа у Вас будет достаточно материала, для того, чтобы оценить основные личностные и профессиональные качества претендента.
Кстати, когда я коротко описал эту задачку на своем рабочем сайте, то наиболее популярный комментарий был «Вот такая эта Ваша Java кривая». Специально для них выкладываю код на Великом и Свободном. А счастливые обладатели Free Pascal под Windows могут заглянуть

под спойлер

program Time; uses Windows; var start, finish, res: int64; n, i, j: Integer; g: Array of Array of Integer; begin n:= 10000; SetLength(g, n, n); QueryPerformanceFrequency(res); QueryPerformanceCounter(start); for i:=1 to n-1 do for j:=1 to n-1 do g := i + j; QueryPerformanceCounter(finish); writeln("Time by rows:", (finish - start) / res, " sec"); QueryPerformanceCounter(start); for i:=1 to n-1 do for j:=1 to n-1 do g := i + j; QueryPerformanceCounter(finish); writeln("Time by cols:", (finish - start) / res, " sec"); end.

В приведенном коде на Паскале я убрал «запутывающие» моменты и оставил только суть проблемы. Если это можно назвать проблемой.
Какие мы в итоге получаем вопросы к подзащитному?
1. Почему стало работать медленнее? И поподробнее…
2. Как сделать инициализацию быстрее?

Если есть необходимость копнуть глубже именно в реализацию Java, то просим соискателя понаблюдать за временем выполнения для небольших значений n . Например, на ideone.com для n=117 «оптимизированный» вариант работает вдвое медленнее. Но для следующего значения n=118 он оказывается уже в 100 (сто) раз быстрее не оптимизированного! Предложите поэкспериментировать на локальной машине. Пусть поиграет с настройками.
Кстати, а всем понятно, что происходит?

Несколько слов в оправдание

Хочу сказать несколько слов в оправдание такого способа собеседования при найме. Да, я не проверяю знание синтаксиса языка и владение структурами данных. Возможно, при цивилизованном рынке труда это все работает. Но в наших условиях тотальной нехватки квалифицированных кадров, приходится оценивать скорее перспективную адекватность претендента той работе с которой он столкнется. Т.е. способность научиться, прорваться, разобраться, сделать.
По духу это похоже на «собеседованию» при наборе легионеров в древнем Риме. Будущего вояку сильно пугали и смотрели краснеет он или бледнеет. Если бледнеет, то в стрессовой ситуации у претендента кровь отливает от головы и он склонен к пассивной реакции. Например, упасть в обморок. Если же соискатель краснел, то кровь у него к голове приливает. Т.е. он склонен к активным действиям, бросаться в драку. Такой считался годным.
Ну и последнее. Почему я рассказал об этой задаче всем, а не продолжаю использовать её на собеседованиях? Просто, эту задачу уже «выучили» потенциальные соискатели и приходится использовать другие.
Собственно на этот эффект я обратил внимание именно в связи с реальной задачей обработки изображений. Ситуация была несколько запутанная и я не сразу понял почему у меня так просел fps после рефакторинга. А вообще таких чуднЫх моментов наверное много накопилось у каждого.

Пока лидирует версия, что «виноват» кэш процессора. Т.е. последовательный доступ в первом варианте работает в пределах хэша, который обновляется при переходе за определенную границу. При доступе по столбцам хэш вынужден постоянно обновляться и это занимает много времени. Давайте проверим эту версию в самом чистом виде. Заведем массив и сравним, что быстрее - обработать все элементы подряд или столько же раз обработать элементы массива со случайным номером? Вот эта программа - ideone.com/tMaR2S . Для 100000 элементов массива случайный доступ обычно оказывается заметно быстрее. Что же это означает?
Тут мне совершенно справедливо указали (Big_Lebowski), что перестановка циклов меняет результаты в пользу последовательного варианта. Пришлось для чистоты эксперимента поставить цикл для разогрева. Заодно сделал несколько повторов, чтобы вывести среднее время работы как советовал leventov. Получилось так ideone.com/yN1H4g . Т.е. случайный доступ к элементам большого массива на ~10% медленнее чем последовательный. Возможно и в правду какую-то роль может сыграть кэш. Однако, в исходной ситуации производительность проседала в разы. Значит есть еще что-то.

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

Теги: Добавить метки

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

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

Теперь перейдем к массивам.

Массив — это структура данных, которая предназначена для хранения однотипных данных.

Допустим, Вам нужно создать 5 целочисленных переменных и задать им некоторое значение. Как Вы это будете делать? Не зная массивов, Вы скорее всего начнете писать вот так: int a = 2, b = 3, c = 5, d = 21, e = 2;

Имея в арсенале такой тип данных как массивы, Вы можете писать так: int a = {2, 3, 5, 21, 2};

Это очень удобно, когда имеет место обработка этих данных. Например, теперь Вам нужно к каждой переменной добавить 3. Если бы Вы использовали первый способ объявления, то такая операция заняла бы у Вас достаточно много времени. Тогда как имея в арсенале массивы и , мы можем обрабатывать огромное количество данных не прибегая к монотонному коду.

Перед тем как использовать, массив нужно:

Объявить;
Создать;
Инициализировать.

Запомните это порядок действий и никогда не нарушайте его.
Объявление массивов:
char s;
String p;
или
char s;
String p;
Создание массивов:
s = new char;
p = new String;

В квадратных скобках указано количество элементов массива. Это количество нельзя будет поменять потом.
Инициализация массивов:
после создания – поэлементно: int a = {1,2,3,4,5};
при объявлении/создании – массив целиком: int b = new int {2, 4 ,6};.

Если массив явно не проинициализирован, то после его создания все
элементы равны:
0 – в числовых массивах
false – в boolean-массивах
null – в массивах объектов

Границы массивов:
У всех массивов есть поле length – длина массива (в элементах)
Первый элемент всегда имеет индекс 0 (не путать со значением).
Последний элемент всегда имеет индекс length-1.

После такого количества теории, думаю, нужно немного практики:

public class ArraysInJava {

int intArray; //объявление массива

intArray = new int [ 10] ; //инициализация массива

intArray[ 0] = 1 ; //первому элементу массива даем значение 1

intArray[ 1] = 2 ; //второму значение 2

intArray[ 6] = 7 ; //остальные значения массива, которым мы

//не задали значений будут по умолчанию 0

//соответствует значению в квадратных скобках при инициалазации.

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

intArray[ i] = 45 ; //каждый элемент массива может быть изменен

Результат выполнения кода:

Мы рассмотрели одномерные массивы в Java. Сейчас пришла очередь двумерных.

Как Вы уже могли догадаться двумерный массив — это массив массивов. Не нужно пугаться. Все намного проще, чем кажется.

int twoDim = new int — вот так можно объявить двумерный массив с размерностью 4 на 4. Будет 4 элемента по вертикали и 4 по горизонтали. Задать значение таком массиву так же просто как и одномерному: twoDim = 3. Эта запись будет означать, что мы задали нашему элементу массива, которых находится во втором ряде (индекс начинается с 0) и 3 столбике. На рисунке это будет вот так:

Кстати, вот пример кода:

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

Еще пример. Точнее задание. Я хочу, чтобы Вы подумали и написали приложение, которое выводит числа в таком порядке:

Подсказка: System.out.println(); — печатает с новой строки, тогда как: System.out.print() — печатает в той самой строке.

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

Для тех, кто не осилил, предлагаю решение. Не огорчайтесь. Программирование требует времени и терпения.

public class FormatMatrixPrint {

int size = 5 ;

Java ,

Алгоритмы

Tutorial

Код с контролем времени

под спойлер

Несколько слов в оправдание

Теги:

Программирование
массивы
память

Добавить метки

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

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

Матрицы и двумерные массивы в Java

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

Общий вид матрицы размером m x n (m — количество строк, n — количество столбцов), выглядит следующим образом:

Каждый элемент матрицы имеет свой индекс, где первая цифра обозначает номер строки на которой находится элемент, а вторая — номер столбца.

Рассмотрим примеры конкретных матриц и создадим их с помощью Java.

Матрица A имеет размерность 2 на 3 (2 строки, 3 столбца). Создадим двухмерный массив этой размерности:

Int matrixA; matrixA = new int ;

Мы объявили двумерный массив целых чисел (поскольку матрица в данном случае содержит целые числа) и зарезервировали для него память. Для этого мы использовали 2 индекса: первый индекс определяет строку и ее размер, второй индекс определяет столбец и его размер.

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

MatrixA = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7;

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

For (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); }

То есть, сначала выводим все элементы первой строки, отделяя их символом табуляции "\t", переносим строку и выводим все элементы второй строки.

Полностью код для матрицы А выглядит следующим образом:

Public class Matrix { public static void main(String args) { int matrixA; matrixA = new int; matrixA = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7; for (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); } } }

Для матрицы B воспользуемся упрощенным способом инициализации — в момент объявления. По аналогии с одномерными массивами.

Int matrixB = { {-9,1,0}, {4,1,1}, {-2,2,-1} };

Каждую строку массива необходимо заключить в пару фигурных скобок и отделить друг от друга запятой.

Полностью код для матрицы B :

Public class Matrix { public static void main(String args) { int matrixB = { {-9,1,0}, {4,1,1}, {-2,2,-1} }; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixB[i][j] + "\t"); } System.out.println(); } } }

Рассмотрим инициализацию в цикле для двумерного массива на примере таблицы умножения.

Public class Mult { public static void main(String args) { // создаем двумерный массив 10 на 10 int multiplyTab = new int; // цикл по первой размерности for (int i = 0; i < 10; i++) { // цикл по второй размерности for (int j = 0; j < 10; j++) { //инициализация элементов массива multiplyTab[i][j] = (i+1)*(j+1); //вывод элементов массива System.out.print(multiplyTab[i][j] + "\t"); } System.out.println(); } } }

Здесь инициализация элементов значениями таблицы умножения совмещена с их выводом на консоль в одном цикле.

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

Создаются многомерные массивы в Java аналогичным способом. Количество квадратных скобок указывает на размерность.
Примеры создания массивов фиксированной длины:

Int a = new int;// двумерный массив int b = new int;// трехмерный массив int c = new int;// четырехмерный массив // и т.д.

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

Int a1 = new int;// двумерный массив с 5 строками

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

A1 = new int ; a1 = new int ; a1 = new int ; a1 = new int ; a1 = new int ;

В результате, при выводе на экран,

For(int i = 0; i

массив будет иметь такой вид:

0
0 0
0 0 0
0 0 0 0
0 0 0 0 0

При создании массива его элементы автоматически инициализируются нулями, поэтому в это примере на экран выведены нули.

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

Создайте массив размерностью 5 на 6 и заполните его случайными числами (в диапазоне от 0 до 99). Выведите на консоль третью строку
Даны матрицы С и D размерностью 3 на 3 и заполненные случайными числами в диапазоне от 0 до 99. Выполните по отдельности сначала сложение, потом умножения матриц друг на друга. Выведете исходные матрицы и результат вычислений на консоль.
Просуммируйте все элементы двумерного массива.
Дан двумерный массив, содержащий отрицательные и положительные числа. Выведете на экран номера тех ячеек массива, которые содержат отрицательные числа.
Отсортируйте элементы в строках двумерного массива по возрастанию

Массив — это множество однотипных объектов, которые имеют общее название. К каждому элементу массива возможен доступ по его индексу. Рассмотрим реальный пример. Пусть у нас есть некоторый склад, который называется a и пусть в нем есть некоторое количество ящиков, каждый из которых последовательно пронумерован. В каждом ящике лежит некоторый объект, который по своему типу совпадает с объектами в других ящиках. Пример данного склада является классическим массивом, где название склада — это название массива, ящики — это элементы массива, номера ящиков — это индексы элементов, а содержимое ящиков — это значения наших переменных. Представим, что внутри ящиков лежат лимоны, и в каждом ящике лежит определенное количество лимонов. Тогда, значения наших переменных будут показывать количество лимонов. Рассмотрим такой склад, состоящий из трех ящиков, пусть в первом ящике лежит 3, во втором 7, в третьем 273. Тогда, массив, описывающий данный склад можно изобразить следующим образом:

Индекс	0	1	2
Значение	3	7	273

Индексация в массиве всегда начинается с 0. Рассмотрим некоторые операции, которые можно производить с массивом:

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

Тип имяПеременной;
int a;//целочисленный массив
char b;//массив символов
String c;

Выделение памяти:

A = new int;//выделяем память под 10 элементов
b = new char;//выделяем память под 20 элементов
c = new String;//выделяем память под 30 элементов

Таким образом инициализация массива выглядит следующим образом:

Int a = new int;//инициализация массива целых чисел из 10 элементов
char b = new char;//инициализация массива символов из 20 элементов
String c = new String;//инициализация массива строк из 30 элементов

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

Int a = new int{ 3, 7, 273 };

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

Считывание массива:

Import java.util.Scanner;
public class test {
public static void main(String args) {
int a;//массив целых чисел
int n;//количество элементов в массиве
Scanner in = new Scanner(System.in);
n = in.nextInt();
a = new int[n];
for(int i = 0; i Изменение значений массива:

for(int i = 0; i Вывод массива:

Int a;//массив целых чисел, который был как - то обработан
for(int i = 0; i Произвольный доступ к элементу массива по индексу:

System.out.println(a);//Выводим первый элемент массива
a = 1;//Присваиваем второму элементу массива 1
int temp = a;//Сохраняем значение третьего элемента массива в переменную temp

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

Двумерные массивы

Не всегда бывает удобно нумеровать ящики на складе с 0 до определенного числа, иногда хочется привести склад в более упорядоченный вид, например ввести ряды. Теперь каждый ящик имеет свой номер ряда и свой порядковый номер в этом ряду. Пусть на нашем складе есть девять ящиков, которые имеют содержат 1, 2 и так далее 9 апельсинов. Ящики на складе располагаются в три ряда по три ящика, тогда ситуацию на складе можно представить так.