Неограничен за (Java) цикъл

В Java, както и в почти всеки език за програмиране, има инструменти за осигуряване на повторение на определено парче код или, както се наричат, цикли. Циклите в Java се представят от оператори като за и докато, както и от разновидностите им. По правило циклите се използват за преминаване през едномерни и многоизмерни масиви и повторени структури от данни (включително колекции), за да се намерят определени елементи и допълнителни операции с тях. Това обаче не е единственият начин да използвате инструмент като Java цикъла. Примери за използване ще бъдат дадени, тъй като те се разглеждат.

Циклирайте докато Java: Описание и примери

Основният извод на цикъла в Java е докато. Кодовият фрагмент, затворен в тялото му, ще бъде повторен, докато състоянието на израза е затворено в скоби, след като ще задоволи логическата стойност на истината. Общата формулировка на декларацията за време е:

докато (условие) {

// тялото на цикъла

}

Веднага щом стойността на логическото условие престане да бъде вярно, кодът, включен в тялото на цикъла, ще престане да се изпълнява и контролът ще бъде прехвърлен на непосредствено следващия ред. Ако има само един оператор в тялото на цикъла, скобите не могат да бъдат настроени, но се считат за добра форма, ако винаги стоят. Фигурата по-горе показва блокова диаграма на работата на този оператор.

За по-голяма яснота нека да разгледаме примера, показан на фигурата по-долу:

Обявеният брой на променливите първоначално има стойност 1. След това виждаме логически израз, затворен в скоби след името на оператора. Това ще бъде вярно, т.е. return true, докато броят е по-малък или равен на 10. В тялото на цикъла, с всяка итерация, стойността на променливата се увеличава с 1 и се показва на екрана на конзолата. Имайте предвид, че когато стойността на променливата достигне 11, цикълът спря.

Ако стойността на променливото число първоначално е равна на 11, тогава състоянието на цикъла би било невярно и програмата дори няма да отиде в тялото му.

Струва си да се отбележи, че синтаксисът Java ви позволява да използвате изявлението while без тяло. Нека да дадем пример. Да предположим, че имаме две променливи i = 100 и j = 200, ние сме изправени пред задачата да програмираме изчисляването на техния аритметичен знак - можете да използвате "кухи", докато:

докато (++ i < --j);

В резултат на това стойността на всяка от двете променливи ще бъде равна на средната стойност на техните първоначални стойности. Както можете да видите, цикълът работи перфектно без тяло и изпълнява всички необходими действия в условен израз.

Докато въртиш

В предишните примери, ако условният израз първоначално е върнал невярно, тогава изпълнението на програмата ще игнорира тялото на цикъла и ще продължи. Често обаче има ситуации, при които изпълнението на кода, съдържащ се в тялото на цикъла, задължително поне веднъж, независимо от валидността на условния израз. С други думи, се оказва, че не е необходимо да проверявате валидността на условен израз в началото, а в края на цикъла. Тази функционалност може да бъде осигурена от нещо като "докато". Тя има следната форма:

да {
// тялото на цикъла

} докато (условие);

Както можем да видим, тялото на бримката е изпълнено за първи път и едва тогава истината за състоянието е проверена - и така нататък.

Кодът по-горе ще работи по същия начин, както при обичайното време. Ако обаче дадем променливата за преброяване на стойност 11, тялото ще бъде изпълнено още веднъж, преди операторът да може да провери валидността на израза.

Описание и примери за - Java цикъл

За цикъл е универсална и ефективна езикова форма в Java. Преди петата версия на Java SDK имаше само една традиционна форма на декларацията, а след това нова за всеки. В тази секция ще се запознаем с традиционната форма на оператора. за Java, цикълът изглежда така:

Преди контролът да бъде предаден на кода в тялото на цикъла, първо се извършва инициализирането на променливата i, служеща като брояч. След това проверяваме условния израз, в който броячът се сравнява с определена стойност и ако се върне вярно, тялото на бримката се изпълнява. Тогава стойността на брояча се променя до предварително определена стъпка и условният израз се проверява отново и т.н., докато условието стане невярно. Диаграмата по-долу илюстрира всички фази на цикъла.

За да разберем по-добре, нека да дадем пример за това как функционира Java loop:

Виждаме, че в loopVal променлива се използва като брояч. След всяка итерация, стойността му ще нарасне с 1, и това ще се случи до тогава, докато не достигне 11. Имайте предвид, че променливата на контрол може да бъде обявена извън за изявление, но ако не искате да използвате тази променлива навсякъде с изключение на в цикъла, е препоръчително да го декларират директно в отчета. Имайте предвид, че една променлива, декларирано в отчета има обхват в рамките на една и съща този цикъл.

Има ситуации, в които искате да декларирате няколко променливи за контрол на веригата. За Java цикълът ви позволява да зададете две или повече променливи, разделени със запетая, и да правите това както по време на инициализация, така и повторение. Такъв оператор ще има следната форма:

за (int i = 1, int j = 10-i < j- ++ i, -j) {}

При всяка итерация стойността на променливата i ще се увеличи с 1, а стойността на променливата j ще се понижи с 1. Итерекциите ще бъдат изпълнени, докато i стане по-голяма или равна на j.

Характеристики на използването на за изявление

Корпусът for е сравнително гъвкава конструкция, тъй като всичките три части (инициализация, състояние и увеличение / намаляване) не могат да се използват по предназначение. Например, вместо условен израз с контролна променлива, можете да замените всяка логическа променлива.

boolean exit = false;

за (int i = 0-! exit- ++ i) {

exit = true;

}

В горния пример можем да видим как работния цикъл е напълно независима от управляема променлива аз и броя на повторенията зависи изцяло от кое време на излизане променлива ще бъде настроен на истина. Освен това, контролната променлива може да бъде напълно премахната от цикъла и това не оказва влияние върху нейната работа: за (-! Exit-) {}. Въпреки че това не е най-разумният начин за програмиране, понякога може да бъде полезно. Основното нещо е да се осигури ситуация, в която променливата взема необходимата стойност, за да излезе от веригата, за да не се превърне в безкрайна стойност.

За Java, една линия може да бъде обявена по този начин: за (- -) {}. Това е типичен пример за безкраен цикъл със специални условия на прекъсване. За това как да прекъснете този тип цикли, ние ще говорим малко по-късно.

Циклирайте по стил за всеки

Преден Java цикъл винаги се използва за последователно изброяване на масив елементи или някои структури от данни и извършване на определени повтарящи се операции върху тях. Пример за тази форма на изявлението за е показан по-долу:

Като итеративна променлива, името се декларира, а преди това обявеният масив от имена е вторият аргумент на оператора. Името на променливата ще вземе стойностите на всеки елемент от масива едно по едно, докато всички негови елементи бъдат извлечени. Трябва да се отбележи, че типът на променливата трябва да е съвместим с типа елементи, които се съхраняват в масива. Също така, променливата на името е само за четене и опитът да се промени, няма да промени самия елемент в масива.

Оператори за прекъсване на цикъла

Има три прекъсвания за цикъла: прекъсване, връщане и продължаване. Първите две могат напълно да прекъснат цикъла и продължават да прекъсват само работата на текущата итерация. Ако използвате умишлено безкраен Java цикъл във вашия код, тези оператори трябва да присъстват в него. Помислете за един прост пример за използване на почивка:

Въпреки че е осигурено това твърдение за 11 повторения, изпълнени само 8, защото, когато брояч I е равен на 7, работа състояние, при което тялото има изявление почивка.

Декларацията за връщане действа по подобен начин, с изключение на това, че тя не само осигурява излизане от Java цикъла, но и от метода, по който е поставена тази линия.

Използване на прекъсване като

Трябва да се има предвид, че прекъсването прекъсва работата само на този цикъл в тялото, на което то се намира директно, т.е. Ако го използвате във вложен цикъл, външната верига няма да спре да работи. За тази цел изявлението за прекъсване може да се използва като цивилизована форма на гото.

В тази версия този оператор се използва заедно с етикета, който ви позволява да организирате изхода не само от циклите, но и от всеки блок от код. Етикетът е подходящо обозначен идентификатор с двоеточие след него. Етикетът е обявен в началото на отбелязания блок от код. За да прекъснете изпълнението на маркиран блок на правилното място, трябва да декларирате: break name_name. Обърнете внимание на примера от фигурата по-долу:

Кодът декларира три блока с имената на етикетите Едно, Две и Три, съответно. Декларацията за пауза с етикета "Две" е вложена и в трите блока, но когато се задейства, програмата ще излезе от три и два блока и ще продължи изпълнението в блока "Един". Т.е. в конзолата ще видим две съобщения: Три и Едно.

заключение

Научихме за концепцията за цикли в Java, главното време и за изявления, както и за тяхното изпълнение и съответно за всяка форма. За по-добро разбиране препоръчваме да правите упражнения, които използват тези оператори в различни форми, както и различни начини да ги прекъснете и да преместите от един блок в друг.