Java Fundamentals (All tests passed)

Dan Do Better/MathUtilities.ctxt

@@ -0,0 +1,82 @@
+#BlueJ class context
+comment0.target=MathUtilities
+comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
+comment1.params=baseValue\ difference
+comment1.target=java.lang.Integer\ add(int,\ int)
+comment1.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
+comment10.params=baseValue\ difference
+comment10.target=java.lang.Byte\ subtract(byte,\ byte)
+comment10.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
+comment11.params=baseValue\ difference
+comment11.target=java.lang.Float\ subtract(float,\ float)
+comment11.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
+comment12.params=baseValue\ difference
+comment12.target=java.lang.Double\ subtract(double,\ double)
+comment12.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
+comment13.params=dividend\ divisor
+comment13.target=java.lang.Integer\ divide(int,\ int)
+comment13.text=\n\ @param\ dividend\ value\ to\ be\ divided\n\ @param\ divisor\ \ value\ to\ divide\ by\n\ @return\ division\ of\ `dividend`\ by\ `divisor\n
+comment14.params=dividend\ divisor
+comment14.target=java.lang.Long\ divide(long,\ long)
+comment14.text=\n\ @param\ dividend\ value\ to\ be\ divided\n\ @param\ divisor\ \ value\ to\ divide\ by\n\ @return\ division\ of\ `dividend`\ by\ `divisor\n
+comment15.params=dividend\ divisor
+comment15.target=java.lang.Short\ divide(short,\ short)
+comment15.text=\n\ @param\ dividend\ value\ to\ be\ divided\n\ @param\ divisor\ \ value\ to\ divide\ by\n\ @return\ division\ of\ `dividend`\ by\ `divisor\n
+comment16.params=dividend\ divisor
+comment16.target=java.lang.Byte\ divide(byte,\ byte)
+comment16.text=\n\ @param\ dividend\ value\ to\ be\ divided\n\ @param\ divisor\ \ value\ to\ divide\ by\n\ @return\ division\ of\ `dividend`\ by\ `divisor\n
+comment17.params=dividend\ divisor
+comment17.target=java.lang.Float\ divide(float,\ float)
+comment17.text=\n\ @param\ dividend\ value\ to\ be\ divided\n\ @param\ divisor\ \ value\ to\ divide\ by\n\ @return\ division\ of\ `dividend`\ by\ `divisor\n
+comment18.params=dividend\ divisor
+comment18.target=java.lang.Double\ divide(double,\ double)
+comment18.text=\n\ @param\ dividend\ value\ to\ be\ divided\n\ @param\ divisor\ \ value\ to\ divide\ by\n\ @return\ division\ of\ `dividend`\ by\ `divisor\n
+comment19.params=multiplicand\ multiplier
+comment19.target=java.lang.Integer\ multiply(int,\ int)
+comment19.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ \ \ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
+comment2.params=baseValue\ difference
+comment2.target=java.lang.Long\ add(long,\ long)
+comment2.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
+comment20.params=multiplicand\ multiplier
+comment20.target=java.lang.Long\ multiply(long,\ long)
+comment20.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ \ \ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
+comment21.params=multiplicand\ multiplier
+comment21.target=java.lang.Short\ multiply(short,\ short)
+comment21.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ \ \ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
+comment22.params=multiplicand\ multiplier
+comment22.target=java.lang.Byte\ multiply(byte,\ byte)
+comment22.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ \ \ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
+comment23.params=multiplicand\ multiplier
+comment23.target=java.lang.Float\ multiply(float,\ float)
+comment23.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ \ \ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
+comment24.params=multiplicand\ multiplier
+comment24.target=java.lang.Double\ multiply(double,\ double)
+comment24.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ \ \ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
+comment25.params=
+comment25.target=java.lang.Boolean\ returnTrue()
+comment25.text=\n\ @return\ true\n
+comment26.params=
+comment26.target=java.lang.Boolean\ returnFalse()
+comment26.text=\n\ @return\ false\n
+comment3.params=baseValue\ difference
+comment3.target=java.lang.Short\ add(short,\ short)
+comment3.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
+comment4.params=baseValue\ difference
+comment4.target=java.lang.Byte\ add(byte,\ byte)
+comment4.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
+comment5.params=baseValue\ difference
+comment5.target=java.lang.Float\ add(float,\ float)
+comment5.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
+comment6.params=baseValue\ difference
+comment6.target=java.lang.Double\ add(double,\ double)
+comment6.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
+comment7.params=baseValue\ difference
+comment7.target=java.lang.Integer\ subtract(int,\ int)
+comment7.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
+comment8.params=baseValue\ difference
+comment8.target=java.lang.Long\ subtract(long,\ long)
+comment8.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
+comment9.params=baseValue\ difference
+comment9.target=java.lang.Short\ subtract(short,\ short)
+comment9.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
+numComments=27

Dan Do Better/MathUtilities.java

@@ -0,0 +1,247 @@
+/**
+ * Created by dan on 6/14/17.
+ */
+public class MathUtilities {
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Integer add(int baseValue, int difference) {
+        return (baseValue + difference);
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Long add(long baseValue, long difference) {
+        return baseValue + difference;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Short add(short baseValue, short difference) {
+        short sumShort = (short) (baseValue + difference);
+        return sumShort;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Byte add(byte baseValue, byte difference) {
+        byte sumByte = (byte) (baseValue + difference);
+        return sumByte;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Float add(float baseValue, float difference) {
+        return baseValue + difference;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Double add(double baseValue, double difference) {
+        return baseValue + difference;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Integer subtract(int baseValue, int difference) {
+        return baseValue - difference;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Long subtract(long baseValue, long difference) {
+        return baseValue - difference;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Short subtract(short baseValue, short difference) {
+        short minusShort = (short) (baseValue - difference);
+        return minusShort;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Byte subtract(byte baseValue, byte difference) {
+        byte minusByte = (byte) (baseValue - difference);
+        return minusByte;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Float subtract(float baseValue, float difference) {
+        return (baseValue - difference);
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Double subtract(double baseValue, double difference) {
+        return (baseValue - difference);
+    }
+
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor  value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Integer divide(int dividend, int divisor) {
+        return (dividend / divisor);
+    }
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor  value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Long divide(long dividend, long divisor) {
+        return (dividend / divisor);
+    }
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor  value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Short divide(short dividend, short divisor) {
+        short divShort = (short) (dividend / divisor);
+        return divShort;
+    }
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor  value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Byte divide(byte dividend, byte divisor) {
+        byte divByte = (byte) (dividend / divisor);
+        return divByte;
+    }
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor  value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Float divide(float dividend, float divisor) {
+        return (dividend / divisor);
+    }
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor  value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Double divide(double dividend, double divisor) {
+        return (dividend / divisor);
+    }
+
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier   value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Integer multiply(int multiplicand, int multiplier) {
+        return (multiplicand * multiplier);
+    }
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier   value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Long multiply(long multiplicand, long multiplier) {
+        return (multiplicand * multiplier);
+    }
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier   value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Short multiply(short multiplicand, short multiplier) {
+        short multShort = (short) (multiplicand * multiplier);
+        return multShort;
+    }
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier   value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Byte multiply(byte multiplicand, byte multiplier) {
+        byte multByte = (byte) (multiplicand * multiplier);
+        return multByte;
+    }
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier   value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Float multiply(float multiplicand, float multiplier) {
+        return (multiplicand * multiplier);
+    }
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier   value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Double multiply(double multiplicand, double multiplier) {
+        return (multiplicand * multiplier);
+    }
+
+
+    /**
+     * @return true
+     */
+    public Boolean returnTrue() {
+        return true;
+    }
+
+    /**
+     * @return false
+     */
+    public Boolean returnFalse() {
+        return false;
+    }
+
+}

Dan Do Better/PredicateUtilities.ctxt

@@ -0,0 +1,16 @@
+#BlueJ class context
+comment0.target=PredicateUtilities
+comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
+comment1.params=x\ y
+comment1.target=java.lang.Boolean\ isGreaterThan(int,\ int)
+comment1.text=\n\ @param\ x\n\ @param\ y\n\ @return\ true\ if\ `x`\ is\ greater\ than\ `y`\n
+comment2.params=x\ y
+comment2.target=java.lang.Boolean\ isLessThan(int,\ int)
+comment2.text=\n\ @param\ x\n\ @param\ y\n\ @return\ true\ if\ `x`\ is\ less\ than\ `y`\n
+comment3.params=x\ y
+comment3.target=java.lang.Boolean\ isGreaterThanOrEqualTo(int,\ int)
+comment3.text=\n\ @param\ x\n\ @param\ y\n\ @return\ true\ if\ `x`\ is\ greater\ than\ or\ equal\ to\ `y`\n
+comment4.params=x\ y
+comment4.target=java.lang.Boolean\ isLessThanOrEqualTo(int,\ int)
+comment4.text=\n\ @param\ x\n\ @param\ y\n\ @return\ true\ if\ `x`\ is\ less\ than\ or\ equal\ to\ `y`\n
+numComments=5

Dan Do Better/PredicateUtilities.java

@@ -0,0 +1,69 @@
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class PredicateUtilities {
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is greater than `y`
+     */
+    public Boolean isGreaterThan(int x, int y) {
+        boolean z;
+
+        if (x > y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is less than `y`
+     */
+    public Boolean isLessThan(int x, int y) {
+        boolean z;
+
+        if (x < y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is greater than or equal to `y`
+     */
+    public Boolean isGreaterThanOrEqualTo(int x, int y) {
+        boolean z;
+
+        if (x >= y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is less than or equal to `y`
+     */
+    public Boolean isLessThanOrEqualTo(int x, int y) {
+        boolean z;
+
+        if (x <= y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
+    }
+}

Dan Do Better/README.TXT

@@ -0,0 +1,12 @@
+------------------------------------------------------------------------
+This is the project README file. Here, you should describe your project.
+Tell the reader (someone who does not know anything about this project)
+all he/she needs to know. The comments should usually include at least:
+------------------------------------------------------------------------
+
+PROJECT TITLE:
+PURPOSE OF PROJECT:
+VERSION or DATE:
+HOW TO START THIS PROJECT:
+AUTHORS:
+USER INSTRUCTIONS:

Dan Do Better/StringUtilities.ctxt

@@ -0,0 +1,34 @@
+#BlueJ class context
+comment0.target=StringUtilities
+comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
+comment1.params=
+comment1.target=java.lang.String\ getHelloWorld()
+comment1.text=\n\ @return\ `Hello\ World`\ as\ a\ string\n
+comment10.params=stringToReverse
+comment10.target=java.lang.String\ reverse(java.lang.String)
+comment10.text=\n\ @param\ stringToReverse\n\ @return\ an\ identical\ string\ with\ characters\ in\ reverse\ order.\n
+comment2.params=firstSegment\ secondSegment
+comment2.target=java.lang.String\ concatenation(java.lang.String,\ java.lang.String)
+comment2.text=\n\ @param\ firstSegment\ a\ string\ to\ be\ added\ to\n\ @param\ secondSegment\ a\ string\ to\ add\n\ @return\ the\ concatenation\ of\ two\ strings,\ `firstSegment`,\ and\ `secondSegment`\n
+comment3.params=firstSegment\ secondSegment
+comment3.target=java.lang.String\ concatenation(int,\ java.lang.String)
+comment3.text=\n\ @param\ firstSegment\ a\ string\ to\ be\ added\ to\n\ @param\ secondSegment\ a\ string\ to\ add\n\ @return\ the\ concatenation\ of\ an\ integer,\ `firstSegment`,\ and\ a\ String,\ `secondSegment`\n
+comment4.params=input
+comment4.target=java.lang.String\ getPrefix(java.lang.String)
+comment4.text=\n\ @param\ input\ a\ string\ to\ be\ manipulated\n\ @return\ the\ first\ 3\ characters\ of\ `input`\n
+comment5.params=input
+comment5.target=java.lang.String\ getSuffix(java.lang.String)
+comment5.text=\n\ @param\ input\ a\ string\ to\ be\ manipulated\n\ @return\ the\ last\ 3\ characters\ of\ `input`\n
+comment6.params=inputValue\ comparableValue
+comment6.target=java.lang.Boolean\ compareTwoStrings(java.lang.String,\ java.lang.String)
+comment6.text=\n\ @param\ inputValue\ the\ value\ to\ be\ compared\n\ @param\ comparableValue\ the\ value\ to\ be\ compared\ against\n\ @return\ the\ equivalence\ of\ two\ strings,\ `inputValue`\ and\ `comparableValue`\n
+comment7.params=inputValue
+comment7.target=java.lang.Character\ getMiddleCharacter(java.lang.String)
+comment7.text=\n\ @param\ inputValue\ the\ value\ input\ from\ user\n\ @return\ the\ middle\ character\ of\ `inputValue`\n
+comment8.params=spaceDelimitedString
+comment8.target=java.lang.String\ getFirstWord(java.lang.String)
+comment8.text=\n\ @param\ spaceDelimitedString\ a\ string,\ representative\ of\ a\ sentence,\ containing\ spaces\n\ @return\ the\ first\ sequence\ of\ characters\n
+comment9.params=spaceDelimitedString
+comment9.target=java.lang.String\ getSecondWord(java.lang.String)
+comment9.text=\n\ @param\ spaceDelimitedString\ a\ string\ delimited\ by\ spaces\n\ @return\ the\ second\ word\ of\ a\ string\ delimited\ by\ spaces.\n
+numComments=11

Dan Do Better/StringUtilities.java

@@ -0,0 +1,114 @@
+/**
+ * Created by dan on 6/14/17.
+ */
+public class StringUtilities {
+    /**
+     * @return `Hello World` as a string
+     */
+    public static String getHelloWorld() {
+        String hello = "Hello World";
+        return hello;
+    }
+
+    /**
+     * @param firstSegment a string to be added to
+     * @param secondSegment a string to add
+     * @return the concatenation of two strings, `firstSegment`, and `secondSegment`
+     */
+    public static String concatenation(String firstSegment, String secondSegment){
+        String conCat = firstSegment.concat(secondSegment);
+        return conCat;
+    }
+
+    /**
+     * @param firstSegment a string to be added to
+     * @param secondSegment a string to add
+     * @return the concatenation of an integer, `firstSegment`, and a String, `secondSegment`
+     */
+    public static String concatenation(int firstSegment, String secondSegment){
+        String conCat2 = (firstSegment + secondSegment);
+        return conCat2;
+    }
+
+    /**
+     * @param input a string to be manipulated
+     * @return the first 3 characters of `input`
+     */
+    public static String getPrefix(String input){
+        String firstThree = input.substring(0, 3);        
+        return firstThree;
+    }
+
+    /**
+     * @param input a string to be manipulated
+     * @return the last 3 characters of `input`
+     */
+    public static String getSuffix(String input){
+        String lastThree = input.substring((input.length() - 3), (input.length()));
+        return lastThree;
+    }
+
+    /**
+     * @param inputValue the value to be compared
+     * @param comparableValue the value to be compared against
+     * @return the equivalence of two strings, `inputValue` and `comparableValue`
+     */
+    public static Boolean compareTwoStrings(String inputValue, String comparableValue){
+        boolean stringEqual = inputValue.equalsIgnoreCase(comparableValue);        
+        return stringEqual;
+    }
+
+    /**
+     * @param inputValue the value input from user
+     * @return the middle character of `inputValue`
+     */
+    public static Character getMiddleCharacter(String inputValue){
+        int midCharLocation = (inputValue.length() - 1) / 2;  // gets index #
+        char midChar = inputValue.charAt(midCharLocation);
+        return midChar;
+    }
+
+    /**
+     * @param spaceDelimitedString a string, representative of a sentence, containing spaces
+     * @return the first sequence of characters
+     */
+    public static String getFirstWord(String spaceDelimitedString){
+        int firstSpace = spaceDelimitedString.indexOf(" ");
+        String firstWord = spaceDelimitedString.substring(0, firstSpace);        
+        return firstWord;
+    }
+
+    /**
+     * @param spaceDelimitedString a string delimited by spaces
+     * @return the second word of a string delimited by spaces.
+     */
+    public static String getSecondWord(String spaceDelimitedString){
+        // find index of first space
+        int firstSpace = spaceDelimitedString.indexOf(" ");
+        // find index of second space
+        int secondSpace = spaceDelimitedString.indexOf(" ", firstSpace + 1);
+
+        String secondWord;
+        
+        if (secondSpace > 0) {
+            secondWord = spaceDelimitedString.substring(firstSpace, secondSpace);
+        } else {
+            secondWord = spaceDelimitedString.substring((firstSpace + 1),(spaceDelimitedString.length()));
+        }
+
+        return secondWord;
+    }
+
+    /**
+     * @param stringToReverse
+     * @return an identical string with characters in reverse order.
+     */
+    public static String reverse(String stringToReverse){
+        // change string in stringbuilder
+        StringBuilder reverseSB = new StringBuilder(stringToReverse);
+        // use built-in stringbuilder reverse method and then change back to string
+        String reverse = reverseSB.reverse().toString();
+        
+        return reverse;
+    }
+}

Dan Do Better/TestMathUtilities.ctxt

@@ -0,0 +1,56 @@
+#BlueJ class context
+comment0.target=TestMathUtilities
+comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
+comment1.params=
+comment1.target=void\ testAdditions()
+comment10.params=
+comment10.target=void\ testSubtractions3()
+comment11.params=
+comment11.target=void\ testSubtractions4()
+comment12.params=
+comment12.target=void\ testSubtractions5()
+comment13.params=
+comment13.target=void\ testDivision()
+comment14.params=
+comment14.target=void\ testDivision1()
+comment15.params=
+comment15.target=void\ testDivision2()
+comment16.params=
+comment16.target=void\ testDivision3()
+comment17.params=
+comment17.target=void\ testDivision4()
+comment18.params=
+comment18.target=void\ testDivision5()
+comment19.params=
+comment19.target=void\ testMultiplication()
+comment2.params=
+comment2.target=void\ testAdditions1()
+comment20.params=
+comment20.target=void\ testMultiplication1()
+comment21.params=
+comment21.target=void\ testMultiplication2()
+comment22.params=
+comment22.target=void\ testMultiplication3()
+comment23.params=
+comment23.target=void\ testMultiplication4()
+comment24.params=
+comment24.target=void\ testMultiplication5()
+comment25.params=
+comment25.target=void\ testReturnTrue()
+comment26.params=
+comment26.target=void\ testReturnFalse()
+comment3.params=
+comment3.target=void\ testAdditions2()
+comment4.params=
+comment4.target=void\ testAdditions4()
+comment5.params=
+comment5.target=void\ testAdditions5()
+comment6.params=
+comment6.target=void\ testAdditions6()
+comment7.params=
+comment7.target=void\ testSubtractions()
+comment8.params=
+comment8.target=void\ testSubtractions1()
+comment9.params=
+comment9.target=void\ testSubtractions2()
+numComments=27

Dan Do Better/TestMathUtilities.java

@@ -0,0 +1,342 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+/**
+ * Created by dan on 6/14/17.
+ */
+public class TestMathUtilities {
+    private static volatile MathUtilities primativeTypes = new MathUtilities();
+
+    @Test
+    public void testAdditions() {
+        // : Given
+        int baseValue = 20;
+        int addedValue = 7;
+        int expected = 27;
+        // : When
+        int actual = primativeTypes.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected,actual);
+    }
+    @Test
+    public void testAdditions1() {
+        // : Given
+        long baseValue = 228437266;
+        long difference = 228437265;
+        long expected = 456874531;
+        // : When
+        long actual = primativeTypes.add(baseValue, difference);
+        // : Then
+        assertEquals(expected,actual);
+    }
+    @Test
+    public void testAdditions2() {
+        // : Given
+        short baseValue = 16384;
+        short addedValue = 7;
+        short expected = 16391;
+        // : When
+        short actual = primativeTypes.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testAdditions4() {
+        // : Given
+        byte baseValue = 63;
+        byte addedValue = 64;
+        byte expected = 127;
+        // : When
+        byte actual = primativeTypes.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected,actual);
+    }
+    @Test
+    public void testAdditions5() {
+        // : Given
+        float baseValue = 750.585F;
+        float addedValue = 795.000F;
+        float expected = 1545.585F;
+        // : When
+        float actual = primativeTypes.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected,actual, 0);
+    }
+
+    @Test
+    public void testAdditions6() {
+        // : Given
+        double baseValue = 225.25;
+        double addedValue = 231;
+        double expected = 456.25;
+        // : When
+        double actual = primativeTypes.add(baseValue,addedValue);
+        // : Then
+        assertEquals(expected,actual, 0);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testSubtractions(){
+        // : Given
+        int baseValue = 20;
+        int difference = 7;
+        int expectedInt = 13;
+        // : When
+        int actualInt = primativeTypes.subtract(baseValue,difference);
+        // : Then
+        assertEquals(expectedInt,actualInt);
+    }
+    @Test
+    public void testSubtractions1() {
+        // : Given
+        long baseValue = 228437266;
+        long difference = 228437265;
+        long expectedLong = 1;
+        // : When
+        long actualLong = primativeTypes.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedLong,actualLong);
+    }
+    @Test
+    public void testSubtractions2() {
+        // : Given
+        short baseValue = 16384;
+        short difference = 16383;
+        short expectedShort = 1;
+        // : When
+        short actualShort = primativeTypes.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedShort,actualShort);
+    }
+    @Test
+    public void testSubtractions3() {
+        // : Given
+        byte baseValue = 63;
+        byte difference = 64;
+        byte expectedByte = -1;
+        // : When
+        byte actualByte = primativeTypes.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedByte,actualByte);
+    }
+    @Test
+    public void testSubtractions4() {
+        // : Given
+        float baseValue = 750.585F;
+        float difference = 795.0F;
+        float expectedFloat = -44.415F;
+        // : When
+        float actualFloat = primativeTypes.subtract(baseValue,difference);
+        // : Then
+        assertEquals(expectedFloat,actualFloat, 0.005);
+    }
+    @Test
+    public void testSubtractions5() {
+        // : Given
+        double baseValue = 225.25;
+        double difference = 231;
+        double expectedDouble = -5.75;
+        // : When
+        double actualDouble = primativeTypes.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedDouble,actualDouble, 0);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testDivision(){
+        // : Given
+        int dividend = 20;
+        int divisor = 2;
+        int expectedInt = 10;
+        // : When
+        int actualInt = primativeTypes.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedInt,actualInt);
+    }
+    @Test
+    public void testDivision1() {
+        // : Given
+        int dividend = 20000000;
+        int divisor = 1000;
+        long expectedLong = 20000;
+        // : When
+        long actualLong = primativeTypes.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedLong,actualLong);
+    }
+    @Test
+    public void testDivision2() {
+        // : Given
+        short dividend = 2;
+        short divisor = 1;
+        short expectedShort = 2;
+        // : When
+        short actualShort = primativeTypes.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedShort,actualShort);
+
+    }
+    @Test
+    public void testDivision3() {
+        // : Given
+        byte dividend = 64;
+        byte divisor = 32;
+        byte expectedByte = 2;
+        // : When
+        byte actualByte = primativeTypes.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedByte,actualByte);
+    }
+    @Test
+    public void testDivision4() {
+        // : Given
+        float dividend = 7.5F;
+        float divisor = 3;
+        float expectedFloat = 2.50F;
+        // : When
+        float actualFloat = primativeTypes.divide(dividend,divisor);
+        // : Then
+        assertEquals(expectedFloat,actualFloat, 0);
+    }
+    @Test
+    public void testDivision5() {
+        // : Given
+        double dividend = 5.0;
+        double divisor = 4.0;
+        double expectedDouble = 1.25;
+        // : When
+        double actualDouble = primativeTypes.divide(dividend,divisor);
+        // : Then
+        assertEquals(expectedDouble,actualDouble, 0);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testMultiplication(){
+        // : Given
+        int multiplicand = 5;
+        int multiplier = 2;
+        int expectedInt = 10;
+        // : When
+        int actualInt = primativeTypes.multiply(multiplicand,multiplier);
+        // : Then
+        assertEquals(expectedInt,actualInt);
+    }
+    @Test
+    public void testMultiplication1() {
+        // : Given
+        long multiplicand = 20;
+        long multiplier = 1000;
+        long expectedLong = 20000;
+        // : When
+        long actualLong = primativeTypes.multiply(multiplicand, multiplier);
+        // : Then
+        assertEquals(expectedLong, actualLong);
+    }
+    @Test
+    public void testMultiplication2() {
+        // : Given
+        short multiplicand = 2;
+        short multiplier = 1;
+        short expectedShort = 2;
+        // : When
+        short actualShort = primativeTypes.multiply(multiplicand, multiplier);
+        // : Then
+        assertEquals(expectedShort, actualShort);
+    }
+    @Test
+    public void testMultiplication3() {
+        // : Given
+        byte multiplicand = 16;
+        byte multiplier = 4;
+        byte expectedByte = 64;
+        // : When
+        byte actualByte = primativeTypes.multiply(multiplicand, multiplier);
+        // : Then
+        assertEquals(expectedByte, actualByte);
+    }
+    @Test
+    public void testMultiplication4() {
+        // : Given
+        float multiplicand = 2.5F;
+        float multiplier = 1;
+        float expectedFloat = 2.50F;
+        // : When
+        float actualFloat =  primativeTypes.multiply(multiplicand,multiplier);
+        // : Then
+        assertEquals(expectedFloat, actualFloat, 0);
+    }
+    @Test
+    public void testMultiplication5() {
+        // : Given
+        double multiplicand = 3.25;
+        double multiplier = 3.0;
+        double expectedDouble = 9.75;
+        // : When
+        double actualDouble = primativeTypes.multiply(multiplicand,multiplier);
+        // : Then
+        assertEquals(expectedDouble, actualDouble, 0);
+    }
+
+    @Test
+    public void testReturnTrue(){
+        // : Given
+        // : When
+        // : Then
+        assertTrue(primativeTypes.returnTrue());
+    }
+
+    @Test
+    public void testReturnFalse(){
+        // : Given
+        // : When
+        // : Then
+        assertFalse(primativeTypes.returnFalse());
+    }
+
+}

Dan Do Better/TestPredicateUtilities.ctxt

@@ -0,0 +1,20 @@
+#BlueJ class context
+comment0.target=TestPredicateUtilities
+comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
+comment1.params=
+comment1.target=void\ testGreaterThanTrue()
+comment2.params=
+comment2.target=void\ testGreaterThanFalse()
+comment3.params=
+comment3.target=void\ testLessThanTrue()
+comment4.params=
+comment4.target=void\ testLessThan1()
+comment5.params=
+comment5.target=void\ testLessOrEqual1()
+comment6.params=
+comment6.target=void\ testLessOrEqual2()
+comment7.params=
+comment7.target=void\ testGreaterOrEqual1()
+comment8.params=
+comment8.target=void\ testGreaterOrEqual2()
+numComments=9

Dan Do Better/TestPredicateUtilities.java

@@ -0,0 +1,120 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class TestPredicateUtilities {
+    private static volatile PredicateUtilities math = new PredicateUtilities();
+
+    @Test
+    public void testGreaterThanTrue() {
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+
+        // : When
+        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+
+    @Test
+    public void testGreaterThanFalse() {
+        // : Given
+        int greaterValue = 350;
+        int lesserValue = 350;
+
+        // : When
+        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+
+        // : Then
+        assertFalse(outcome);
+    }
+
+
+    @Test
+    public void testLessThanTrue() {
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+        // : When
+        boolean outcome = math.isLessThan(greaterValue, lesserValue);
+
+        // : Then
+        assertFalse(outcome);
+    }
+
+
+    @Test
+    public void testLessThan1() {
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+        // : When
+        boolean outcome = math.isLessThan(greaterValue, lesserValue);
+
+        // : Then
+        assertFalse(outcome);
+    }
+
+
+    @Test
+    public void testLessOrEqual1() {
+        // : Given
+        int greaterValue = 3;
+        int lesserValue = 3;
+
+        // : When
+        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+    @Test
+    public void testLessOrEqual2() {
+        // : Given
+        int greaterValue = 3;
+        int lesserValue = 6;
+
+        // : When
+        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+    @Test
+    public void testGreaterOrEqual1() {
+        // : Given
+        int greaterValue = 4;
+        int lesserValue = 4;
+
+        // : When
+        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
+
+        // : ThenP
+        assertTrue(outcome);
+    }
+
+
+    @Test
+    public void testGreaterOrEqual2() {
+        // : Given
+        int greaterValue = 8;
+        int lesserValue = 15;
+
+        // : When
+        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertFalse(outcome);
+    }
+}

Dan Do Better/TestStringUtilities.ctxt

@@ -0,0 +1,28 @@
+#BlueJ class context
+comment0.target=TestStringUtilities
+comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
+comment1.params=
+comment1.target=void\ getHelloWorldTest()
+comment10.params=
+comment10.target=void\ getTheFirstWord()
+comment11.params=
+comment11.target=void\ getTheSecondWord()
+comment12.params=
+comment12.target=void\ reverseThem()
+comment2.params=
+comment2.target=void\ concatenationStringTest()
+comment3.params=
+comment3.target=void\ concatenationStringAndIntegerTest()
+comment4.params=
+comment4.target=void\ substringBeginTest()
+comment5.params=
+comment5.target=void\ substringEndTest()
+comment6.params=
+comment6.target=void\ compareToTestEquals()
+comment7.params=
+comment7.target=void\ compareToTestNotEquals()
+comment8.params=
+comment8.target=void\ getTheMiddleChar1()
+comment9.params=
+comment9.target=void\ getTheMiddleChar2()
+numComments=13

Dan Do Better/TestStringUtilities.java

@@ -0,0 +1,174 @@
+import org.junit.Assert;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class TestStringUtilities {
+    @Test
+    public void getHelloWorldTest() {
+        // : Given
+        String expected = "Hello World";
+
+        // : When
+        String actual = StringUtilities.getHelloWorld();
+
+        // : Then
+        assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void concatenationStringTest(){
+        // : Given
+        String one = "Hello";
+        String two = " Java";
+        String expected = "Hello Java";
+
+        // : When
+        String actual = StringUtilities.concatenation(one,two);
+
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void concatenationStringAndIntegerTest(){
+        // : Given
+        int one = 1;
+        String two = " Java";
+        String expected = "1 Java";
+
+        // : When
+        String actual = StringUtilities.concatenation(one,two);
+
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void substringBeginTest(){
+        // : Given
+        String input = "Hello";
+        String expected = "Hel";
+
+        // : When
+        String actual = StringUtilities.getPrefix(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void substringEndTest(){
+        // : Given
+        String input = "Hello";
+        String expected = "llo";
+
+        // : When
+        String actual = StringUtilities.getSuffix("Hello");
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void compareToTestEquals(){
+        // : Given
+        String inputValue = "Zipcode";
+        String comparableValue = "Zipcode";
+
+        // : When
+        boolean actual = StringUtilities.compareTwoStrings(inputValue, comparableValue);
+
+        // : Then
+        assertTrue(actual);
+    }
+
+
+    @Test
+    public void compareToTestNotEquals(){
+        // : Given
+        String inputValue = "Zipcode";
+        String comparableValue = "Zipcodee";
+
+        // : When
+        boolean actual = StringUtilities.compareTwoStrings(inputValue, comparableValue);
+
+        // : Then
+        assertFalse(actual);
+    }
+
+    @Test
+    public void getTheMiddleChar1(){
+        // : Given
+        String input = "Zipcode";
+        Character expected = 'c';
+
+        // : When
+        Character actual = StringUtilities.getMiddleCharacter(input);
+
+        // : Then
+        Assert.assertEquals(expected.toString(), actual.toString());
+    }
+
+
+    @Test
+    public void getTheMiddleChar2(){
+        // : Given
+        String input = "Zipcoder";
+        Character expected = 'c';
+
+        // : When
+        Character actual = StringUtilities.getMiddleCharacter(input);
+
+        // : Then
+        Assert.assertEquals(expected.toString(), actual.toString());
+    }
+
+
+    @Test
+    public void getTheFirstWord(){
+        // : Given
+        String input = "Zipcode Wilmington";
+        String expected = "Zipcode";
+
+        // : When
+        String actual = StringUtilities.getFirstWord(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void getTheSecondWord(){
+        // : Given
+        String input = "Zipcode Wilmington";
+        String expected = "Wilmington";
+
+        // : When
+        String actual = StringUtilities.getSecondWord(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void reverseThem(){
+        // : Given
+        String input = "Zipcode Wilmington";
+        String expected = "notgnimliW edocpiZ";
+
+
+        // : When
+        String actual = StringUtilities.reverse(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+}

Dan Do Better/ZipcodeRocks.ctxt

@@ -0,0 +1,6 @@
+#BlueJ class context
+comment0.target=ZipcodeRocks
+comment0.text=\n\ Created\ by\ leon\ on\ 2/5/18.\n
+comment1.params=args
+comment1.target=void\ main(java.lang.String[])
+numComments=2

Dan Do Better/ZipcodeRocks.java

@@ -0,0 +1,8 @@
+ /**
+ * Created by leon on 2/5/18.
+ */
+public class ZipcodeRocks {
+    public static void main(String[] args) {
+         System.out.println("Zipcode Rocks!");
+    }
+}

Dan Do Better/package.bluej

@@ -0,0 +1,86 @@
+#BlueJ package file
+dependency1.from=TestMathUtilities
+dependency1.to=MathUtilities
+dependency1.type=UsesDependency
+dependency2.from=TestPredicateUtilities
+dependency2.to=PredicateUtilities
+dependency2.type=UsesDependency
+dependency3.from=TestStringUtilities
+dependency3.to=StringUtilities
+dependency3.type=UsesDependency
+editor.fx.0.height=722
+editor.fx.0.width=800
+editor.fx.0.x=998
+editor.fx.0.y=177
+objectbench.height=101
+objectbench.width=776
+package.divider.horizontal=0.6
+package.divider.vertical=0.8007380073800738
+package.editor.height=427
+package.editor.width=674
+package.editor.x=1080
+package.editor.y=216
+package.frame.height=600
+package.frame.width=800
+package.numDependencies=3
+package.numTargets=7
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.association=TestPredicateUtilities
+target1.height=50
+target1.name=PredicateUtilities
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=130
+target1.x=310
+target1.y=90
+target2.height=50
+target2.name=TestPredicateUtilities
+target2.showInterface=false
+target2.type=UnitTestTargetJunit4
+target2.width=160
+target2.x=340
+target2.y=60
+target3.height=50
+target3.name=TestMathUtilities
+target3.showInterface=false
+target3.type=UnitTestTargetJunit4
+target3.width=100
+target3.x=120
+target3.y=60
+target4.height=50
+target4.name=TestStringUtilities
+target4.showInterface=false
+target4.type=UnitTestTargetJunit4
+target4.width=110
+target4.x=390
+target4.y=190
+target5.association=TestMathUtilities
+target5.height=50
+target5.name=MathUtilities
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=100
+target5.x=90
+target5.y=90
+target6.association=TestStringUtilities
+target6.height=50
+target6.name=StringUtilities
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=110
+target6.x=360
+target6.y=220
+target7.height=50
+target7.name=ZipcodeRocks
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=110
+target7.x=130
+target7.y=220

src/main/java/com/zipcodewilmington/danny_do_better_exercises/MathUtilities.java

@@ -1,5 +1,3 @@
-package com.zipcodewilmington.danny_do_better_exercises;
-
 /**
  * Created by dan on 6/14/17.
  */
@@ -11,7 +9,7 @@ public class MathUtilities {
      * @return sum of `baseValue` and `difference`
      */
     public Integer add(int baseValue, int difference) {
-        return null;
+        return (baseValue + difference);
     }
 
     /**
@@ -20,7 +18,7 @@ public class MathUtilities {
      * @return sum of `baseValue` and `difference`
      */
     public Long add(long baseValue, long difference) {
-        return null;
+        return baseValue + difference;
     }
 
     /**
@@ -29,7 +27,8 @@ public class MathUtilities {
      * @return sum of `baseValue` and `difference`
      */
     public Short add(short baseValue, short difference) {
-        return null;
+        short sumShort = (short) (baseValue + difference);
+        return sumShort;
     }
 
     /**
@@ -38,7 +37,8 @@ public class MathUtilities {
      * @return sum of `baseValue` and `difference`
      */
     public Byte add(byte baseValue, byte difference) {
-        return null;
+        byte sumByte = (byte) (baseValue + difference);
+        return sumByte;
     }
 
     /**
@@ -47,7 +47,7 @@ public class MathUtilities {
      * @return sum of `baseValue` and `difference`
      */
     public Float add(float baseValue, float difference) {
-        return null;
+        return baseValue + difference;
     }
 
     /**
@@ -56,7 +56,7 @@ public class MathUtilities {
      * @return sum of `baseValue` and `difference`
      */
     public Double add(double baseValue, double difference) {
-        return null;
+        return baseValue + difference;
     }
 
     /**
@@ -65,7 +65,7 @@ public class MathUtilities {
      * @return difference between `baseValue` and `difference`
      */
     public Integer subtract(int baseValue, int difference) {
-        return null;
+        return baseValue - difference;
     }
 
     /**
@@ -74,7 +74,7 @@ public class MathUtilities {
      * @return difference between `baseValue` and `difference`
      */
     public Long subtract(long baseValue, long difference) {
-        return null;
+        return baseValue - difference;
     }
 
     /**
@@ -83,7 +83,8 @@ public class MathUtilities {
      * @return difference between `baseValue` and `difference`
      */
     public Short subtract(short baseValue, short difference) {
-        return null;
+        short minusShort = (short) (baseValue - difference);
+        return minusShort;
     }
 
     /**
@@ -92,7 +93,8 @@ public class MathUtilities {
      * @return difference between `baseValue` and `difference`
      */
     public Byte subtract(byte baseValue, byte difference) {
-        return null;
+        byte minusByte = (byte) (baseValue - difference);
+        return minusByte;
     }
 
     /**
@@ -101,7 +103,7 @@ public class MathUtilities {
      * @return difference between `baseValue` and `difference`
      */
     public Float subtract(float baseValue, float difference) {
-        return null;
+        return (baseValue - difference);
     }
 
     /**
@@ -110,131 +112,136 @@ public class MathUtilities {
      * @return difference between `baseValue` and `difference`
      */
     public Double subtract(double baseValue, double difference) {
-        return null;
+        return (baseValue - difference);
     }
 
 
     /**
      * @param dividend value to be divided
-     * @param divisor value to divide by
+     * @param divisor  value to divide by
      * @return division of `dividend` by `divisor
      */
     public Integer divide(int dividend, int divisor) {
-        return null;
+        return (dividend / divisor);
     }
 
     /**
      * @param dividend value to be divided
-     * @param divisor value to divide by
+     * @param divisor  value to divide by
      * @return division of `dividend` by `divisor
      */
     public Long divide(long dividend, long divisor) {
-        return null;
+        return (dividend / divisor);
     }
 
     /**
      * @param dividend value to be divided
-     * @param divisor value to divide by
+     * @param divisor  value to divide by
      * @return division of `dividend` by `divisor
      */
     public Short divide(short dividend, short divisor) {
-        return null;
+        short divShort = (short) (dividend / divisor);
+        return divShort;
     }
 
     /**
      * @param dividend value to be divided
-     * @param divisor value to divide by
+     * @param divisor  value to divide by
      * @return division of `dividend` by `divisor
      */
     public Byte divide(byte dividend, byte divisor) {
-        return null;
+        byte divByte = (byte) (dividend / divisor);
+        return divByte;
     }
 
     /**
      * @param dividend value to be divided
-     * @param divisor value to divide by
+     * @param divisor  value to divide by
      * @return division of `dividend` by `divisor
      */
     public Float divide(float dividend, float divisor) {
-        return null;
+        return (dividend / divisor);
     }
 
     /**
      * @param dividend value to be divided
-     * @param divisor value to divide by
+     * @param divisor  value to divide by
      * @return division of `dividend` by `divisor
      */
     public Double divide(double dividend, double divisor) {
-        return null;
+        return (dividend / divisor);
     }
 
 
     /**
      * @param multiplicand value to be multiplied
-     * @param multiplier value to multiply by
+     * @param multiplier   value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
     public Integer multiply(int multiplicand, int multiplier) {
-        return null;
+        return (multiplicand * multiplier);
     }
 
     /**
      * @param multiplicand value to be multiplied
-     * @param multiplier value to multiply by
+     * @param multiplier   value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
     public Long multiply(long multiplicand, long multiplier) {
-        return null;
+        return (multiplicand * multiplier);
     }
 
     /**
      * @param multiplicand value to be multiplied
-     * @param multiplier value to multiply by
+     * @param multiplier   value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
     public Short multiply(short multiplicand, short multiplier) {
-        return null;
+        short multShort = (short) (multiplicand * multiplier);
+        return multShort;
     }
+
     /**
      * @param multiplicand value to be multiplied
-     * @param multiplier value to multiply by
+     * @param multiplier   value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
     public Byte multiply(byte multiplicand, byte multiplier) {
-        return null;
+        byte multByte = (byte) (multiplicand * multiplier);
+        return multByte;
     }
 
     /**
      * @param multiplicand value to be multiplied
-     * @param multiplier value to multiply by
+     * @param multiplier   value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
     public Float multiply(float multiplicand, float multiplier) {
-        return null;
+        return (multiplicand * multiplier);
     }
 
     /**
      * @param multiplicand value to be multiplied
-     * @param multiplier value to multiply by
+     * @param multiplier   value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
     public Double multiply(double multiplicand, double multiplier) {
-        return null;
+        return (multiplicand * multiplier);
     }
 
 
     /**
-      * @return true
+     * @return true
      */
     public Boolean returnTrue() {
-        return null;
+        return true;
     }
 
     /**
      * @return false
      */
     public Boolean returnFalse() {
-        return null;
+        return false;
     }
 
 }

src/main/java/com/zipcodewilmington/danny_do_better_exercises/PredicateUtilities.java

@@ -1,4 +1,3 @@
-package com.zipcodewilmington.danny_do_better_exercises;
 
 /**
  * Created by dan on 6/14/17.
@@ -10,7 +9,14 @@ public class PredicateUtilities {
      * @return true if `x` is greater than `y`
      */
     public Boolean isGreaterThan(int x, int y) {
-        return null;
+        boolean z;
+
+        if (x > y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
     }
 
     /**
@@ -19,7 +25,14 @@ public class PredicateUtilities {
      * @return true if `x` is less than `y`
      */
     public Boolean isLessThan(int x, int y) {
-        return null;
+        boolean z;
+
+        if (x < y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
     }
 
     /**
@@ -28,7 +41,14 @@ public class PredicateUtilities {
      * @return true if `x` is greater than or equal to `y`
      */
     public Boolean isGreaterThanOrEqualTo(int x, int y) {
-        return null;
+        boolean z;
+
+        if (x >= y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
     }
 
     /**
@@ -37,6 +57,13 @@ public class PredicateUtilities {
      * @return true if `x` is less than or equal to `y`
      */
     public Boolean isLessThanOrEqualTo(int x, int y) {
-        return null;
+        boolean z;
+
+        if (x <= y) {
+            z = true;
+        } else {
+            z = false;
+        }
+        return z;
     }
 }

src/main/java/com/zipcodewilmington/danny_do_better_exercises/StringUtilities.java

@@ -1,5 +1,3 @@
-package com.zipcodewilmington.danny_do_better_exercises;
-
 /**
  * Created by dan on 6/14/17.
  */
@@ -8,7 +6,8 @@ public class StringUtilities {
      * @return `Hello World` as a string
      */
     public static String getHelloWorld() {
-        return null;
+        String hello = "Hello World";
+        return hello;
     }
 
     /**
@@ -17,7 +16,8 @@ public class StringUtilities {
      * @return the concatenation of two strings, `firstSegment`, and `secondSegment`
      */
     public static String concatenation(String firstSegment, String secondSegment){
-        return null;
+        String conCat = firstSegment.concat(secondSegment);
+        return conCat;
     }
 
     /**
@@ -26,7 +26,8 @@ public class StringUtilities {
      * @return the concatenation of an integer, `firstSegment`, and a String, `secondSegment`
      */
     public static String concatenation(int firstSegment, String secondSegment){
-        return null;
+        String conCat2 = (firstSegment + secondSegment);
+        return conCat2;
     }
 
     /**
@@ -34,7 +35,8 @@ public class StringUtilities {
      * @return the first 3 characters of `input`
      */
     public static String getPrefix(String input){
-        return null;
+        String firstThree = input.substring(0, 3);        
+        return firstThree;
     }
 
     /**
@@ -42,7 +44,8 @@ public class StringUtilities {
      * @return the last 3 characters of `input`
      */
     public static String getSuffix(String input){
-        return null;
+        String lastThree = input.substring((input.length() - 3), (input.length()));
+        return lastThree;
     }
 
     /**
@@ -51,7 +54,8 @@ public class StringUtilities {
      * @return the equivalence of two strings, `inputValue` and `comparableValue`
      */
     public static Boolean compareTwoStrings(String inputValue, String comparableValue){
-        return null;
+        boolean stringEqual = inputValue.equalsIgnoreCase(comparableValue);        
+        return stringEqual;
     }
 
     /**
@@ -59,7 +63,9 @@ public class StringUtilities {
      * @return the middle character of `inputValue`
      */
     public static Character getMiddleCharacter(String inputValue){
-        return null;
+        int midCharLocation = (inputValue.length() - 1) / 2;  // gets index #
+        char midChar = inputValue.charAt(midCharLocation);
+        return midChar;
     }
 
     /**
@@ -67,7 +73,9 @@ public class StringUtilities {
      * @return the first sequence of characters
      */
     public static String getFirstWord(String spaceDelimitedString){
-        return null;
+        int firstSpace = spaceDelimitedString.indexOf(" ");
+        String firstWord = spaceDelimitedString.substring(0, firstSpace);        
+        return firstWord;
     }
 
     /**
@@ -75,7 +83,20 @@ public class StringUtilities {
      * @return the second word of a string delimited by spaces.
      */
     public static String getSecondWord(String spaceDelimitedString){
-        return null;
+        // find index of first space
+        int firstSpace = spaceDelimitedString.indexOf(" ");
+        // find index of second space
+        int secondSpace = spaceDelimitedString.indexOf(" ", firstSpace + 1);
+
+        String secondWord;
+        
+        if (secondSpace > 0) {
+            secondWord = spaceDelimitedString.substring(firstSpace, secondSpace);
+        } else {
+            secondWord = spaceDelimitedString.substring((firstSpace + 1),(spaceDelimitedString.length()));
+        }
+
+        return secondWord;
     }
 
     /**
@@ -83,6 +104,11 @@ public class StringUtilities {
      * @return an identical string with characters in reverse order.
      */
     public static String reverse(String stringToReverse){
-        return null;
+        // change string in stringbuilder
+        StringBuilder reverseSB = new StringBuilder(stringToReverse);
+        // use built-in stringbuilder reverse method and then change back to string
+        String reverse = reverseSB.reverse().toString();
+        
+        return reverse;
     }
 }

src/main/java/com/zipcodewilmington/danny_do_better_exercises/ZipcodeRocks.java

@@ -5,6 +5,6 @@ package com.zipcodewilmington.danny_do_better_exercises;
  */
 public class ZipcodeRocks {
     public static void main(String[] args) {
-//         System.out.println("Zipcode Rocks!");
+         System.out.println("Zipcode Rocks!");
     }
 }