complete

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(String str:array){
+            if(str.equals(value)){
+                result = true;
+                break;
+            }
+        }
+        return result;
     }
 
     /**
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+
+        String[] result = new String[array.length];
+        int j = 0;
+
+        for(int i = array.length-1; i>=0; i--){
+            result[j] = array[i];
+            j++;
+        }
+        return result;
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        return false;
+        boolean result = true;
+        int j = array.length-1;
+
+        for(String str:array){
+            if(!str.equals(array[j])){
+                result = false;
+            }
+            j--;
+        }
+        return result;
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        char[] alphabet = new char[26]; //string of alphabet characters
+        alphabet[0] = 'a';
+        for(int i = 0; i < 26; i++){
+            alphabet[i] = (char) ('a'+ i);
+        }
+
+        boolean result = true; //beginning with default true statement
+
+        StringBuilder sb = new StringBuilder();
+        for(String str : array){
+            sb.append(str.toLowerCase());
+        }
+
+        String arrStr = sb.toString();
+
+        for(char letter: alphabet){
+            if(!arrStr.contains(Character.toString(letter).toLowerCase())){
+                result = false;
+                break;
+            }
+        }
+
+        return result;
     }
 
     /**
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int i = 0;
+        for(String str : array){
+            if(str.contains(value)){
+                i++;
+            }
+        }
+        return i;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        String[] arr2 = new String[array.length-1];
+        int j = 0;
+
+        for(int i=0; i<array.length; i++){
+            if(array[i].equals(valueToRemove)){
+                continue;
+            }
+
+            arr2[j] = array[i];
+            j++;
+        }
+
+        return arr2;
     }
 
     /**
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+        String lastWord = "";
+
+        StringBuilder sb = new StringBuilder();
+        for(String str : array){
+            if(!str.equals(lastWord)) {
+                sb.append(str + "-");
+            }
+            lastWord = str;
+        }
+
+        String[] arr2 = sb.toString().split("-");
+        return arr2;
     }
 
     /**
      * @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;
+        StringBuilder sb = new StringBuilder(array[0]);
+        String lastWord = array[0];
+
+        for(int i=1; i<array.length; i++){
+            if(!array[i].equals(lastWord)){
+                sb.append("-");
+            }
+            sb.append(array[i]);
+            lastWord = array[i];
+        }
+
+        String[] result = sb.toString().split("-");
+        return result;
     }