passed all of the test.

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

 package com.zipcodewilmington;
 
+import com.sun.deploy.util.ArrayUtil;
+import com.sun.tools.javac.util.ArrayUtils;
+import java.lang.String;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+
 /**
- * Created by leon on 1/29/18.
+ * Edited by William 10.24.2018.
  */
 public class StringArrayUtils {
     /**
      * @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;
+        //Arrays.asList(array).indexOf(value);
+        boolean output = false;
+        for(int i = 0; i< array.length; i++){
+            if(array[i].equals(value)){
+                output = true;
+            }
+        }
+        return output;
     }
 
     /**
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+        String[] output = new String[array.length];
+        int j = 0;
+        for(int i = array.length - 1; i >= 0; i--){
+            output[j] = array[i];
+            j++;
+        }
+        return output;
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        return false;
+        boolean Palindromic = false;
+        String[] newArray = reverse(array);
+        //reverse(array);
+        for(int i = 0; i < array.length; i++) {
+            if (newArray[i] == array[i]) {
+                Palindromic = true;
+            } else if(newArray[i] != array[i]){
+                Palindromic = false;
+            }
+        }
+        return Palindromic;
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        String arrayString = "";
+        for(int k = 0; k < array.length; k++){
+            arrayString += array[k];
+        }
+        arrayString = arrayString.toLowerCase();
+        String alphabet = "abcdefghijklmnopqrstuvwxyz";
+
+        for(int i = 0; i < arrayString.length(); i++){
+            for(int j = 0; j <= 25; j++){
+                if(arrayString.indexOf(alphabet.charAt(j)) == -1){
+                    return false;
+                }
+            }
+        }
+        return true;
     }
 
     /**
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int output = 0;
+        for(int i = 0; i< array.length; i++){
+            if(array[i].equals(value)){
+                output = output + 1;
+            }
+        }
+        return output;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        //int output = 0;
+        ArrayList<String> arrayWithout = new ArrayList<String>();
+        for(int i = 0; i < array.length; i++) {
+            if (!(array[i].equals(valueToRemove))) {
+                arrayWithout.add(array[i]);
+            }
+        }
+        String[] finalArray = arrayWithout.toArray(new String[arrayWithout.size()]);
+        return finalArray;
     }
 
     /**
      * @param array array of chars
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
-    public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+    public static String[] removeConsecutiveDuplicates(String[] array){
+        ArrayList<String> arrayWithout = new ArrayList<String>();
+        String previous = "";
+        for(int i = 0; i < array.length; i++){
+            if(!(previous.equals(array[i]))){
+                arrayWithout.add(array[i]);
+            }
+            previous = array[i];
+        }
+        String[] finalArray = arrayWithout.toArray(new String[arrayWithout.size()]);
+        return finalArray;
     }
 
     /**
      * @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;
+        ArrayList<String> packArray = new ArrayList<String>();
+        String previous = array[0];
+        String holder = array[0];
+        for(int i = 1; i < array.length; i++){
+            if(!(previous.equals(array[i]))){
+                packArray.add(holder);
+                holder = "";
+            }
+            holder += array[i];
+                //if(!holder.equals("")){
+                //    packArray.add(holder);
+                //    holder = "";
+                //}
+            previous = array[i];
+        }
+        packArray.add(holder);
+        String[] finalArray = packArray.toArray(new String[packArray.size()]);
+        for(int k = 0; k < finalArray.length; k++) {
+        }
+        return finalArray;
     }