Skip to content
Browse files

Create Java-Loops.md

Update Java-Loops.md

Update Java-Loops.md

Update Java-Loops.md
  • Loading branch information...
1 parent c12da76 commit 7e5ba3e3cadb897cb18378d5e8aa834262a8f151 @madhav-datt madhav-datt committed
Showing with 246 additions and 0 deletions.
  1. +246 −0 Java-Loops.md
View
246 Java-Loops.md
@@ -0,0 +1,246 @@
+# Java Loops
+
+Whenever you need to execute a block of code multiple times, a loop will often come in handy. In general, a loop looks something like this:
+
+![Loop Schematic Diagram](http://cse.iitkgp.ac.in/pds/notes/img/loop2.gif)
+
+## Types of Loops
+
+Java has 4 types of loops - the `while`, `do while`, `for` and `for each`. While you can pick your favorite and use that almost everywhere, each of them has certain advantages in different applications.
+
+You can use a *debugger* (a lot of IDEs have one - check out [Eclipse](http://eclipsetutorial.sourceforge.net/Debugger-Tutorial-Companion-Document.pdf), [Netbeans](https://netbeans.org/kb/docs/java/debug-visual.html), [IntelliJ](https://www.jetbrains.com/idea/help/debugging-your-first-java-application.html) etc.), [set up breakpoints](http://help.eclipse.org/mars/index.jsp?topic=%2Forg.eclipse.jdt.doc.user%2Ftasks%2Ftask-add_line_breakpoints.htm) and visualize how the following code about loops, works step-by-step.
+
+### The While loop
+
+The `while` statement evaluates the `expression` (which must return a boolean value), and if it is `true`, the `Statements` get executed.
+
+```java
+while (expression)
+{
+ // Statements
+}
+```
+
+In the following example, the `expression` is given by `iter_While < 10`. As we increment `iter_While` by `1` each time the loop is executed, the `while` loop will keep going till `iter_While` reaches `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);
+```
+
+Output:
+
+ 0 1 2 3 4 5 6 7 8 9
+ iter_While Value: 10
+
+
+### The Do While loop
+
+The `do while` is very similar to the `while` loop in the way it works, but is *exit controlled* (unlike the `for` and `while` loops which are *entry controlled*), that is, the truth value of its `expression` is evaluated after the execution of `Statements`.
+
+```java
+do
+{
+ // Statements
+}
+while (expression);
+```
+
+This kind of loop is particularly useful if you want your `Statements` to be executed atleast once, irrespective of what `expression` evaluates to. You want to do this if you are initializing a variable inside your loop and plan on using its value later.
+
+```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);
+```
+
+Output:
+
+ 20
+ iter_DoWhile Value: 21
+
+### The For loop
+
+The `for` loop give you a compact way to iterate over a range of values.
+
+```java
+for (initialization; expression; increment)
+{
+ // Statements
+}
+```
+
+* `initialization` - Initializes the loop and is executed just once, at the beginning.
+* `expression` - Evaluated at the beginning of each iteration. If the `expression` evaluates to `true`, `Statements` will get executed.
+* `increment` - Invoked after each iteration through the loop. You can increase/decrease the value of variables here.
+
+```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: " + fooFor);
+```
+
+Output:
+
+ 0 1 2 3 4 5 6 7 8 9
+ iter_For Value: 10
+
+### The For Each loop
+
+Also called the enhanced for loop, it is an extremely useful and simple way to iterate over each item in a collection, arrays as well as objects that implement the Iterable interface.
+
+```java
+for (object : iterable)
+{
+ // Statements
+}
+```
+
+The loop is read as - for each element in the `iterable` (could be an array, collectable etc.). The `object` type must match the element type of the `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
+}
+```
+
+Output:
+
+ 0 1 2 3 4 5 6 7 8 9
+
+In the above code snippet, `number_list` is an array. If you don't know what this is, don't worry about it. An array is a container object that holds a fixed number of values of a single type, but more on this later.
+
+## Loop Control Statemens
+
+### break
+
+Terminates the loop and starts the execution of the code that immediately follows the loop. If you have nested loops, the `break` statement will only end the loop in which it is placed.
+
+```java
+for (int i = 0; i < 10; i++) // Loop 1
+{
+ for (int j = 0; j < 10; j++) // Loop 2
+ {
+ if (i == 5 && j == 5)
+ {
+ break;
+ // Will terminate Loop 2, but Loop 1 will keep going
+ }
+ }
+}
+```
+
+But if you do want to break out of the outer loop too, you can use a label to exit:
+
+```java
+loop1: // This is a label
+for (int i = 0; i < 10; i++) // Loop 1
+{
+ for (int j = 0; j < 10; j++) // Loop 2
+ {
+ if (i == 5 && j == 5)
+ {
+ break loop1;
+ // Will break out of Loop 1, instead of just breaking out of Loop 2
+ }
+ }
+}
+```
+
+`break` statements can be particulary useful while searching for an element in an array. Using `break` in the following code improves efficiency as the loop stops as soon as the element we are looking for (`searchFor`) is found, instead of going on till the end of `arrayInts` is reached.
+
+```java
+int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+int searchFor = 5;
+
+for (int i : arrayInts)
+{
+ if (arayOfInts[i] == searchfor)
+ break;
+}
+```
+
+### continue
+
+The `continue` statement makes a loop skip all the following lines after the continue and jump ahead to the beginning of the next iteration. In a `for` loop, control jumps to the update statement, and in a `while` or `do while` loop, control jumps to the boolean expression/condition.
+
+```java
+for (int j = 0; j < 10; j++)
+{
+ if (j == 5)
+ {
+ continue;
+ }
+ System.out.print (j + " ");
+}
+```
+
+The value of `j` will be printed for each iteration, except when it is equal to `5`. The print statement will get skipped because of the `continue` and the output will be:
+
+ 0 1 2 3 4 6 7 8 9
+
+Say you want to count the number of `i`s in a the word `mississippi`. Here you could use a loop with the `continue` statement, as follows:
+
+```java
+String searchWord = "mississippi";
+
+// max stores the length of the string
+int max = searchWord.length();
+int count_i = 0;
+
+for (int i = 0; i < max; i++)
+{
+ // We only want to count i's - skip other letters
+ if (searchMe.charAt(i) != 'i')
+ continue;
+
+ // Increase count_i for each i encountered
+ numPs++;
+}
+```
+
+## Infinite Loops
+
+If you want your loop to go on infinitely, you can use the `while`, `do while` and `for` statement.
+
+```java
+// Infinite For Loop
+for ( ; ; )
+{
+ // your code here
+}
+
+// Infinite While Loop
+while (true)
+{
+ // your code here
+}
+
+// Infinite Do While Loop
+do
+{
+ // your code here
+}
+while (true);
+```

0 comments on commit 7e5ba3e

Please sign in to comment.
Something went wrong with that request. Please try again.