Оператор while
Содержание:
Переменные в Java
Теперь пришло время рассказать о некоторых более важных вещах, лежащих в основе Java. Мало что может быть более фундаментальным в программировании, чем обучение использованию переменных!
Переменная по сути является «контейнером» для некоторых данных. Это означает, что вы выберете слово, которое будет представлять какое-то значение. Нам также необходимо определить переменные, основанные на типе данных, на которые они будут ссылаться.
Вот три основных типа переменных, которые мы собираемся ввести в этом руководстве по Java:
- Целые числа (integers) – как целые числа.
- Плавающие точки (floats) – или «переменные с плавающей точкой». Они содержат все числа, в том числе те, которые представляют десятичные дроби. «Плавающая точка» относится к десятичному разряду.
- Строки (strings)– строки содержат буквенно-цифровые символы и символы. Обычно строка используется для хранения чьего-то имени или, возможно, предложения.
Как только мы определяем переменную, мы можем вставить ее в наш код, чтобы изменить выходные данные. Например:
В этом примере кода мы определили строковую переменную с именем . Мы сделали это, используя тип данных , за которым следует имя нашей переменной, а затем данные. Когда вы помещаете что-то в двойные кавычки, то Java интерпретирует это дословно как строку.
Теперь мы печатаем на экране, как и раньше, но на этот раз заменяем «Hello world!» на «Hello + имя». Этот код показывает строку «Hello», за которой следует любое значение, содержащееся в следующей строковой переменной!
Самое замечательное в использовании переменных заключается в том, что они позволяют нам манипулировать данными, чтобы наш код мог вести себя динамически. Изменяя значение , вы можете изменить поведение программы, не изменяя никакого фактического кода!
Цикл While
Цикл while
имеет самый простой синтаксис. Вспомните if
-инструкцию, которую мы изучали чуть ранее. В условное выражение оператора if
(то, что заключено в скобочки после слова if
) можно поместить практически любую комбинацию операторов и переменных. Если выражение будет истинным (true
), то код, заключенный в тело блока if
будет выполнен. Аналогичным образом в цикле while
мы помещаем выражение, которое может вычисляться в true
или false
, как показано в этом коде:
Int x = 10;
while(x > 0){
x—;
//x уменьшается на один каждый проход цикла
}
Что здесь происходит? Первым делом за пределами цикла while
мы объявили переменную x
типа int
и присвоили этой переменной значение “10”. Далее начинается цикл while
, в условии которого написано “
x > 0”
– это означает, что код, написанный в теле цикла while
будет выполняться до тех пор, пока переменная x
больше и условие не достигнет значения false
. Следовательно, код выполнится 10 раз(x=10,x>0 ; x=9,x>0 ; x=8,x>0 ; x=7,x>0 ; x=6,x>0 ; x=5,x>0 ; x=4,x>0 ; x=3,x>0 ; x=2,x>0 ; x=1,x>0). В первый проход цикла x = 10
, во второй уже 9
, в третий 8
и т.д. И когда x
будет равен , то условие захода в цикл не выполнится, и программа продолжится со следующей строки после окончания цикла.
Также, как и в операторе if
, возможна такая ситуация, при которой цикл не будет выполнен ни разу. Взгляните на следующий пример:
Int x = 10;
while(x > 10){
//какой-нибудь код
//но он никогда не выполнится, пока x больше 10
}
Кроме того, нет ограничений на сложность выражения условия или объем кода, который может быть записан в теле цикла:
Int playerLives = 3;
int alienShips = 10;
while(playerLives >0 && alienShips >0){
//Весь игровой код здесь
//…
//…
// и т.д.
}
//программа продолжится здесь, когда или playerLives или alienShips = 0
Этот цикл будет выполняться до тех пор, пока либо переменная playerLives
, либо alienShips
не станут равны или меньше нуля. Как только одно из этих условий наступит, выражение в условии примет значение false
и программа продолжится со следующей строки после завершения цикла.
Стоит отметить, что как только программа входит в тело цикла, он будет выполнен, даже если условие цикла станет false
, где-нибудь в теле цикла, т.к. условие проверяется только при входе:
Int x = 1;
while(x > 0){
x—;
//x теперь равен 0 и условие в следующий раз примет значение false
//Но эта строка выполнится
//И эта
//И даже эта
}
В примере выше тело цикла выполнится один раз. Помимо этого, можно установить такое условие, что цикл будет выполняться вечно – это называется бесконечный цикл.
Вот пример:
Int x = 0;
while(true){
x++; //Я буду становиться очень большим!
}
Using the forEach Method
We use forEach to iterate over a collection and perform a certain action on each element. The action to be performed is contained in a class that implements the Consumer interface and is passed to forEach as an argument.
The Consumer interface is a functional interface (an interface with a single abstract method). It accepts an input and returns no result.
Here’s the definition:
Therefore, any implementation, for instance, a consumer that simply prints a String:
can be passed to forEach as an argument:
But that is not the only way of creating an action via a consumer and using forEach API.
Let’s see the 3 most popular ways in which we will use the forEach method:
3.1. Anonymous Consumer Implementation
We can instantiate an implementation of the Consumer interface using an anonymous class and then apply it as an argument to the forEach method:
This works well but if we analyze at the example above we’ll see that the actual part that is of use is the code inside the accept() method.
Although Lambda expressions are now the norm and easier way to do this, it’s still worth to know how to implement the Consumer interface.
3.2. A Lambda Expression
The major benefit of Java 8 functional interfaces is that we can use Lambda expressions to instantiate them and avoid using bulky anonymous class implementations.
As Consumer Interface is a functional interface, we can express it in Lambda in the form of:
Therefore, our printConsumer simplifies to:
And we can pass it to forEach as:
Since the introduction of Lambda expressions in Java 8, this is probably the most common way to use the forEach method.
Lambdas do have a very real learning curve, so if you’re getting started, this write-up goes over some good practices of working the new language feature.
3.3. A Method Reference
We can use method reference syntax instead of the normal Lambda syntax where a method already exists to perform an operation on the class:
Выход их цикла. Ключевое слово break
А вдруг нам действительно понадобится воспользоваться бесконечным циклом, но так чтобы мы могли решить в какой момент из него выйти. Для этой цели в Java
существует ключевое слово break
. Мы можем использовать break
, когда нам нужно будет «выйти» из цикла:
Int x = 0;
while(true){
x++; //Я буду становиться очень большим!
break; //Нет, не будешь!
//код здесь не будет достигнут
}
Наверняка вы уже догадались о том, что возможно сочетать различные инструменты принятия решений, такие как if,
else,
switch
внутри нашего цикла while
и других циклах, которые рассмотрим чуть ниже. К примеру:
Int x = 0;
int tooBig = 10;
while(true){
x++; //Я буду становиться очень большим!
if(x == tooBig){
break; //Нет, не будешь.
}
//код здесь будет доступен до тех пор пока x не станет равен 10
}
Можно исписать еще множество различных вариаций, но для нас важнее практическое применение этих знаний, так что не будем сейчас сильно углубляться. Посмотрим на еще одну концепцию, которой можно оперировать в цикле.
Чего сделать нельзя
Для любых хороших вещей (а я считаю, что является одной из них) существуют ограничения. Из-за способа реализации и особенно из-за того, что он исключает явное использование , есть вещи, которые вы не можете сделать с использованием этой новой конструкции.
Позиционирование
Наиболее заметным ограничением является невозможность определить позицию, на которой вы находитесь в списке или массиве (или специализированном объекте). Для освежения памяти просмотрите листинг 20, в котором показано, как может быть использован обычный цикл
Обратите внимание, что индексная переменная не только перемещается по списку, но также указывает позицию:
Листинг 20. Использование переменной итератора в «нормальном» цикле for
List<String> wordList = new LinkedList<String>();
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": '" + args + "'");
}
Это не надуманный пример — это общепринятая практика программирования. Однако, вы не можете выполнить эту простую задачу с циклом , как показано в листинге 21:
Листинг 21. Невозможность определения позиции в цикле for/in
public void determineListPosition(PrintStream out, String[] args)
throws IOException {
List<String> wordList = new LinkedList<String>();
// Здесь найти позицию очень просто
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": '" + args + "'");
}
// Здесь определить позицию невозможно
for (String word : wordList) {
out.println(word);
}
}
Проблема заключается в отсутствии какой-либо переменной-счетчика (или ). Если вам нужна позиция, возьмите «обычный» for. В листинге 22 приводится пример еще одного общепринятого использования позиции в цикле — работа со строками:
Листинг 22. Еще одна проблема — соединение строк
StringBuffer longList = new StringBuffer();
for (int i=0, len=wordList.size(); i < len; i++) {
if (i < (len-1)) {
longList.append(wordList.get(i))
.append(", ");
} else {
longList.append(wordList.get(i));
}
}
out.println(longList);
Удаление элементов
Еще одним ограничением является удаление элемента. Невозможность удаления элемента во время итерации по списку показана в листинге 23:
Листинг 23. Невозможно удалить элемент в цикле for/in
public void removeListItems(PrintStream out, String[] args)
throws IOException {
List<String> wordList = new LinkedList<String>();
// Присвоить несколько слов
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": " '" + args + "'");
}
// Удалить все слова, содержащие "1". Невозможно в for/in!
for (Iterator i = wordList.iterator(); i.hasNext(); ) {
String word = (String)i.next();
if (word.indexOf("1") != -1) {
i.remove();
}
}
// Вывести слова на экран можно в цикле for/in
for (String word : wordList) {
out.println(word);
}
}
Глядя глобально, это не столько ограничения, сколько правила, когда использовать , а когда . Мысль, возможно, глубокая, но бесполезная.
В заключение можно сказать, что вы никогда не попадете в ситуацию (по-крайней мере, я так думаю), когда вам будет обязательно необходим цикл . Просто рассматривайте его как красивую конструкцию, которую можно использовать для того, чтобы сделать код немного понятнее, немного лаконичнее, и все это без того сокращения кода, которое может вызвать головную боль у читателя.
- Оригинал статьи Enhance looping in Java 5.0 with for/in
- Загрузите Tiger и попробуйте его самостоятельно.
- Официальная страница J2SE 5.0 является исчерпывающим ресурсом, который вы не должны пропустить.
- Об особенностях Tiger можно узнать в серии статей Джона Жуковски (John Zukowski)Taming Tiger, в которых дается краткий обзор нововведений и изменений в J2SE 5.0.
-
Несколько статей по новым функциям в Tiger подготовил Бретт Маклафлин (Brett McLaughlin):
- Серия из двух частей по аннотированию в Tiger: «Аннотирование в Tiger, часть 1: Добавление метаданных в Java-код» и «Аннотирование в Tiger, часть 2: Пользовательское аннотирование»
- «Введение в перечислимый тип»
- В книге «Java 1.5 Tiger: Заметки разработчика» (O’Reilly & Associates; 2004, Бретт Маклафлин (Brett McLaughlin) и Дэвид Флэнаган (David Flanagan)) охвачены почти все новые функциональные возможности Tiger, включая аннотирование.
- Посетите Developer Bookstore и просмотрите исчерпывающий перечень технических книг, в котором присутствуют сотни названий, связанных с Java-технологией.
Map.forEach()
Этот метод выполняет заданное действие BiConsumer для каждой записи в этой карте, пока все записи не будут обработаны или действие не вызовет исключение.
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
Map<String, String> map = new HashMap<String, String>();
map.put("A", "Alex");
map.put("B", "Brian");
map.put("C", "Charles");
map.forEach((k, v) ->
System.out.println("Key = " + k + ", Value = " + v));
//Console Output
Key = A, Value = Alex
Key = B, Value = Brian
Key = C, Value = Charles
Как и в примере со , мы можем создать собственное действие двоякого потребителя, беря пары ключ-значение из карты и обрабатывая каждую запись по одной за раз.
BiConsumer<String, Integer> action = (a, b) ->
{
System.out.println("Key is : " + a);
System.out.println("Value is : " + b);
};
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
map.forEach(action);
Программа вывода.
Key is : A Value is : 1 Key is : B Value is : 2 Key is : C Value is : 3
Условные конструкции
Последнее обновление: 17.04.2018
Одним из фундаментальных элементов многих языков программирования являются условные конструкции. Данные конструкции
позволяют направить работу программы по одному из путей в зависимости от определенных условий.
В языке Java используются следующие условные конструкции: и
Конструкция if/else
Выражение if/else проверяет истинность некоторого условия и в зависимости от результатов проверки выполняет определенный код:
int num1 = 6;
int num2 = 4;
if(num1>num2){
System.out.println("Первое число больше второго");
}
После ключевого слова ставится условие. И если это условие выполняется, то срабатывает код, который помещен в далее в
блоке if после фигурных скобок. В качестве условий выступает операция сравнения двух чисел.
Так как, в данном случае первое число больше второго, то выражение истинно и возвращает значение
. Следовательно, управление переходит в блок кода после фигурных скобок и начинает выполнять содержащиеся там инструкции, а
конкретно метод . Если бы первое число оказалось бы меньше второго или равно ему, то инструкции в блоке if не выполнялись бы.
Но что, если мы захотим, чтобы при несоблюдении условия также выполнялись какие-либо действия? В этом случае мы можем добавить блок :
int num1 = 6;
int num2 = 4;
if(num1>num2){
System.out.println("Первое число больше второго");
}
else{
System.out.println("Первое число меньше второго");
}
Но при сравнении чисел мы можем насчитать три состояния: первое число больше второго, первое число меньше второго и числа равны.
С помощью выражения , мы можем обрабатывать дополнительные условия:
int num1 = 6;
int num2 = 8;
if(num1>num2){
System.out.println("Первое число больше второго");
}
else if(num1<num2){
System.out.println("Первое число меньше второго");
}
else{
System.out.println("Числа равны");
}
Также мы можем соединить сразу несколько условий, используя логические операторы:
int num1 = 8;
int num2 = 6;
if(num1 > num2 && num1>7){
System.out.println("Первое число больше второго и больше 7");
}
Здесь блок if будет выполняться, если равно и одновременно равно .
Конструкция switch
Конструкция switch/case аналогична конструкции , так как позволяет обработать сразу несколько условий:
int num = 8;
switch(num){
case 1:
System.out.println("число равно 1");
break;
case 8:
System.out.println("число равно 8");
num++;
break;
case 9:
System.out.println("число равно 9");
break;
default:
System.out.println("число не равно 1, 8, 9");
}
После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после операторов
сase. И если совпадение найдено, то будет выполняет соответствующий блок сase.
В конце блока сase ставится оператор break, чтобы избежать выполнения других блоков. Например, если бы убрали оператор в следующем случае:
case 8:
System.out.println("число равно 8");
num++;
case 9:
System.out.println("число равно 9");
break;
то выполнился бы блок , (поскольку переменная num равна 8). Но так как в этом блоке оператор break отсутствует, то начал бы выполняться блок .
Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить блок default,
как в примере выше. Хотя блок default необязателен.
Также мы можем определить одно действие сразу для нескольких блоков case подряд:
int num = 3;
int output = 0;
switch(num){
case 1:
output = 3;
break;
case 2:
case 3:
case 4:
output = 6;
break;
case 5:
output = 12;
break;
default:
output = 24;
}
System.out.println(output);
Тернарная операция
Тернарную операция имеет следующий синтаксис: .
Таким образом, в этой операции участвуют сразу три операнда.
В зависимости от условия тернарная операция возвращает второй или третий операнд: если условие равно , то
возвращается второй операнд; если условие равно , то третий. Например:
int x=3; int y=2; int z = x<y? (x+y) : (x-y); System.out.println(z);
Здесь результатом тернарной операции является переменная z. Сначала проверяется условие .
И если оно соблюдается, то z будет равно второму операнду — (x+y), иначе z будет равно третьему операнду.
НазадВперед
Primitive Data Types
A primitive data type specifies the size and type of variable values, and it has no
additional methods.
There are eight primitive data types in Java:
| Data Type | Size | Description |
|---|---|---|
| byte | 1 byte | Stores whole numbers from -128 to 127 |
| short | 2 bytes | Stores whole numbers from -32,768 to 32,767 |
| int | 4 bytes | Stores whole numbers from -2,147,483,648 to 2,147,483,647 |
| long | 8 bytes | Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
| float | 4 bytes | Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits |
| double | 8 bytes | Stores fractional numbers. Sufficient for storing 15 decimal digits |
| boolean | 1 bit | Stores true or false values |
| char | 2 bytes | Stores a single character/letter or ASCII values |
Каков синтаксис Java?
Прежде чем мы погрузимся в самую суть этого руководства по Java для начинающих, стоит уделить некоторое время изучению синтаксиса Java.
Синтаксис Java относится к способу написания конкретных алгоритмов. Java очень принципиален в этом вопросе, и, если вы не пишете код определенным образом, то ваша программа не будет работать!
На самом деле я написал целую статью о синтаксисе Java для разработки Android, кратко перечислю особенности синтаксиса:
- Большинство строк должно заканчиваться точкой с запятой «;».
- Исключение составляет строка, открывающая новый блок кода. Она должна начинаться открытой фигурной скобкой «{». В качестве альтернативы эту открытую скобку можно поместить на новую строку под оператором. Блоки кода – это фрагменты кода, которые выполняют определенные, отдельные задачи.
- Код внутри блока кода должен иметь отступ, чтобы отделить его от остальных.
- Открытые блоки кода должны быть закрыты закрывающей фигурной скобкой «}».
- Комментарии – это строки, которым предшествуют символы «//».
Если вы нажимаете кнопку «запустить» или «скомпилировать» и получаете ошибку, то есть большая вероятность, что вы где-то пропустили точку с запятой!
Вы никогда не перестанете делать это, и это никогда не перестанет вас раздражать. Расслабьтесь!
С этими знаниями мы сможем глубже погрузиться в руководство по Java!
Основы Java: ваша первая программа
Зайдите на compilejava.net, и вас встретит редактор с кучей готовых примеров.
(Если же вы предпочитаете использовать другую IDE или стороннее приложение, это тоже прекрасно! Скорее всего, ваш новый проект будет состоять из аналогичного кода).
Удалите все, кроме следующего:
Это то, что мы, программисты, мы называем «шаблоном» (этот код скопирован из учебника Java от Фила Данфи). Шаблонный код – так можно назвать любой код, который встречается внутри практически любой программы.
Первая строка здесь определяет «класс», который по сути является модулем кода. Затем нам нужен метод внутри этого класса, который представляет собой небольшой блок кода, выполняющий задачу. В каждой программе Java должен быть метод main, так как он сообщает Java, где начинается программа.
Об остальном поговорим чуть ниже, не беспокойтесь. Все, что нам нужно знать для этого урока Java прямо сейчас, – это то, что код, который мы действительно хотим запустить, должен быть помещен в фигурные скобки под словом «main».
Поместите сюда следующий оператор:
Этот оператор напишет слова: «Hello world!» на вашем экране. Нажмите «Compile & Execute» и вы увидите его в действии.
Поздравляю! Вы только что написали свое первое Java-приложение!
Ключевое слово continue
continue
действует почти так же, как и break
. Ключевое слово continue
выкинет вас из тела цикла, но затем проверит выражение условия, а не продолжит с места после закрывающейся фигурной скобки цикла, как это случилось бы в случае с break
. В следующем примере показано использование continue
:
Int x = 0;
int tooBig = 10;
int tooBigToPrint = 5;
while(true){
x++; //Я буду становиться очень большим!
if(x == tooBig){
break;
} //Нет, не будешь.
//код здесь будет доступен только пока x не станет равен 10
if(x >= tooBigToPrint){
//больше не будет выводиться на экран, но цикл будет продолжаться
continue;
}
//код здесь будет доступен пока x не станет равен 5
//код для вывода x на экран
}
Пояснение: объявляем и инициализируем переменные. Заходим в цикл — прибавляем к значению переменной x
единицу (теперь x
= 1). Проверка «1 равно 10?» — false
— первый оператор if
не выполняется. Следующая проверка «1 больше или равен 5?» — false
— второй оператор if
не выполняется. Выводим x
на экран.
Рассмотрим вариант, когда x
будет принимать значение 5 при входе в цикл. Заходим в цикл — прибавляем к значению переменной x
единицу (теперь x
= 6). Проверка «6 равно 10?» — false
— первый оператор if
не выполняется. Следующая проверка «6 больше или равен 5?» — true
— заходим в тело if
— continue
, выходим из цикла и проверяем условие входа в цикл.
Теперь вариант, когда x
будет принимать значение 9 при входе в цикл. Заходим в цикл — прибавляем к значению переменной x
единицу (теперь x
= 10). Проверка «10 равно 10?» — true
— заходим в тело if
— break
, выходим из цикла и код продолжится за закрывающейся фигурной скобкой цикла while
.
Циклы
Последнее обновление: 19.06.2017
Циклы являются управляющими конструкциями, позволяя в зависимости от определенных условий выполнять некоторое действие множество раз. В
C# имеются следующие виды циклов:
-
for
-
foreach
-
while
-
do…while
Цикл for
Цикл for имеет следующее формальное определение:
for (; ; )
{
// действия
}
Рассмотрим стандартный цикл for:
for (int i = 0; i < 9; i++)
{
Console.WriteLine($"Квадрат числа {i} равен {i*i}");
}
Первая часть объявления цикла — — создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип
int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 0. В данном
случае это то же самое, что и объявление переменной.
Вторая часть — условие, при котором будет выполняться цикл. Пока условное выражение возвращает true, будет выполняться цикл.
В данном случае цикл будет выполняться, пока счетчик i не достигнет 9.
И третья часть — приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: .
В итоге блок цикла сработает 9 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:
int i = 0;
for (; ;)
{
Console.WriteLine($"Квадрат числа {++i} равен {i * i}");
}
Формально определение цикла осталось тем же, только теперь блоки в определении у нас пустые: . У нас нет
инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно — бесконечный цикл.
Мы также можем опустить ряд блоков:
int i = 0;
for (; i<9;)
{
Console.WriteLine($"Квадрат числа {++i} равен {i * i}");
}
Этот пример по сути эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла.
И есть приращение счетчика уже в самом блоке for.
Цикл do
В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно,
цикл повторяется. Например:
int i = 6;
do
{
Console.WriteLine(i);
i--;
}
while (i > 0);
Здесь код цикла сработает 6 раз, пока i не станет равным нулю
Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий,
даже если условие в инструкции while не будет истинно. То есть мы можем написать:
int i = -1;
do
{
Console.WriteLine(i);
i--;
}
while (i > 0);
Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.
Цикл while
В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:
int i = 6;
while (i > 0)
{
Console.WriteLine(i);
i--;
}
Операторы continue и break
Иногда возникает ситуация, когда требуется выйти из цикла, не дожидаясь его завершения. В этом случае мы можем воспользоваться оператором
break.
Например:
for (int i = 0; i < 9; i++)
{
if (i == 5)
break;
Console.WriteLine(i);
}
Хотя в условии цикла сказано, что цикл будет выполняться, пока счетчик i не достигнет значения 9, в реальности цикл сработает 5 раз.
Так как при достижении счетчиком i значения 5, сработает оператор break, и цикл завершится.
0 1 2 3 4
Теперь поставим себе другую задачу. А что если мы хотим, чтобы при проверке цикл не завершался, а просто пропускал текущую итерацию.
Для этого мы можем воспользоваться оператором continue:
for (int i = 0; i < 9; i++)
{
if (i == 5)
continue;
Console.WriteLine(i);
}
В этом случае цикл, когда дойдет до числа 5, которое не удовлетворяет условию проверки, просто пропустит это число и перейдет к следующей итерации:
0 1 2 3 4 6 7 8
Краткие выводы
- Все логические операторы применяются к булевским выражениям, то есть таким, о которых можно сказать, true они или false.
- Если операторы , или применяются к числам, речь идёт уже не о логических операциях, а о побитовых. То есть оба числа переводятся в двоичную систему и к этим числам побитово применяют операции логического сложения, умножения или вычитания.
- В математической логике операторам и соответствуют конъюнкция и дизъюнкция.
- Логическое И похоже на умножения 1 (true) и 0 (false).
- Логическое ИЛИ напоминает поиск максимума среди 1 (true) и 0 (false).
- Для побитового отрицания целого числа a используется операция .
- Для логического отрицания булевского выражения a используется операция .
- Отрицательные числа хранятся и обрабатываются в дополнительном коде.
- Поразрядный сдвиг вправо может сохранять знак (), а может — не сохранять ().
