ЗАМЕТКА НЕДООФОРМЛЕНА. ЧУТЬ ПОЗЖЕ ИЗМЕНЮ.
Интересно задание и элегантное решение удалось обнаружить на просторах сети по Java. Считаю целесообразным опубликовать его здесь и разобрать по строкам. Суть задания: пользователь вводит 5 чисел и программка выводит их по мере возрастания. Код:
public class array {
public static void main(String[] args) throws Exception
{
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int[] a = new int[5];
for (int i = 0; i < 5; i++){
a[i] = Integer.parseInt(reader.readLine());
}
for (int i = 0; i < a.length; i++){
int min = a[i];
int minIndex = i;
for (int j = i + 1; j < a.length; j++){
if (a[j] < min){
min = a[j];
minIndex = j;
}
}
if (i != minIndex){
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
System.out.println(a[i]);
}
}
}
Наш класс называется Array — то есть массив. По-научному массив — это конечная последовательность упорядоченных элементов одного типа, доступ к каждому элементу в которой осуществляется по его индексу.
Объявляется так: тип[] имя;
тип имя[];
Где тип — это тип элементов массива, а имя — уникальный (незанятый другими переменными или объектами в этой части программы) идентификатор, начинающийся с буквы.
Пример: String[] kotiki = new String[5]; Мы объявили массив kotiki типа String (строка), который будет содержать 5 значений.
Пример:
String[] kotiki = new String[5]; kotiki[0] = "Пусь"; kotiki[1] = "Мурчик"; kotiki[2] = "Барсик"; kotiki[3] = "Мурзик"; kotiki[4] = "Китякет"; System.out.println(kotiki[2]);
Обращение к элементу массива происходит так — имя массива и в квадратных скобках порядковый номер элемента. Так вышеприведённый код выведет значение «Барсик» на экран ( System.out.println(kotiki[2]) )
Обратите внимание, что нумерация значений массива начинается ноля! Однако, если добавить вот такую строку:
System.out.println(kotiki.length);
то увидим, что система нам выдаст число «5». Метод length() возвращает длину строки, в нашем случае количество элементов в массиве. Следует обратить внимание на то, что индекс значения массива мы считаем с числа ноль, однако метод «ведёт отсчёт» с единицы.
Внутри метода main строка
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); [java] является более короткой записью кода из предыдущей &amp;amp;lt;strong&amp;amp;gt;&amp;amp;lt;a href="http://makson.ru/zavedyom-dzhavu-vneurochnaya-zametka-1/"&amp;amp;gt;внеурочной заметке&amp;amp;lt;/a&amp;amp;gt;&amp;amp;lt;/strong&amp;amp;gt;. сравните [java] InputStream inputStream = System.in; Reader inputStreamReader = new InputStreamReader(inputStream); BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
Напоминаю для ввода данных используется System.in. Но System.in позволяет считать с клавиатуры только коды символов. Чтобы считать строку с клавиатуры, можно использовать объект BufferedReader. Но для этого в него нужно передать объект, из которого он будет вычитывать данные – System.in.
Однако System.in и BufferedReader не совместимы друг с другом, поэтому следует использовать переходник – еще один объект InputStreamReader.
Строка
int[] a = new int[5];
— создаёт массив типа Int (целочисленные числа), состоящий из 5 элементов.
for (int i = 0; i &amp;amp;lt; 5; i++){
a[i] = Integer.parseInt(reader.readLine());
}
— цикл for, состоящий из 5 итераций. При каждой итерации элемент массива «a» получает значение, введённое с клавиатуры.
reader.readLine()
— считывает строку, а
Integer.parseInt
преобразовывает строку число.
В результате чего мы должны будем 5 раз ввести числа с клавиатуры для заполнения массива «a,» состоящего из 5 элементов.
Далее у нас идёт цикл в цикле. Разберём его.
for (int i = 0; i &amp;amp;lt; a.length; i++){
int min = a[i];
int minIndex = i;
for (int j = i + 1; j &amp;amp;lt; a.length; j++){
if (a[j] &amp;amp;lt; min){
min = a[j];
minIndex = j;
}
}
if (i != minIndex){
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
System.out.println(a[i]);
}
Разберём на примере. Допустим мы ввели следующие числа: 6 4 8 3 5, что же произойдёт?
a[0] = 6;
a[1] = 4;
a[2] = 8;
a[3] = 3;
a[4] = 5;
Как мы видим у нас есть цикл в цикле. Для удобство будем обозначать их так 1-1, 1-2, 1-3 и т.д…
Итерация 1-1.
Начало первой итерации. Переменная i равна 0. Цикл работает пока i меньше a.length. Метод length считает количество элементов массива. Считает, начиная с 1, а не с 0! Стало быть a.length равно 5. Ну и конечно же i увеличивается на 1, иначе цикл станет бесконечным.
переменная min равна a[i]. Если i у нас 0, значит a[0]. А это у нас число 6 из введённого массива. Стало быть на данном этапе переменная min равна 6.
minIndex равно 0 соответственно. Начинается внутренняя итерация, в которой переменная j равна i плюс один. Соответственно j равно 0 + 1, то есть j = 1.
Условный цикл выполняется в данном случае. a[j] это a[1], то есть второй элемент массива, имеющий значение 4. 4 меньше 6. А стало быть переменная min равна a[j], то есть a[1], стало быть min вместо 6 теперь равна 4! А minIndex равен j, а значит единице, вместо 0!
Обратите внимание, что изменилось значение переменных выше второго цикла.
int min = a[i]; // min : 4 (а было min : 6) int minIndex = i; // minIndex : 1 (а было minIndex: 0).
Итерация 1-2.
j = 2.
a [j] = a[2] = 8. Восемь не меньше переменной min, поскольку min = 4. Стало быть условный цикл не выполнится и мы переходим к итерации 1-3.
Итерация 1-3.
j = 3. a[j] = a[3]. Стало быть a[3] рано 3. min = 4, стало быть условный цикл выполняется — 3 меньше 4.
min = a[j], стало быть min = a[3] = 3.
minIndex также равен 3 (индекс массива у нас ведь тоже 3).
Итерация 1-4.
j = 4. a[j] = a[4] = 5. min = 3. 5 не меньше 3, стало быть условный цикл не выполнится и мы переходим к следующему блоку кода.
if (i != minIndex){
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
System.out.println(a[i]);
i = 0; Почему 0? Да потому что эта переменная i относится к первому циклу for! minIndex = 3.
0 не равно 3, стало быть условие выполнится.
int temp = a[i] = a[0] = 6;
a[i] = a [minIndex] то есть a[0] = a[3]
то есть a[0] = 3!
a[minIndex] = temp, то есть a[3] = 6.
System.out.println(a[i]) = System.out.println(a[3]); = System.out.println(3); То есть первое число, которое покажет программа - 3, наименьшее. Теперь обратите внимание вот на что: благодаря конструкции
int temp = a[i]; a[i] = a[minIndex]; a[minIndex] = temp;
a[3] равно 6 [temp], а стало быть в массиве int[] a = new int[5]; произошли изменения. Было:
a[0] = 6;
a[1] = 4;
a[2] = 8;
a[3] = 3;
a[4] = 5;
Но теперь a[i] = a[minIndex], то есть a[0] = a[3]; А значит теперь массив выглядит так:
a[0] = 3;
a[1] = 4;
a[2] = 8;
a[3] = 3;
a[4] = 5;
Смотрим дальше
a[minIndex] = temp; то есть a[3] = 6 (ведь int temp = a[i] то есть int temp = 6!). И картина выглядит так: a[0] = 3; a[1] = 4; a[2] = 8; a[3] = 6; a[4] = 5;
Переходим к циклу 2! i = 1;int min = a[i]; => int min = a[1] => int min => 4; int minIndex = i; => int minIndex = 1;
Переходим к внутреннему циклу. Итерация 2-1.
int j = i + 1; j < a.length; j++ => int j = 1 + 1; j < 5; j = 2 + 1; Условие не выполняется! a[j] < min => a[2] < min => a[2] = 8 < min = 4 => 8 < 4 8 никак не может быть меньше 4, значит условие не выполнится! Понятно, почему 8? Напоминаю, массив считают с 0! Итерация 2-2.
int j = 3; j < 5; j = 3 + 1;
a[j] < min => a[3] < min => a[3] = 6 < min = 4 => 6 < 4
6 никак не может быть меньше 4, значит условие не выполнится!
Итерация 2-3
int j = 4; j < 5; j = 4 + 1;
a[j] < min => a[4] < min => a[4] = 5 < min = 4 => 5 < 4
5 никак не может быть меньше 4, значит условие не выполнится!
Теперь переходим к следующему блоку
&lt;pre&gt;if (i != minIndex){
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
System.out.println(a[i]);&lt;/pre&gt;
&amp;nbsp;
А чему у нас равно i в первом цикле? Правильно i = 1. А чему равен minIndex? Точно тоже 1. А стало быть условный цикл не выполнится! И нам останется только вывести на экран a[i], то есть a[1] = 4!
Итерация 3.
int min = a[i]; => int min = a[2] => int min => 8; int minIndex = i; => int minIndex = 2;
Переходим к внутреннему циклу. Итерация 3-1.
int j = i + 1; j < a.length; j++ => int j = 2 + 1; j < 5; j = 3 + 1;
a[j] < min => a[3] < min => a[3] = 6 < min = 8 => 6 < 8
Условный цикл выполняется!
min = a[3]; => min = 6;
minIndex = 3;
Итерация 3-2.
int j = i + 1; j < a.length; j++ => int j = 4; j < 5; j = 4 + 1;
a[j] < min => a[4] < min => a[4] = 5 < min = 6 => 5 < 6; Условие выполняется! min = a[4]; => min = 5; minIndex = 4; Далее переходим к условному циклу, поскольку итерации закончились - пять не меньше a.length, которое, собственно и равно пяти. i = 2; minIndex = 4; Так что условный цикл выполняется. int temp = a[i]; => int temp = a[2]; => int temp = 8; a[i] = a[minIndex]; => a[2] = a[4]; => a[2] = 5;
a[minIndex] = temp; => a[4] = temp; a[4] = 8;
Осталось только вывести на экран.
System.out.println(a[2]); То есть цифра 5.
Обратите внимание, как изменились значения массива!
Итерация 4.
i = 3;
int min = a[i]; => int min = a[3]; => int min = 6;
int minIndex = 3;
Переходим к внутренней итерации.
Итерация 4-1.
int j = i + 1; j < a.length; j++ => int j = 3 + 1; j < 5; j = 4 + 1;
a[j] < min => a[4] < min => a[4] = 8 < min = 6 => 8 < 6 Не выполняется! 8 не меньше 6. Внутренние итерации закончились! Переходим к условному циклу.
</pre><pre>if (i != minIndex){
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
System.out.println(a[i]);
i = 3; minIndex = 3; Значит условный цикл не выполняется! Осталось просто вывести на экран число.
System.out.println(a[i]); => System.out.println(a[3]); => System.out.println(6);
Итерация 5.
i = 4;
int min = a[i]; => int min = a[4]; => int min = 8;
int minIndex = 4;
Итерация 5-1.
int j = i + 1; j < a.length; j++ => int j = 4 + 1; j < 5; j = 5 + 1; Как бы так, да вот и не так.
Не один цикл не выполнится, поскольку 5 не можеть быть меньше 5. Переходим к условному циклу.
i = 4; minIndex = 4; Стало быть условный цикл не выполнится. Осталось вывести число на экран.
System.out.println(a[i]); => System.out.println(a[4]); => System.out.println(8); На этом все. Программа звершила свои действия. Оох чувствую сумбурное объяснение вышло, поэтому есть предложение снять маленький видеоролик.
