fix(guide): simplify directory structure

guide/chinese/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/chinese/java/loops/continue-control-statement/index.md

@@ -0,0 +1,51 @@
+---
+title: Continue Control Statement
+localeTitle: 继续控制声明
+---
+# 继续控制声明
+
+`continue`语句使循环在继续之后跳过所有以下行，并跳转到下一次迭代的开始。在`for`循环中，控制跳转到update语句，在`while`或`do while`循环中，控制跳转到布尔表达式/条件。
+
+```java
+for (int j = 0; j < 10; j++) 
+ { 
+    if (j == 5) 
+    { 
+        continue; 
+    } 
+    System.out.print (j + " "); 
+ } 
+```
+
+除非等于`5` ，否则将为每次迭代打印`j`的值。由于`continue` ，将跳过print语句，输出将是：
+```
+0 1 2 3 4 6 7 8 9 
+```
+
+假设你想要在`mississippi`这个词中计算`i`的数量。在这里，您可以使用带有`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/chinese/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，则循环继续，因此它将跳过下面的print语句并继续前进，直到我达到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/chinese/java/loops/do-while-loop/index.md

@@ -0,0 +1,55 @@
+---
+title: Do...While Loop
+localeTitle: 做......循环
+---
+# 做......循环
+
+`do 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`循环的条件。
+
+![: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/chinese/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 
+```
+
+：rocket： [运行代码](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 
+```
+
+：rocket： [运行代码](https://repl.it/NJfG/0)
+
+上面的两段代码片段都做了同样的工作，但是，很明显，每个循环都有利于迭代和访问集合的元素（在我们的例子中，数组）更容易。
+
+使用增强的for循环，我们不再需要提及循环的起点和终点，从而减少OutofBounds错误。 删除了对循环计数器和手动索引的需求，并且改进了代码的可读性。
+
+重要的是要注意，对循环内的增强for循环进行迭代变量的更改不会导致原始集合元素的更改。
+
+增强的for循环也可以与多维数组或其他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 
+```
+
+：rocket： [运行代码](https://repl.it/NJhP/0)
+
+在上面的代码片段中， `number_list`是一个数组。如果您不知道这是什么，请不要担心。数组是一个容器对象，它包含固定数量的单个类型的值，但稍后会有更多内容。

guide/chinese/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 
+```
+
+添加前50个数字的for循环的另一个例子是这样的。 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/chinese/java/loops/index.md

@@ -0,0 +1,24 @@
+---
+title: Loops
+localeTitle: 循环
+---
+# 循环
+
+每当您需要多次执行代码块时，通常会循环 派上用场了。
+
+Java有4种类型的循环：
+
+*   [而Loop](loops/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/chinese/java/loops/infinite-loops/index.md

@@ -0,0 +1,65 @@
+---
+title: Infinite Loops
+localeTitle: 无限循环
+---
+# 无限循环
+
+infinte循环是一个循环语句（ `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/chinese/java/loops/while-loop/index.md

@@ -0,0 +1,42 @@
+---
+title: While Loop
+localeTitle: 而Loop
+---
+# 而Loop
+
+`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` 。当`iter_While`值达到`10`时， `while`循环中断。
+
+```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)