Java массивы. Массивы в 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:
- Создайте массив, содержащий 10 первых нечетных чисел. Выведете элементы массива на консоль в одну строку, разделяя запятой.
- Дан массив размерности N, найти наименьший элемент массива и вывести на консоль (если наименьших элементов несколько — вывести их все).
- В массиве из задания 2. найти наибольший элемент.
- Поменять наибольший и наименьший элементы массива местами. Пример: дан массив {4, -5, 0, 6, 8}. После замены будет выглядеть {4, 8, 0, 6, -5}.
- Найти среднее арифметическое всех элементов массива.
Инициализаторы массивов и безымянные массивы
В языке 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 нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива.
Ссылка на перво
Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ 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 нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива.
Ссылка на перво
Массивы (arrays) _ это упорядоченные наборы элементов одного типа. Элементами массива могут служить объекты простых и ссылочных типов, в том Числе и ссылки на другие массивы. Массивы сами по себе являются объектами и
наследуют класс Object. Объявление
int ia = new int;
Определяет массив с именем ia, который изначально указывает на набор из трех Элементов типа int.
В объявлении массива его размерность не указывается. Количество элементов массива задается при его создании посредством оператора new. Длина массива фиксируется в момент создания и в дальнейшем изменению не поддается. Впрочем, переменной типа массива (в нашем примере – ia) в любой момент может быть поставлен в соответствие новый массив с другой размерностью.
Доступ к элементам массива осуществляется по значениям их номеров-индексов.
Первый элемент массива имеет индекс, равный нулю (0), а последний – length – 1. Обращение к элементу массива выполняется посредством задания имени массива и значения индекса, заключенного в квадратные скобки, [ и ]. в предыдущем примере первым элементом массива ia будет ia, а последним – ia. При каждом обращении к элементу массива по индексу исполняющая система Java проверяет, находится ли значение индекса в допустимых пределах, и генерирует исключение типа ArraylndexOutOfBoundsException, если результат проверки ложен. 6 Выражение индекса должно относиться к типу int – только этим и ограничивается максимальное количество элементов массива.
Длину массива легко определить с помощью поля length объекта массива (которое неявно снабжено признаками publiс и final). Ниже приведен дополненный код прежнего примера, в котором предусмотрено выполнение Цикла, обеспечивающего вывод на экран содержимого каждого элемента массива ia:
for (int i = о; i < ia.length; i++)
system.out.println(i + ": " + ia[i]);
Массив нулевой длины (т.е. такой, в котором нет элементов) принято называть пустым. Обратите внимание, что ссылка на массив, равная значению null, и ссылка на пустой массив – это совершенно разные вещи. Пустой массив это реальный массив, в котором попросту отсутствуют элементы. Пустой массив представляет собой удобную альтернативу значению null при возврате из метода. Если метод способен возвращать null, прикладной код, в котором выполняется обращение к методу, должен сравнить возвращенное значение с null прежде, чем перейти к выполнению оставшихся операций. Если же метод возвращает массив (возможно, пустой), никакие дополнительные проверки не нужны – разумеется, помимо тех, которые касаются длины массива и должны выполняться в любом случае.
Допускается и иная форма объявления массива, в которой квадратные скобки задаются после идентификатора массива, а не после наименования его типа:
int ia = new int;
Прежний синтаксис, однако, считается более предпочтительным, поскольку описание типа в таком случае выглядит более компактным.
Модификаторы в объявлениях массивов
Правила употребления в объявлениях массивов тех или иных модификаторов обычны и зависят только от того, к какой категории относится массив – к полям или Локальным переменным. Существует единственная особенность, которую важно помнить, – модификаторы применяются к массиву как таковому, но не к его отдельным элементам. Если в объявлении массива указан признак final, это значит только то, что ссылка на массив не может быть изменена после его создания, но никак не запрещает возможность изменения содержимого отдельных элементов массива. Язык не позволяет задавать каких бы то ни было модификаторов (скажем, final или уоlatilе) для элементов массива.
Многомерные массивы
В Java поддерживается возможность объявления многомерных массивов (multidimensional arrays) (т.е. массивов, элементами которых служат другие массивы), Код, предусматривающий объявление двумерной матрицы и вывод на экран содержимого ее элементов, может выглядеть, например, так:
float mat = new float;
setupMatrix(mat);
for (int у = о; у < mat.length; у++) {
for (int х = о; х < mat[y].length; х++)
system.out.print(mat[y][x] + " ");
system.out.println();
При создании массива должна быть указана, по меньшей мере, его первая, "самая левая", размерность. Другие размерности разрешается не задавать – в этом случае их придется определить позже. Указание в операторе new единовременно всех размерностей – это самый лаконичный способ создания массива, позволяющий избежать необходимости использования дополнительных операторов new. Выражение объявления и создания массива mat, приведенное выше, равнозначно следующему фрагменту кода:
float mat = new float;
for (int у = о; у < mat.length; у++)
mat[y] = new float;
Такая форма объявления обладает тем преимуществом, что позволяет наряду с получением массивов с одинаковыми размерностями (скажем, 4 х 4) строить и массивы массивов различных размерностей, необходимых для хранения тех или иных последовательностей данных.
Инициализация массивов
При создании массива каждый его элемент получает значение, предусмотренное по умолчанию и зависящее от типа массива: нуль (0) – для числовых типов, ‘\u0000′ _ для char, false – для boolean и null – для ссылочных типов. Объявляя массив ссылочного типа, мы на самом деле определяем массив переменных этого типа. Рассмотрим следующий фрагмент кода:
Attr attrs = new Attr;
for (int i = о; i < attrs.length; i++)
attrs[i] = new Attr(names[i], values[i]);
После выполнения первого выражения, содержащего оператор new, переменная attrs получит ссылку на массив из 12 переменных, которые инициализированы значением null, Объекты Attr как таковые будут созданы только в процессе про хождения цикла.
Массив может инициализироваться (одновременно с объявлением) посредством конструкции в фигурных скобках, в которой перечислены исходные Значения его элементов:
String dangers = { "Львы", "Тигры", "Медведи" };
Следующий фрагмент кода даст тот же результат:
String dangers = new String; dangers = "Львы";
dangers = "Тигры";
dangers = "Медведи";
Первая форма, предусматривающая задание списка инициализаторов в фигурных скобках, не требует явного использования оператора new – он вызывается косвенно исполняющей системой. Длина массива в этом случае определяется Количеством значений-инициализаторов. Допускается и возможность явного задания оператора new, но размерность все равно следует опускать она, как и раньше, определяется исполняющей системой:
String dangers = new String { "Львы", "Тигры", "Медведи" };
Подобную форму объявления и инициализации массива разрешается применять в любом месте кода, например в выражении вызова метода:
printStringsCnew String { "раз", "два", "три" });
Массив без названия, который создается таким образом, называют анонимным (anonymous).
Массивы массивов могут инициализироваться посредством вложенных последовательностей исходных значений. Ниже приведен пример объявления массива, содержащего несколько первых строк так называемого треугольника Паскаля, где каждая строка описана собственным массивом значений.
int pascalsTriangle = {
{ 1, 4, 6, 4, 1 },
Индексы многомерных массивов следуют в порядке от внешнего к внутренним. Так, например, pascalsTriangle[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% медленнее чем последовательный. Возможно и в правду какую-то роль может сыграть кэш. Однако, в исходной ситуации производительность проседала в разы. Значит есть еще что-то.
Постепенно в лидеры выходит версия про дополнительные действия при переходе от одной строки массива к другой. И это правильно. Осталось разобраться, что же именно там происходит.
Теги:
- Программирование
- массивы
- память