fix(guide): simplify directory structure

guide/russian/java/loops/break-control-statement/index.md

@@ -0,0 +1,77 @@
+---
+title: Break Control Statement
+localeTitle: Заявление о нарушении правил
+---
+# Заявление о нарушении правил
+
+Завершает цикл и запускает выполнение кода, который сразу же следует за циклом. Если у вас есть вложенные циклы, оператор `break` заканчивает цикл, в который он помещается.
+
+```java
+// Loop 1 
+ for (int i = 0; i < 10; i++) 
+ { 
+    // Loop 2 
+    for (int j = 0; j < 10; j++) 
+    { 
+        if (i == 5 && j == 5) 
+        { 
+            break; // Will terminate Loop 2, but Loop 1 will keep going 
+        } 
+    } 
+ } 
+```
+
+Но если вы хотите выйти из внешнего цикла, вы можете использовать метку для выхода:
+
+```java
+loop1: // This is a label 
+ for (int i = 0; i < 10; i++) 
+ { 
+    // Loop 2 
+    for (int j = 0; j < 10; j++) 
+    { 
+        if (i == 5 && j == 5) 
+        { 
+            break loop1; // Will break out of Loop 1, instead of Loop 2 
+        } 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZA/0)
+
+операторы `break` могут быть особенно полезны при поиске элемента в массиве. Использование `break` в следующем коде повышает эффективность, поскольку цикл останавливается, как только элемент, который мы ищем ( `searchFor` ), найден, а не продолжается до конца `arrayInts` .
+
+```java
+int j = 0; 
+ int[] arrayOfInts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ int searchFor = 5; 
+ 
+ for (int i : arrayOfInts) 
+ { 
+    if (arrayOfInts[j] == searchFor) 
+    { 
+        break; 
+    } 
+    j++; 
+ } 
+ 
+ System.out.println("j = " + j); 
+```
+
+Оператор break также может использоваться под оператором while.
+
+```java
+int i = 0; 
+ int[] arrayOfInts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ int searchFor = 5; 
+ 
+ while(i < 10){ 
+ System.out.println("i = " + j); 
+ if(arrayOfInts[i] > 7){ 
+  break; 
+  } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZC/0)

guide/russian/java/loops/continue-control-statement/index.md

@@ -0,0 +1,51 @@
+---
+title: Continue Control Statement
+localeTitle: Продолжить контрольное заявление
+---
+# Продолжить контрольное заявление
+
+Оператор `continue` заставляет цикл пропускать все следующие строки после продолжения и перейти к началу следующей итерации. В цикле `for` управление переходит к оператору обновления, а через некоторое `while` или `do while` цикл while, управление переходит к логическому выражению / условию.
+
+```java
+for (int j = 0; j < 10; j++) 
+ { 
+    if (j == 5) 
+    { 
+        continue; 
+    } 
+    System.out.print (j + " "); 
+ } 
+```
+
+Значение `j` будет напечатано для каждой итерации, за исключением случаев, когда оно равно `5` . Оператор печати будет пропущен из-за `continue` и вывода:
+```
+0 1 2 3 4 6 7 8 9 
+```
+
+Скажем, вы хотите подсчитать количество `i` s в слове `mississippi` . Здесь вы можете использовать цикл с инструкцией `continue` следующим образом:
+
+```java
+String searchWord = "mississippi"; 
+ 
+ // max stores the length of the string 
+ int max = searchWord.length(); 
+ int numPs = 0; 
+ 
+ for (int i = 0; i < max; i++) 
+ { 
+    // We only want to count i's - skip other letters 
+    if (searchWord.charAt(i) != 'i') 
+    { 
+        continue; 
+    } 
+ 
+    // Increase count_i for each i encountered 
+    numPs++; 
+ } 
+ 
+ System.out.println("numPs = " + numPs); 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZH/0)
+
+Кроме того, вы можете использовать метки для выбора определенного цикла из вложенного набора, чтобы перейти к следующей итерации.

guide/russian/java/loops/control-statements/index.md

@@ -0,0 +1,49 @@
+---
+title: Jump Statements
+localeTitle: Перейти к началу страницы
+---
+# Перейти к началу страницы
+
+Операторы перехода - это тип операторов [_потока управления_](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/flow.html) . В основном вы можете использовать их для изменения порядка выполнения операторов из обычного хода выполнения. По сути, эти утверждения заставляют программный контроль «прыгать» от следующей ожидаемой точки выполнения в другое место в программе.
+
+Следующие операторы перехода обычно используются с циклами:
+
+*   [перерыв](http://forum.freecodecamp.com/t/java-loops-break-control-statement)
+*   [Продолжить](http://forum.freecodecamp.com/t/java-loops-continue-control-statement)
+
+Оператор управления «break» выходит из цикла, когда выполняется условие. Это означает, что остальная часть цикла не будет работать. Например, в цикле ниже, если я достигает 5, цикл прерывается, поэтому он не продолжается.
+
+```java
+for(int i=0;i<10;i++){ 
+ 
+  if(i == 5){ //if i is 5, break out of the loop. 
+    break; 
+  } 
+ 
+ System.out.println(i); 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 
+```
+
+Операция «continue» является менее интенсивной версией «break». Он только вырывается из текущего экземпляра цикла и продолжается. В цикле ниже, если i равно 5, цикл продолжается, поэтому он пропустит приведенный ниже оператор печати и продолжит движение до тех пор, пока не достигнет 10, и цикл остановится.
+
+```java
+for(int i=0;i<10;i++){ 
+ 
+  if(i == 5){ //if i is 5, break out of the current instance loop. 
+    continue; 
+  } 
+ 
+ System.out.println(i); 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 6 7 8 9 
+
+```

guide/russian/java/loops/do-while-loop/index.md

@@ -0,0 +1,55 @@
+---
+title: Do...While Loop
+localeTitle: Do ... While Loop
+---
+# Do ... While Loop
+
+`do while` в `while` `do while` это похоже на `while` цикл, но группа отчетности гарантирована запустить по крайней мере один раз перед проверкой данного состояния. Важно отметить, что цикл «while» представляет собой цикл управления выходом. while (это не обязательно будет выполнено), «do while» - это контур, управляемый записью (он будет выполнен хотя бы один раз, даже если условие не соответствует действительности).
+
+```java
+do 
+ { 
+    // Statements 
+ } 
+ while (condition); 
+```
+
+## пример
+
+```java
+int iter_DoWhile = 20; 
+ do 
+ { 
+    System.out.print (iter_DoWhile + " "); 
+ 
+    // Increment the counter 
+    iter_DoWhile++; 
+ } 
+ while (iter_DoWhile < 10); 
+ System.out.println("iter_DoWhile Value: " + iter_DoWhile); 
+```
+
+Вывод:
+```
+    20 
+    iter_DoWhile Value: 21 
+```
+
+**Помните** : условие цикла `do-while` while проверяется после того, как тело кода выполняется один раз.
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYl/0)
+
+## Упражнение
+
+Можете ли вы угадать вывод следующего фрагмента кода?
+
+```java
+int i = 10; 
+ do 
+ { 
+    System.out.println("The value of i is " + i); 
+    i--; 
+ } 
+ while (i >= 10); 
+
+```

guide/russian/java/loops/for-each-loop/index.md

@@ -0,0 +1,85 @@
+---
+title: For Each Loop
+localeTitle: Для каждого цикла
+---
+# Для каждого цикла
+
+Также называемый расширенным циклом `for` , это чрезвычайно полезный и простой способ перебора каждого элемента в коллекции, массиве или любом объекте, который реализует интерфейс `Iterable` .
+
+```java
+for (object : iterable) 
+ { 
+    // Statements 
+ } 
+```
+
+Цикл читается как «для каждого элемента в `iterable` (может быть массив, собираемый и т. Д.)». Тип `object` должен соответствовать типу элемента `iterable` .
+
+```java
+int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ 
+ for (int numbers : number_list) 
+ { 
+    System.out.print(numbers + " "); 
+    // Iterated 10 times, numbers 0,1,2...9 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 5 6 7 8 9 
+```
+
+: ракета: [Код запуска](https://repl.it/CJYs/0)
+
+Сравнивая это с традиционными `for` петель:
+
+```java
+int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ 
+ for(int i=0;i < number_list.length;i++) 
+ { 
+  System.out.print(number_list[i]+" "); 
+      // Iterated 10 times, numbers 0,1,2...9 
+ 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 5 6 7 8 9 
+```
+
+: ракета: [Код запуска](https://repl.it/NJfG/0)
+
+Однако обе части фрагментов кода выполняют одну и ту же работу, однако, очевидно, что для каждой петли есть преимущества в упрощении итерации и доступа элементов коллекции (массива в нашем случае).
+
+С улучшенными циклами циклов нам больше не нужно упоминать начальные и конечные точки цикла, что уменьшает ошибки OutofBounds. Потребность в счетчиках контуров и ручном индексировании удаляется, а читаемость кода улучшается.
+
+Важно отметить, что внесение изменений в переменную итерации для расширенных циклов в цикле не приводит к изменениям исходных элементов коллекции.
+
+Улучшенные для циклов также могут использоваться с многомерными массивами или другими наборами Java. Пример его использования с массивами с несколькими расширениями показан ниже:
+
+```java
+int number_list_new[][]={  {  0,  1, 2}, 
+                  {  3, 4, 5}, 
+                  { 6, 7, 8} }; 
+ 
+ // Because 2d arrays are implemented as "arrays of arrays",the first iteration variable iterates 
+ // through 3 such arrays(that is, the 3 rows of testarr[][]) 
+ for(int i[] : number_list_new) 
+ { 
+  for(int j : i){ 
+    System.out.print(j+" "); 
+  } 
+ } 
+```
+
+Вывод:
+```
+0 1 2 3 4 5 6 7 8 
+```
+
+: ракета: [Код запуска](https://repl.it/NJhP/0)
+
+В приведенных выше фрагментах кода `number_list` является массивом. Если вы не знаете, что это такое, не беспокойтесь об этом. Массив - это контейнерный объект, который содержит фиксированное число значений одного типа, но больше об этом позже.

guide/russian/java/loops/for-loop/index.md

@@ -0,0 +1,73 @@
+---
+title: For Loop
+localeTitle: Для цикла
+---
+# Для цикла
+
+Цикл `for` дает вам компактный способ итерации по целому ряду значений. Базовый `for` оператора состоит из трех частей: инициализации переменных, булевского выражения и выражения инкремента.
+
+```java
+for (variable initialization; boolean expression; increment expression) 
+ { 
+    // Statements 
+ } 
+```
+
+*   `initialization` - инициализирует цикл и выполняется только один раз, в начале.
+
+Вы можете инициализировать более одной переменной того же типа в первой части основных `for` декларации контура; каждая инициализация должна быть разделена запятой.
+
+*   `expression` - оценивается в начале каждой итерации. Если `expression` оценивается как `true` , `Statements` будут выполнены.
+*   `increment` - вызывается после каждой итерации через цикл. Здесь вы можете увеличить / уменьшить значение переменных. Убедитесь, что приращение работает над значением выражения, чтобы избежать бесконечного цикла.
+
+Общим способом использования цикла `for` является то, что вам нужно повторять ваш код определенное количество раз. Например, если вы хотите вывести числа 0-10, вы должны инициализировать переменную для вашего счетчика равным 0, а затем проверить, меньше ли это значение 10, и добавить один к счетчику после каждой итерации.
+
+Обратите внимание, что вы проверите, будет ли значение меньше 10, не менее или равно 10, так как вы начинаете свой счетчик с 0.
+
+```java
+for (int iter_For = 0; iter_For < 10; iter_For++) 
+ { 
+    System.out.print(iter_For + " "); 
+    // Iterated 10 times, iter_For 0,1,2...9 
+ } 
+ 
+ System.out.println("iter_For Value: " + iter_For); 
+```
+
+Примечание. Также допустимо объявить переменную в цикле for как один оператор.
+
+```java
+for (int iter_For = 0; iter_For < 10; iter_For++) 
+ { 
+    System.out.print (iter_For + " "); 
+    // Iterated 10 times, iter_For 0,1,2...9 
+ } 
+```
+
+Вывод:
+```
+0 1 2 3 4 5 6 7 8 9 
+ iter_For Value: 10 
+```
+
+Другой пример цикла for, который добавляет первые 50 номеров, будет таким. i ++ означает i = i + 1.
+
+```java
+int addUntil = 50; 
+ int sum 0; 
+ 
+ for (int i = 1; i <= addUntil; i++) 
+ { 
+    sum+=i 
+ } 
+ 
+ System.out.println("The sum of the first 50 numbers is: " + 50); 
+```
+
+![:rocket:](https://forum.freecodecamp.org/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYr/0)
+
+### Дополнительно
+
+Вы не можете использовать число (старая конструкция языка C-стиля) или что-либо, что не оценивает логическое значение как условие для оператора if или цикла. Вы не можете, например, сказать if (x), если x не является логической переменной.
+
+Кроме того, важно иметь в виду, что булево выражение должно в какой-то момент оценить значение true. В противном случае ваша программа застрянет в бесконечном цикле.

guide/russian/java/loops/index.md

@@ -0,0 +1,24 @@
+---
+title: Loops
+localeTitle: Loops
+---
+# Loops
+
+Всякий раз, когда вам нужно выполнить блок кода несколько раз, цикл будет часто пригодиться.
+
+Java имеет 4 типа циклов:
+
+*   [Пока цикл](loops/while-loop)
+*   [Do ... While Loop](loops/do-while-loop)
+*   [Для цикла](loops/for-loop)
+*   [Для каждого цикла](loops/for-each-loop)
+
+Поведение петлей можно настроить, используя:
+
+*   [Контрольные заявления](loops/control-statements)
+    *   [Заявление о нарушении правил](loops/break-control-statement)
+    *   [Продолжить контрольное заявление](loops/continue-control-statement)
+
+Частный случай петель:
+
+*   [Бесконечные петли](loops/infinite-loops)

guide/russian/java/loops/infinite-loops/index.md

@@ -0,0 +1,65 @@
+---
+title: Infinite Loops
+localeTitle: Бесконечные петли
+---
+# Бесконечные петли
+
+Инфинитный цикл представляет собой оператор цикла ( `for` , `while` , `do-while` ), который не заканчивается сам по себе.
+
+Условие проверки оператора цикла определяет, будет ли тело цикла выполняться или нет. Таким образом, условие проверки, которое всегда верно, будет продолжать выполнять тело цикла, навсегда. Так обстоит дело в петле infinte.
+
+Примеры:
+
+```java
+// Infinite For Loop 
+ for ( ; ; ) 
+ { 
+    // some code here 
+ } 
+ 
+ // Infinite While Loop 
+ while (true) 
+ { 
+    // some code here 
+ } 
+ 
+ // Infinite Do While Loop 
+ do 
+ { 
+    // some code here 
+ } while (true); 
+```
+
+Обычно, если ваш цикл работает бесконечно, это ошибка, которая не должна возникать, поскольку бесконечный цикл не останавливается и предотвращает запуск остальной части программы.
+
+```java
+for(int i=0;i<100;i++){ 
+ 
+    if(i==49){ 
+    i=0; 
+    } 
+ 
+ } 
+```
+
+Цикл выше работает бесконечно, потому что каждый раз, когда я приближаюсь к 49, он устанавливается равным 0. Это означает, что я никогда не достигаю 100, чтобы завершить цикл, поэтому цикл представляет собой бесконечный цикл.
+
+Но программа, застрявшая в таком цикле, будет бесконечно использовать компьютерные ресурсы. Это нежелательно и является типом «ошибки времени выполнения».
+
+Чтобы предотвратить ошибку, программисты используют оператор break для выхода из цикла. Разрыв выполняется только при определенном условии. Использование команды выбора, такой как if-else, обеспечивает то же самое.
+
+```java
+while (true) 
+ { 
+    // do something 
+ 
+    if(conditionToEndLoop == true) 
+        break; 
+ 
+    // do more 
+ } 
+```
+
+Основным преимуществом использования бесконечного цикла над регулярным циклом является читаемость.
+
+Иногда тело петли легче понять, если петля заканчивается посередине, а не в конце / начале. В такой ситуации лучшим выбором будет бесконечный цикл.

guide/russian/java/loops/while-loop/index.md

@@ -0,0 +1,42 @@
+---
+title: While Loop
+localeTitle: Пока цикл
+---
+# Пока цикл
+
+В `while` цикл многократно выполняет блок операторов , пока условие , указанное в скобках не принимает значение `false` . Например:
+
+```java
+while (some_condition_is_true) 
+ { 
+    // do something 
+ } 
+```
+
+Каждая «итерация» (выполнения блока операторов) предшествует оценке условия, указанного в круглых скобках. Операторы выполняются только в том случае, если условие имеет значение `true` . Если он оценивает значение `false` , выполнение программы возобновляется из инструкции сразу после блока `while` .
+
+**Примечание:** Для во `while` цикла , чтобы начать выполнение, нужно требовать условия , чтобы быть `true` изначально. Однако, чтобы выйти из цикла, вы должны сделать что-то внутри блока операторов, чтобы в итоге достичь итерации, когда условие оценивается как `false` (как показано ниже). В противном случае цикл будет выполняться вечно. (На практике он будет работать до тех пор, пока в [JVM не](https://guide.freecodecamp.org/java/the-java-virtual-machine-jvm) закончится память.)
+
+## пример
+
+В следующем примере `expression` дается `iter_While < 10` . Мы увеличиваем `iter_While` по `1` каждый раз, когда цикл выполняется. В `while` цикл прерывается , когда `iter_While` значение достигает `10` .
+
+```java
+int iter_While = 0; 
+ while (iter_While < 10) 
+ { 
+    System.out.print(iter_While + " "); 
+    // Increment the counter 
+    // Iterated 10 times, iter_While 0,1,2...9 
+    iter_While++; 
+ } 
+ System.out.println("iter_While Value: " + iter_While); 
+```
+
+Вывод:
+```
+0 1 2 3 4 5 6 7 8 9 
+ iter_While Value: 10 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYj/0)