Sn = Sn + i
Программа:
int n, sn=0;
String input;
input=JOptionPane.showInputDialog("До какого числа суммировать:");
n=Integer.parseInt(input);
for (int i = 1; i <= n; i++)
sn+=i;
System.out.printf(“\nСумма чисел от 1 до %d равна %d ”, n, sn);
Операторы прерывания break, continue, return, System.exit
Часто требуется прерывать цикл или выполнение функции при выполнении некоторых условий и перейти на выполнение другого алгоритма или очередной итерации цикла. В Java имеются гибкие структурные средства для решения подобных проблем – это операторы break, continue, return, System.exit:
continue прерывание выполнения тела цикла и переход к следующей итерации текущего цикла,
continue метка прерывание выполнения тела цикла и переход к следующей итерации цикла, помеченного меткой,
break выход из текущего цикла,
break метка выход из цикла, помеченного меткой,
return выход из текущей функции (в том числе из тела цикла) без возвратазначения,
return значение выход из текущей функции (в том числе из тела цикла) с возвратомзначения,
System.exit( n ) выход из приложения с кодом завершения n – целым числом, задаваемым программистом (n=0 – выход нормальный, в остальных случаях – аварийный). Перед своим завершением приложение сообщает операционной системе код завершения, чтобы программист смог установить, по какой причине произошел аварийный выход,
метка идентификатор (имя), после которого ставится двоеточие. Метка может располагаться перед любым оператором. В этом случае оператор называется помеченным:
label_1: // метка
for (int i=1; i<=4; i++)
for (int j=1; j<=4; j++)
{
if (i==j)
continue label_1; // переход на метку label_1
System.out.println(“i=” + i + “ j=” +j);
}
В окне вывода появится:
i=2 j=1
i=3 j=1
i=3 j=2
i=4 j=1
i=4 j=2
i=4 j=3
При выполнении условия (i==j) внутренний цикл прерывается, и управление передается внешнему циклу – берется следующее значение i, а внутренний цикл сбрасывается на j=1.
label_1:
for (int i=1; i<=4; i++)
for (int j=1; j<=4; j++)
{
if (i!=j)
break label_1; // переход на метку label_1
System.out.println(“i=” + i + “ j=” +j);
}
В окне вывода появится:
i=1 j=1
При первом же выполнении условия (i!=j) прерывается цикл, перед которым стоит метка label_1, то есть внешний цикл, и программа заканчивает работу.
for (int i=1; i<=4; i++)
{
label_1:
for (int j=1; j<=4; j++)
{
if (i==j)
break label_1;
System.out.println(“i=” + i + “ j=” +j);
}
}
В окне вывода появится:
i=2 j=1
i=3 j=1
i=3 j=2
i=4 j=1
i=4 j=2
i=4 j=3
При первом же выполнении условия (i==j) прерывается цикл, перед которым стоит метка label_1, то есть внутренний цикл, и управление передается внешнему циклу – берется следующее значение i, а внутренний цикл сбрасывается на j=1. Такой же результат получается, если совсем убрать метку label_1 перед внутренним циклом:
for (int i=1; i<=4; i++)
for (int j=1; j<=4; j++)
{
if (i==j)
break;
System.out.println(“i=” + i + “ j=” +j);
}
Структуры данных
В повседневной практике обработки информации мы часто имеем дело с естественно организованными (объединенными) представлениями информации: текстами, списками, таблицами, анкетами. Такие организованные (структурированные) данные во многом облегчают их восприятие и обработку.
Естественная организация данных эффективно отражается в современных языках программирования понятием структур данных.
Под структурами данных понимаются специальным образом организованные совокупности данных, облегчающие реализацию алгоритма и их компьютерную обработку.
Отличительной особенность хорошо написанных программ является то, что данные в них организованы в определенные, наиболее подходящие для их хранения и обработки структуры, а сами программы являются лишь средством обработки этих структур независимо от их информационного содержания. Проектирование подходящих структур данных для их эффективной обработки программой столь же важно, и занятие это, возможно, более сложное, чем написание собственно операторов программы в соответствии с выбранным алгоритмом их обработки. Хорошо спроектированные структуры данных облегчают и ускоряют их обработку, улучшают понимание самой программы. Организация структур данных и их взаимодействия в объектно-ориентированном программировании занимает 95% объема времени написания программы.
К базовым структурам данных в Java относятся:
- переменные,
- массивы,
- строки,
- файлы.
Понятие переменных было введено раньше – это структура данных, состоящая из отдельных элементов, каждый из которых имеет имя, тип и конкретное значение.
Массивы
В программировании часто встречаются задачи, связанные с хранением и обработкой большого количества однотипных данных. Например, требуется ввести оценки по информатике для 25 студентов группы ПИ-11 и определить средний балл. Для решения этой задачи опишем 25 переменных:
int pi_11_1, pi_11_2, pi_11_3, pi_11_4… pi_11_25;
Каждая из них будет соответствовать оценке одного студента. После этого используем 25 операторов для ввода оценок:
input=JOptionPane.showInputDialog("Введите оценку первого:");
pi_11_1=Integer.parseInt(input);
input=JOptionPane.showInputDialog("Введите оценку второго:");
pi_11_2=Integer.parseInt(input);
...
input=JOptionPane.showInputDialog("Введите оценку 25-го:");
pi_11_25=Integer.parseInt(input);
И, наконец, определим средний балл:
double sr_ball;
sr_ball=(pi_11_1+pi_11_2+pi_11_3+... +pi_11_25)/25.0;
А что произойдет, если нужно будет решить эту задачу для всего университета? Описать и вводить несколько тысяч переменных?
Для решения таких задач используют массивы. Для структур, используемых в алгоритмизации, организация массивов представляется наиболее удобной для программирования. Это связано с возможностью непосредственного логического доступа к любому их элементу без обращения к предыдущим элементам. Это обеспечивает простоту интерфейса между логической организацией данных и их физическим представлением, поскольку массив легко проецируется на оперативную память. Это обстоятельство оказалось столь удобным для программирования, что для большинства структур данных разработаны механизмы их эмуляции на базе массивов.
Массив состоит из конечного числа элементов (компонент), содержимое которых относится к некоторому общему, базовому типу. При этом сам базовый тип должен быть таким, что принадлежность к нему гарантирует одинаковые размеры памяти для размещения каждой из компонент. Элементы различаются местом их размещения внутри структуры, иначе говоря, номером или индексом. Обычным является непрерывное представление массива, как логическое, так и физическое, то есть логический (описанный в программе) массив проецируется на непрерывный участок оперативной памяти. Значит, необходимо, чтобы такой участок существовал. Отсюда вытекают ограничения на размер массива, диктуемые организацией оперативной памяти: массив должен поместиться в сегмент данных программы, размеры которого фиксированы. И, конечно, данные в массивах сохраняются только до конца работы программы.
Таким образом, массив представляет собой структуру данных, определяемую на основе следующих своих свойств:
1. массив состоит из однотипных элементов, при этом используемый тип называется базовым,
2. число элементов массива строго фиксировано,
3. элементы массива упорядочены в том смысле, что каждому из них соответствует один или несколько индексов, позволяющих однозначно указать его расположение в составе структуры,
4. количество индексов, которое связано с отдельным элементом массива, определяет его размерность (одномерные, двумерные, трехмерные …),
5. число элементов массива совпадает с общим количеством возможных значений его индексов,
6. массив – именованная совокупность данных, причем использование его имени совместно с индексами позволяет определять значения его элементов,
7. доступ к элементам массива является прямым, то есть любой элемент массива полностью определяется своими индексами, и возможности доступа к нему не зависят от других элементов.
Массивы можно определить и через понятия математики.
В современной математике для описания и решения многих задач используются матрицы и вектора.
МатрицейAnm называется таблица чисел, состоящая из n строк и m столбцов.
Каждый элемент матрицы aij полностью определяется своими индексами – номерами строки i и столбца j, в которых он расположен.
Количество индексов определяет размерность матрицы: одномерная (вектор), двумерная, трехмерная и т.д.
Максимальное значение каждого индекса определяет размер матрицы.
В качестве аналога матриц в программировании выступают массивы.
Массив – это упорядоченный набор фиксированного количества однотипных компонентов, имеющих общее имя – имя массива, и различающихся значениями своих индексов. В зависимости от количества индексов компонентов (элементов) массива различают одномерные (вектора), двумерные (матрицы) и т.д. массивы.
Элементы векторов хранятся в оперативной памяти компьютера в расположенных друг за другом ячейках в том порядке, в котором они размещены в векторе. Таким образом, структура вектора полностью соответствует структуре оперативной памяти компьютера, поэтому остальные структуры данных размещаются в памяти так, как они размещались бы в одномерных массивах.
Двумерный массив состоит из элементов, образующих прямоугольную таблицу, причем первый индекс элемента обозначает номер строки, а второй – номер столбца этой таблицы, на пересечении которых расположен данный элемент:
a11 a12 a13 …
a21 a22 a23 …
a31 a32 a33 …
……………………..
Таким образом, двумерный массив полностью соответствует понятию матрицы. В оперативной памяти элементы двумерного массива расположены последовательно, строка за строкой: сначала элементы первой строки, затем второй и так далее: a11, a12, a13,…, a21, a22, a23,…, a31, a32, a33,… Значит, быстрее изменяется второй индекс (номер столбца), чем первый (номер строки).
Многомерные массивы располагаются в памяти компьютера так, что сначала изменяется последний индекс элемента, затем – предпоследний и так далее.
Массив как структура данных характеризуется тем, что с помощью индексов обеспечивается прямой (непосредственный) доступ к каждому его элементу: чтение или запись любого элемента массива не зависит от того, прочитаны или записаны предшествующие ему элементы.
Тип элементов массива называется его базовым типом. В Java это может быть любой стандартный (целый, действительный, символьный, строковый) или пользовательский (массив структур) тип данных.
Индексы элементов массива могут быть только целыми положительными числами и начинаются с нуля.
В Java все массивы являются динамическими. В процессе работы программа оперирует с данными, которые реализуются в виде простых переменных, массивов, строк и объектов. Для них нужно выделять память. Память можно выделить:
- при компиляции программы, то есть до запуска ее на выполнение,
- непосредственно при выполнении программы.
В первом случае говорят о статическом распределении памяти. Если память выделяется в процессе выполнения программы, говорят о динамическом распределении памяти.
В Java память для массивов, строк и объектов выделяется непосредственно в процессе выполнения программы, то есть динамически.
Создание массива в Java подразумевает реализацию двух этапов:
1. объявление (declaration) переменой массива (ссылки), указывающей, где в памяти компьютера он расположен:
int myArray[]; // квадратные скобки после имени!
объявлена переменная массива myArray - ссылка на массив целого типа,
2. создание непосредственно массива – выделение в памяти места для хранения его элементов оператором new и связывание его со ссылкой на массив:
myArray=new int[10];
создан массив целого типа длиной десять элементов, при этом элементы автоматически инициализируются нулями.
Как правило, эти две операции объединяются в одну:
int myArray[]=new int[10];
Размер массива можно задавать целым числом при его описании, а также переменной или константой целого типа. Значение этой переменной можно задать оператором присваивания или ввести с клавиатуры:
int n=10;
int myArray[]=new int[n];
или
public final int RAZMER=10;
int myArray[]=new int[RAZMER];
или
int n;
String input;
input=JOptionPane.showInputDialog("Задайте размер массива:");
n=Integer.parseInt(input);
int myArray[]=new int[n];
Индексация элементов массивов в Java, как и в Си, начинается с нуля. Поэтому последний элемент массива будет иметь индекс на единицу меньше его размера. Размер массива можно определить через свойство length:
n=myArray.length; // n – количество элементов в массиве
В отличие от Си, в Java выполняется автоматическая проверка выхода за пределы массива – это повышает надежность программы.
В Java можно создавать не только одномерные массивы (векторы), но и двухмерные (матрицы), трехмерные (кубы) и так далее. В этом случае количество индексов элементов определяет размерность массива: одномерные, двумерные, трехмерные…
При описании двумерного массива используются двойные квадратные скобки:
double matrica[][]=new double [3][5];
Описан двумерный массив matrica, состоящий из трех строк и пяти столбцов. Нумерация строк от 0 до 2, столбцов – от 0 до 4.
Как видно, при описании массива в Java каждая его размерность записывается в отдельных скобках, а не перечисляется через запятые, как в Паскале.
Элементы массива можно использовать во всех выражениях, операторах и функциях, определенных для их типа.
Начальные значения элементам массива в Java можно задавать при их описании (инициализировать массив), при этом размеры массивов в квадратных скобках можно не указывать – для их хранения будет отведено столько ячеек оперативной памяти, сколько значений указано в фигурных скобках:
int vect[] = new int[]{-5, 3, -2, 8, 1}; //5 элементов
double matr[][] = new double[][]{{0.2, -1.5, 3.14},
{-2.73, 25.54, 0.89}}; //2 строки и 3 столбца
Еще раз необходимо обратить внимание на то, что, в отличие от Паскаля, при описании и при работе с многомерными массивами в Java каждый индекс элемента массива заключается в отдельные квадратные скобки:
matr[1][2]=0.89;
Для вывода элементов одномерного массива (вектора) на экран используется специальная форма цикла for: