Loops III

Author: bowbahdoe

src/SUMMARY.md

@@ -564,9 +564,16 @@ Make them do one. -->
   - [Recurse Over a String](./recursion/recursing_over_strings.md)
   - [Recurse Over an Array](./recursion/recursing_over_arrays.md)
 
-<!--- [HashMap](./hash_map.md)
-- [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
-- [Iterable and Iterator](./iterable_and_iterator.md)
+- [Loops III](./loops_iii.md)
+  - [For-each loops](./loops_iii/for_each_loops.md)
+  - [Arrays](./loops_iii/arrays.md)
+  - [Iterable and Iterator](./loops_iii/iterable_and_iterator.md)
+  - [ArrayList](./loops_iii/arraylist.md)
+  - [String](./loops_iii/string.md)
+  - [Concurrent Modifications](./loops_iii/concurrent_modifications.md)
+  - [Inferred Types](./loops_iii/inferred_types.md)
+
+# Concepts II
 
 - [Encapsulation](./encapsulation.md)
   - [Implementation Details](./encapsulation/implementation_details.md)
@@ -577,6 +584,34 @@ Make them do one. -->
   - [Leaky Abstractions](./encapsulation/leaky_abstractions.md)
   - [Information Hiding](./encapsulation/information_hiding.md)
 
+# Metaprogramming
+
+- [Reflection](./reflection.md)
+  - [Class Objects](./reflection/class_objects.md)
+  - [Get all Fields](./reflection/get_all_fields.md)
+  - [Get a Field]()
+  - [Set a Field]()
+  - [Get a Method]()
+  - [Call a Method]()
+  - [Get a Constructor]()
+
+- [Annotations](./annotations.md)
+
+# Concepts III
+
+- [Acronyms](./acronyms.md)
+  - [Niches](./acronyms/niches.md)
+  - [Usage Contexts](./acronyms/usage_contexts.md)
+  - [Ambiguity](./acronyms/ambiguity.md)
+  - [Familiarity](./acronyms/familiarity.md)
+  - [Elaboration](./acronyms/elaboration.md)
+
+<!--- [HashMap](./hash_map.md)
+- [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
+- [Iterable and Iterator](./iterable_and_iterator.md)
+
+
+
 
 - [Loops III](./loops_iii.md)
   - [For-each loops](./loops_iii/for_each_loops.md)
@@ -618,27 +653,7 @@ Make them do one. -->
   - [Low Level versus High Level](./tcp_over_ip/low_level_versus_high_level.md)
 - [Data Formats]()
 
-# Metaprogramming
 
-- [Reflection](./reflection.md)
-  - [Class Objects](./reflection/class_objects.md)
-  - [Get all Fields](./reflection/get_all_fields.md)
-  - [Get a Field]()
-  - [Set a Field]()
-  - [Get a Method]()
-  - [Call a Method]()
-  - [Get a Constructor]()
-
-- [Annotations]()
-
-# Concepts III
-
-- [Acronyms](./acronyms.md)
-  - [Niches](./acronyms/niches.md)
-  - [Usage Contexts](./acronyms/usage_contexts.md)
-  - [Ambiguity](./acronyms/ambiguity.md)
-  - [Familiarity](./acronyms/familiarity.md)
-  - [Elaboration](./acronyms/elaboration.md)
 
 # Code Structure VI
 

src/annotations.md

@@ -0,0 +1 @@
+# Annotations

src/loops_iii/arraylist.md

@@ -0,0 +1,42 @@
+# ArrayList
+
+One class which implements `Iterable` is `ArrayList`.
+
+```java
+~import java.util.ArrayList;
+~
+~class Main {
+~   void main() {
+ArrayList<String> donutEaters = new ArrayList<>();
+donutEaters.add("Chief Wiggum");
+donutEaters.add("Homer Simpson");
+
+Iterator<String> donutEatersIterator = donutEaters.iterator();
+// Check if there is a next element
+while (donutEatersIterator.hasNext()) { 
+    // If there is, get it and advance the iterator
+    String donutEater = donutEatersIterator.next();
+
+    System.out.println(donutEater + " eats donuts");
+}
+~   }
+~}
+```
+
+This means you can loop over it with a for-each loop same as an array.
+
+```java
+~import java.util.ArrayList;
+~
+~class Main {
+~   void main() {
+ArrayList<String> donutEaters = new ArrayList<>();
+donutEaters.add("Chief Wiggum");
+donutEaters.add("Homer Simpson");
+
+for (String donutEater : donutEaters) {
+    System.out.println(donutEater + " eats donuts");
+}
+~   }
+~}
+```

src/loops_iii/arrays.md

@@ -0,0 +1,77 @@
+# Arrays
+
+When you use a for-each loop on an array, it acts the same as the kind of for-loop
+you would have written before with an explicit index.
+
+```java
+record Drink(String name, double mgCaffeinePerCup) {}
+
+~class Main {
+~    void main() {
+Drink[] drinks = { 
+    new Drink("Black Coffee", 95),
+    new Drink("Milk", 0),
+    new Drink("Green Tea", 35)
+};
+
+// This loop functions the same as the loop below
+for (int i = 0; i < drinks.length; i++) {
+    Drink drink = drinks[i];
+
+    System.out.println(
+        drink.name()
+            + " has "
+            + drink.mgCaffeinePerCup()
+            + "mg caffiene per cup"
+        );
+}
+
+System.out.println("------------------");
+
+for (Drink drink : drinks) {
+    System.out.println(
+        drink.name()
+            + " has "
+            + drink.mgCaffeinePerCup()
+            + "mg caffiene per cup"
+        );
+}
+~    }
+~}
+```
+
+This doesn't mean that the old style of for loop is useless now. You will still want that
+if you need to know which element in your array you are dealing with
+or if you are doing a more interesting form of iteration.
+
+```java
+record Drink(String name, double mgCaffeinePerCup) {}
+
+~class Main {
+~    void main() {
+Drink[] drinks = { 
+    new Drink("Black Coffee", 95),
+    new Drink("Milk", 0),
+    new Drink("Green Tea", 35)
+};
+
+
+// If loop actually cares to use `i` beyond just accessing
+// the right element in the array
+for (int i = 0; i < drinks.length; i++) {
+    Drink drink = drinks[i];
+
+    // Which you might want for display logic
+    System.out.println(
+        "[" + i + "]: " + drink.name()
+    );
+
+    // Or to mutate the original array
+    drinks[i] = new Drink(
+        drink.name(),
+        drink.mgCaffeinePerCup() + 100
+    );
+}
+~    }
+~}
+```

src/loops_iii/concurrent_modifications.md

@@ -1 +1,81 @@
 # Concurrent Modifications
+
+If you are looping over a collection with a for-each loop you generally
+cannot remove things from that collection at the same time. Doing so should
+trigger a `ConcurrentModificationException`.[^should]
+
+```java,panics
+~import java.util.ArrayList;
+~
+record Sandwich(
+    int turkeySlices,
+    int cheeseSlices,
+    boolean mayo
+) {}
+
+~class Main {
+~   void main() {
+ArrayList<Sandwich> sandwiches = new ArrayList<>();
+var turkeyAndCheddar = new Sandwich(2, 2, true);
+var grilledCheese = new Sandwich(0, 4, false);
+var bigTurkeyAndCheddar = new Sandwich(10, 10, true);
+var theWisconsinFreak = new Sandwich(0, 20, true);
+
+sandwiches.add(turkeyAndCheddar);
+sandwiches.add(grilledCheese);
+sandwiches.add(bigTurkeyAndCheddar);
+sandwiches.add(theWisconsinFreak);
+
+for (Sandwich sandwich : sandwiches) {
+    if (sandwich.mayo()) { // Some people don't like Mayo
+        // But we can't get rid of them during the loop
+        sandwiches.remove(sandwich);
+    }
+}
+~   }
+~}
+```
+
+If you want to remove an element at the same time as iterating over specifically an `ArrayList`, you
+can get creative with indexes and regular loops.[^remove]
+
+```java
+~import java.util.ArrayList;
+~
+record Sandwich(
+    int turkeySlices,
+    int cheeseSlices,
+    boolean mayo
+) {}
+
+~class Main {
+~   void main() {
+ArrayList<Sandwich> sandwiches = new ArrayList<>();
+var turkeyAndCheddar = new Sandwich(2, 2, true);
+var grilledCheese = new Sandwich(0, 4, false);
+var bigTurkeyAndCheddar = new Sandwich(10, 10, true);
+var theWisconsinFreak = new Sandwich(0, 20, true);
+
+sandwiches.add(turkeyAndCheddar);
+sandwiches.add(grilledCheese);
+sandwiches.add(bigTurkeyAndCheddar);
+sandwiches.add(theWisconsinFreak);
+
+for (int i = 0; i < sandwiches.size(); i++) {
+    Sandwich sandwich = sandwiches.get(i);
+    if (sandwich.mayo()) { // Some people don't like Mayo
+        sandwiches.remove(sandwich);
+        i--; // Subtracting one from our current index sycs us back up
+    }
+}
+        
+System.out.println(sandwiches);
+~   }
+~}
+```
+
+[^should]: The reason I say "should" is that doing the book keeping needed to know when
+this has happened can be hard and not all `Iterator`s in the world will do it. The check is what we would call "best effort."
+
+[^remove]: And, as these footnotes have alluded, there is a `.remove` method on `Iterator`. We'll cover it
+later.

src/loops_iii/for_each_loops.md

@@ -1 +1,38 @@
 # For-each loops
+
+Where a normal `for` loop is more or less a shorthand for a certain kind of `while` loop, 
+a for-each loop[^enhanced] is a shorthand for the general concept of iterating over a collection
+of elements.
+
+To use a for-each loop, write `for` then in the parentheses write a variable declaration, a `:`, and the
+collection of elements you are iterating over.
+
+```
+for (<VARIABLE DECLARATION> : <COLLECTION>) {
+    <BODY>
+}
+```
+
+```java
+record Bread(String name, boolean french) {}
+
+~class Main {
+~    void main() {
+Bread[] breads = { 
+    new Bread("Croissant", true),
+    new Bread("Baguette", true),
+    new Bread("Boston Brown Bread", false)
+};
+
+for (Bread bread : breads) {
+    System.out.println(
+        bread.name()
+            + (bread.french() ? " is french" : " is not french")
+        );
+}
+~    }
+~}
+```
+
+
+[^enhanced]: You might see this referred to as an "enhanced for statement." [That is its name in the language spec](https://docs.oracle.com/javase/specs/jls/se23/html/jls-14.html#jls-14.14.2) but not the name most people will use.

src/loops_iii/inferred_types.md

@@ -0,0 +1,17 @@
+# Inferred Types
+
+A variable declaration in a for-each loop can make use of `var` to infer its type.
+
+```java
+~class Main {
+~   void main() {
+String[] chairMaterials = { "wicker", "wood", "plastic" }
+for (var chairMaterial : chairMaterials) {
+    System.out.println(chairMaterial);
+}
+~   }
+~}
+```
+
+And this is good to know for the same reasons you would use `var` other places in Java.
+Writing `Book book` can be a drain on the soul.