finished and passed tests

src/main/java/com/zipcodewilmington/StringArrayUtils.java

 package com.zipcodewilmington;
 
+import java.util.Arrays;
+
 /**
  * Created by leon on 1/29/18.
  */
      * @return first element of specified array
      */ // TODO
     public static String getFirstElement(String[] array) {
-        return null;
+        return array[0];
     }
 
     /**
      * @return second element in specified array
      */
     public static String getSecondElement(String[] array) {
-        return null;
+        return array[1];
     }
 
     /**
      * @return last element in specified array
      */ // TODO
     public static String getLastElement(String[] array) {
-        return null;
+        return array[array.length - 1];
     }
 
     /**
      * @return second to last element in specified array
      */ // TODO
     public static String getSecondToLastElement(String[] array) {
-        return null;
+        return array[array.length - 2];
     }
 
     /**
      * @return true if the array contains the specified `value`
      */ // TODO
     public static boolean contains(String[] array, String value) {
-        return false;
+
+        boolean result = false;
+
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == value) {
+                result = true;
+                break;
+            }
+        }
+
+        return result;
     }
 
     /**
      * @param array of String objects
      * @return an array with identical contents in reverse order
      */ // TODO
+    // Make an empty String array.
+    // Set the last element of the original array to the first of the empty one.
+    // Keep looping til the number of iterations reach the end of the array.
     public static String[] reverse(String[] array) {
-        return null;
+
+        String[] reverseArray = new String[array.length];
+
+        for (int i = 0; i < array.length; i++) {
+            reverseArray[i] = array[array.length - (i + 1)];
+        }
+
+        return reverseArray;
     }
 
     /**
      * @param array array of String objects
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
+    // Basically you wanna reverse the array and then see if the first half of the arrays are the same?
     public static boolean isPalindromic(String[] array) {
-        return false;
+
+        String[] reverseArray = new String[array.length];
+
+        for (int i = 0; i < array.length; i++) {
+            reverseArray[i] = array[array.length - (i + 1)];
+        }
+
+        boolean palindrome = false;
+
+        for (int i = 0; i < (array.length / 2); i++)
+            if (reverseArray[i] == array[i]) {
+                palindrome = true;
+            }
+
+        return palindrome;
+
     }
 
     /**
      * @param array array of String objects
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
+    // Convert array to string
+    // BOOLEAN ARRAY?? length of 26 so each index matches the number of an alphbet (0 = a, 1 = b, etc).
+    // Convert letters to ASCII, then 0-25. Then for each letter of the array,
+    // log true for the number of the character at the index. If it's already logged
+    // true just move on. If the full boolean array is true then return true?
     public static boolean isPangramic(String[] array) {
-        return false;
+
+        boolean[] alphabet = new boolean[26];
+
+        String stringArray = Arrays.toString(array).toLowerCase();
+
+        int alphaNum;
+
+        for (int i = 0; i < stringArray.length(); i++) {
+            if (stringArray.charAt(i) != ' ' && stringArray.charAt(i) != '[' && stringArray.charAt(i) != ']' && stringArray.charAt(i) != ',') {
+                alphaNum = ((int) stringArray.charAt(i)) - 97;
+                alphabet[alphaNum] = true;
+            }
+        }
+
+        boolean result = true;
+
+        for (int i = 0; i < alphabet.length; i++) {
+            if (alphabet[i] == false) {
+                result = false;
+                break;
+            }
+        }
+        return result;
     }
 
+
     /**
      * @param array array of String objects
      * @param value value to check array for
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
+    // Log occurrences in int set to 0.
+    // For each element in the array, if the specified value equals the value of the element, increase 1.
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+
+        int occurrences = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equalsIgnoreCase(value)) {
+                occurrences++;
+            }
+        }
+        return occurrences;
     }
 
     /**
      * @param valueToRemove value to remove from array
      * @return array with identical contents excluding values of `value`
      */ // TODO
+    // Check if the elements of each array is equal to the value to remove.
+    // If yes... log occurrences of value, but do nothing with it.
+    // Create empty string array whose length is the original minus the occurrences.
+    // If no... assign current operating index of new array as the value.
+
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+
+        int occurrences = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equals(valueToRemove)) {
+                occurrences++;
+            }
+        }
+
+        String[] newArray = new String[array.length - occurrences];
+        int j = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            if (!array[i].equals(valueToRemove)) {
+                newArray[j] = array[i];
+                j++;
+            }
+        }
+        return newArray;
     }
 
     /**
      * @param array array of chars
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
+    // Check each element, if array[i] is equal to array[i - 1], log the occurrence.
+    // The length of that array will be the number of occurrences of duplicates subtracted from original length?
+    // Then make a "result" array that's the original array length minus occurrences.
+    // Then basically loop through the original array again, somehow skip the logged duplicates,
+    // and only put the non-duplicate elements into the result array.
+
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+
+        int occurrences = 0;
+
+        for (int i = 1; i < array.length; i++) {
+            if (array[i].equals(array[i - 1])) {
+                occurrences++;
+            }
+        }
+
+        String[] newArray = new String[array.length - occurrences];
+
+        // j is the index of the new array that we're populating, comparison is helping us keep track of which duplicates we've logged.
+        int j = 0;
+        String compareDuplicate = "";
+
+        // We're checking each element of the array to the one before it, so we start at index 1 so we don't get an out of bounds error.
+        // So just immediately log the first element in the new array.
+        newArray[0] = array[0];
+
+        // Then, for each element of the array, if it doesn't equal the comparison value, put the value in the new array and move to the next new array index.
+        for (int i = 1; i < array.length; i++) {
+            if (!array[i].equals(compareDuplicate)) {
+                newArray[j] = array[i];
+                compareDuplicate = newArray[j];
+                j++;
+            }
+        }
+
+        return newArray;
     }
 
     /**
      * @param array array of chars
      * @return array of Strings with each consecutive duplicate occurrence concatenated as a single string in an array of Strings
      */ // TODO
+
     public static String[] packConsecutiveDuplicates(String[] array) {
-        return null;
+
+        String[] newArray;
+
+        String stringArray = Arrays.toString(array);
+        StringBuilder lettersOnly = new StringBuilder();
+
+        // This loop sorts through the string and only keeps the alphabet characters (so no weird symbols or spaces)
+        for (int i = 0; i < stringArray.length() - 1; i++) {
+            if (stringArray.charAt(i) != '[' && stringArray.charAt(i) != ',' && stringArray.charAt(i) != ' ' && stringArray.charAt(i) != ']') {
+                lettersOnly.append(stringArray.charAt(i));
+            }
+        }
+
+        StringBuilder groupSameLetters = new StringBuilder();
+
+        // Since we're comparing the character to the one before it, we gotta start at index 1 so that we don't get an out of index error.
+        // So this just appends the first character automatically to the front of the new StringBuilder.
+        groupSameLetters.append(lettersOnly.charAt(0));
+
+        // This loop compares the character to the one before it, and if it's not the same, append an underscore before the character.
+        for (int i = 1; i < lettersOnly.length(); i++) {
+            if (lettersOnly.charAt(i) != (lettersOnly.charAt(i - 1))) {
+                groupSameLetters.append('_');
+                groupSameLetters.append(lettersOnly.charAt(i));
+            } else {
+                groupSameLetters.append(lettersOnly.charAt(i));
+            }
+        }
+
+        newArray = groupSameLetters.toString().split("_");
+
+        return newArray;
     }