Add arrays section (#22)

* Add start of if/else!

...

Co-Authored-By: Mitch Masia <[email protected]>

* loops

* ...

* Update SUMMARY.md

* loop challenges

* Update challenges.md

* ..

* Move iteration into loops

* More arrays

* Update access_individual_elements.md

* ...

* Close out arrays I sans challenges

* Rename features.py to features.java to placate folks

Update book.toml

Update book.toml

* Format

---------

Co-authored-by: Mitch Masia <[email protected]>

Author: bowbahdoe

book.toml

@@ -10,8 +10,12 @@ git-repository-url = "https://github.com/Together-Java/ModernJava"
 edit-url-template = "https://github.com/Together-Java/ModernJava/edit/develop/{path}"
 mathjax-support = true
 
+[output.html.fold]
+enable = true    # whether or not to enable section folding
+level = 0         # the depth to start folding
+
 [preprocessor.features]
-command = "python3 features.py"
+command = "python3 features.java"
 # Not ready
 toplevel_anonymous_class = false
 # Not ready

features.py features.java

@@ -1,5 +1,11 @@
 #!/usr/bin/env python3
 
+# This file is python, not Java.
+# but we got enough people complaining that the repo in github showed 100% python
+# that I just changed the extension to .java - I think its funny. We can replace
+# this file if either a json library is added to java or someone wants to do all
+# the setup to pull in a json lib.
+
 import json
 import sys
 

src/SUMMARY.md

@@ -13,15 +13,14 @@
     - [tutorialspoint](./examples/tutorialspoint.md)
     - [tutorialspoint paid course](./examples/tutorialspoint_paid.md)
     - [w3schools](./examples/w3schools.md) -->
-# Getting Started
-
-- [Hello, World](./getting_started/hello_world.md)
 
 # Modern Java
 
 - [Prelude](./prelude.md)
     - [Asking for Help](./prelude/asking_for_help.md)
     - [Toy Problems](./prelude/toy_problems.md)
+    - [Lies](./prelude/lies.md)
+- [Getting Started](./getting_started.md)
 - [First Steps](./first_steps.md)
     - [Comments](./first_steps/comments.md)
     - [Semicolons](./first_steps/semicolon.md)
@@ -36,7 +35,7 @@
     - [Inferred Types](./variables/inferred_types.md)
     - [Challenges](./variables/challenges.md)
 
-# Basic Data Types
+# Data Types I
 
 - [Booleans](./boolean.md)
     - [And](./boolean/and.md)
@@ -95,21 +94,67 @@
 
 # Control Flow I
 
-- [Branching Logic](./branching_logic.md)
+- [Branching Paths](./branching_paths.md)
     - [If](./branching_logic/if.md)
     - [Else](./branching_logic/else.md)
+    - [Nested Ifs](./branching_logic/nested_ifs.md)
     - [Else If](./branching_logic/else_if.md)
     - [Relation to Delayed Assignment](./branching_logic/relation_to_delayed_assignment.md)
-    - [Ternary Expression](./branching_logic/ternary_expression.md)
+    - [Conditional Operator](./branching_logic/conditional_operator.md)
+    - [Boolean Expressions](./branching_logic/boolean_expressions.md)
     - [Challenges](./branching_logic/challenges.md)
 - [Loops](./loops.md)
     - [While](./loops/while.md)
-    - [Termination Conditions](./loops/termination_conditions.md)
+    - [Endless Loops](./loops/endless_loops.md)
     - [Break](./loops/break.md)
     - [Continue](./loops/continue.md)
-    - [Do](./loops/do.md)
+    - [Unreachable Code](./loops/unreachable_code.md)
+    - [Do While](./loops/do_while.md)
+    - [Nested Loops](./loops/nested_loops.md)
+    - [Labeled Break](./loops/labeled_break.md)
+    - [Labeled Continue](./loops/labeled_continue.md)
+    - [Iteration](./loops/iteration.md)
+    - [Counting Up](./loops/counting_up.md)
+    - [Counting Down](./loops/counting_down.md)
+    - [Iterate over a String](./loops/iterate_over_a_string.md)
     - [Challenges](./loops/challenges.md)
 
+# Data Types II
+
+- [Arrays](./arrays.md)
+    - [Array Initializers](./arrays/array_initializers.md)
+    - [Length](./arrays/length.md)
+    - [Access Individual Elements](./arrays/access_individual_elements.md)
+    - [Set Individual Elements](./arrays/set_individual_elements.md)
+    - [Aliasing](./arrays/aliasing.md)
+    - [Reassignment](./arrays/reassignment.md)
+    - [Relation to Final Variables](./arrays/relation_to_final_variables.md)
+    - [Printing the Contents of an Array](./arrays/printing_the_contents_of_an_array.md)
+    - [Empty Array](./arrays/empty_array.md)
+    - [Difference between Initializer and Literal](./arrays/difference_between_initializer_and_literal.md)
+    - [Challenges](./arrays/challenges)
+
+# Control Flow II
+
+<!--
+- [For](./for.md)
+    - [Comparison to while]()
+    - [i](./for/i.md)
+    - [Relation to Arrays]()
+    - [var]()
+    - [final]()
+- [For Each]()
+
+- [Iteration]()
+    - [Iterate over an array]()
+
+- [null](./null.md)
+- [Reference Types]()
+- [Primitive Types]()
+- [Populate array]()
+
+-->
+
 # User Defined Types
 
 - [Classes](./classes.md)
@@ -128,6 +173,7 @@
 
 <!--
 Arrays
+copy an array (System.arrayCopy, for loop)
 Generics
 Maven
 XML
@@ -242,15 +288,9 @@ Javadoc and Documentation comments
 - Getting Started
 - [Hello, World]()
 - Data Types
-    - int and long
-        - Integer Division
-    - float and double
-        - Floating Point Numbers
-    - booleans
+
     - Arrays
-    - String
-        - String Literals
-        - Multiline String Literals
+multi dimensional arrays
 - Expressions
 - Conditionals
 - Loops

src/arrays.md

@@ -0,0 +1,22 @@
+# Arrays
+
+Arrays are used to represent a fixed-size collection of things.
+
+```java
+int[] oddNumbers = { 1, 3, 5, 7, 9 };
+```
+
+Fixed-size means that once an array is made, it will always hold the same
+number of things.
+
+We call the things stored in an array its "elements."
+
+You can make an array of any type of element by using the name of the type followed by
+`[]`.
+
+```java
+char[] letters = { 'a', 'b', 'c' };
+String[] words = { "its", "as", "easy", "as" }
+int[] numbers = { 1, 2, 3 };
+double[] doubles = { 97.0, 98.0, 99.0, 1.0, 2.0, 3.0 };
+```

src/arrays/access_individual_elements.md

@@ -0,0 +1,44 @@
+# Access Individual Elements
+
+Given an array, you can access any of its elements by index.
+
+You write the name of a variable containing an array, `[`, a number, and then a `]`.
+
+The first element can be accessed by using `0`, the second by using `1`, and so on.
+
+```java
+String[] lyrics = { "you", "say", "goodbye" };
+
+String you = lyrics[0];
+System.out.println(you);
+
+String say = lyrics[1];
+System.out.println(say);
+
+String goodbye = lyrics[2];
+System.out.println(goodbye);
+```
+
+The index of the element can also come from a variable.
+
+```java
+int index = 2;
+String[] lyrics = { "I", "say", "hello" };
+
+System.out.println(lyrics[index]);
+```
+
+If you give a number equal to or greater than the length of the array or a number less than zero,
+you will get an error.
+
+```java
+String[] lyrics = { "I", "say", "hi" };
+// Crash!
+lyrics[999];
+```
+
+```java
+String[] lyrics = { "you", "say", "low" };
+// Crash!
+lyrics[-1];
+```

src/arrays/aliasing.md

@@ -0,0 +1,34 @@
+# Aliasing
+
+When you assign a variable containing an array to another variable, the array
+referenced by both variables will be the exact same.
+
+This means that if the contents of the array are updated, that change will
+be reflected by both variables.
+
+```java
+char[] lettersOne = { 'B', 'a', 't', 'm', 'a', 'n' };
+char[] lettersTwo = lettersOne;
+
+// Batman
+System.out.println(lettersOne);
+// Batman
+System.out.println(lettersTwo);
+
+lettersOne[0] = 'C';
+
+// Catman
+System.out.println(lettersOne);
+// Catman
+System.out.println(lettersTwo);
+
+lettersTwo[0] = 'R';
+
+// Ratman
+System.out.println(lettersOne);
+// Ratman
+System.out.println(lettersTwo);
+```
+
+When two variables point to the same thing like this we say that both variables are "aliases"
+for eachother.

src/arrays/array_initializers.md

@@ -0,0 +1,25 @@
+# Array Initializers
+
+To give an initial value to an array you can use an array initializer.
+
+After the equals sign you write `{` followed by a comma separated list of elements and a final  `}`.
+
+```java
+int[] numbers = { 1, 2, 3 }
+             // |---------|
+             // this part is
+             // the initializer
+```
+
+The elements in an initializer do not have to be literals and can also be variables or expressions.
+
+```java
+int two = 2;
+// Will hold 1, 2, 3 just like the array above 
+int[] numbers = { 1, two, two + 1 }
+```
+
+We call them array initializers because you use them to give an initial value to an array.[^pattern]
+
+[^pattern]: You may be noticing a pattern. Confusing sounding names are often kinda "obvious"
+with enough context.

src/challenges.md src/arrays/challenges

@@ -0,0 +1,36 @@
+# Difference between Initializer and Literal
+
+The reason `{ 1, 2, 3 }` is called an "array initializer" and not
+an "array literal" is somewhat subtle.
+
+When you have a literal, like a `String` literal, you can assign that to a variable and
+then use that `String` afterwards.
+
+```java
+String name = "Alana";
+// l
+System.out.println(name.charAt(1));
+```
+
+But you can also perform those operations using the literal itself, without an intermediate variable.
+
+```java
+// l
+System.out.println("Alana".charAt(1));
+```
+
+Array initializers work in the case where you first assign them to a variable before using
+the array.
+
+```java
+char[] name = { 'A', 'm', 'a', 'n', 'd', 'a' };
+// m
+System.out.println(name[1]);
+```
+
+But they do not work to perform operations on directly.
+
+```java
+// Will not run
+System.out.println({ 'A', 'm', 'a', 'n', 'd', 'a' }[1]);
+```

src/arrays/difference_between_initializer_and_literal.md

@@ -0,0 +1,22 @@
+# Empty Array
+
+If you use an array initializer that has no elements between the `{` and `}`
+you can create an empty array.
+
+```java
+char[] emptyCharArray = {};
+```
+
+An empty array is very similar to an empty `String`. It has a length of 0, it has no elements,
+and it is generally useful only as a placeholder value for when you have no data yet but will
+be able to reassign the variable holding it when you get some.
+
+```java
+char[] emptyCharArray = {};
+
+// 0
+System.out.println(emptyCharArray.length);
+
+// Crash
+System.out.println(emptyCharArray[0]);
+```

src/arrays/empty_array.md

@@ -0,0 +1,15 @@
+# Length
+
+The number of elements which comprise an array can be accessed by using `.length`.[^unlike_string]
+
+```java
+String[] veggies = { "brussels", "cabbage", "carrots" };
+int numberOfElements = veggies.length;
+
+// veggies is 3 elements long
+System.out.println(
+    "veggies is " numberOfElements + " characters long"
+);
+```
+
+[^unlike_string]: Unlike with a `String`, you do not write `()` after `.length`.