Completed string arrays lab

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

 package com.zipcodewilmington;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+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) {
+        for(String word : array){
+            if(word.equals(value))
+            {
+                return true;
+            }
+        }
         return false;
     }
 
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+        //create a new array the same length as the new array
+        String[] reverseArray = new String[array.length];
+        //set a counter which iterates the new array from the begining
+        int counter = 0;
+        //starting from the back of the array, increment backwards towards and including 0
+        for(int i = array.length - 1; i >= 0; i --)
+        {
+            //assign the value of array at i, (the back of the array) to the front of the new array
+            reverseArray[counter] = array[i];
+            //increase the counter w
+            counter ++;
+        }
+        return reverseArray;
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
+        //loop through the array
+        for(int i = 0; i < array.length; i++){
+            if(array[i].equals(array[(array.length -1) - i])){
+                if(i == array.length -1){
+                    return true;
+                }
+            } else {
+                break;
+            }
+        }
         return false;
     }
 
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
+
+        //array list to add letters to
+        ArrayList<Character> alpha = new ArrayList<Character>();
+        //turn the array of strings into lowercase since uppercase and lowercase have different codes
+        String arrayString = Arrays.toString(array).toLowerCase();
+        //conver the string to an array of characters
+        char[] letters = arrayString.toCharArray();
+        //loop through each character
+        for(char letter : letters)
+        {
+            //if the character is already in the array, and is a letter / not symbol
+            if(alpha.contains(letter) && (letter <= 122 && letter >= 97)){
+                //skip this letter
+                continue;
+            //f the character is not in the array, and the is a letter / not a symbol
+            } else if(!alpha.contains(letter) && (letter <= 122 && letter >= 97)) {
+                //add this letter
+                alpha.add(letter);
+            }
+        }
+        //if the size of the array is 26 (all letters accounted for) return true
+        if(alpha.size() == 26){
+            return true;
+        }
+        //else return false
         return false;
     }
 
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int numberOfTimes = 0;
+        for(String word : array){
+            if(word.equals(value)){numberOfTimes ++;}
+        }
+        return numberOfTimes;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+
+        ArrayList<String> valulessList = new ArrayList<String>();
+
+        for(String values : array)
+        {
+            if(values.equals(valueToRemove))
+            {
+                continue;
+            } else {
+                valulessList.add(values);
+            }
+        }
+
+        String[] newArray = valulessList.toArray(new String[valulessList.size() - 1]);
+        return newArray;
     }
 
     /**
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+
+        ArrayList<String> consecString = new ArrayList<String>();
+
+        for(int i = 1; i < array.length; i ++){
+            String word = array[i - 1];
+            String next = array[i];
+
+            if(word.equals(next))
+            {
+                if(!consecString.contains(word)){
+                    consecString.add(word);
+                } else if(!consecString.get(consecString.size() - 1).equals(word) && consecString.contains(word)){
+                    consecString.add(word);
+                }
+            } else {
+                consecString.add(next);
+            }
+        }
+
+        String[] newArray = consecString.toArray(new String[consecString.size() - 1]);
+        System.out.println(Arrays.toString(newArray));
+        return newArray;
     }
 
     /**
      * @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> consecString = new ArrayList<String>();
+        String last = array[0];
+        consecString.add(array[0]);
+        //for each word
+        for(int i = 1; i < array.length; i ++){
+            String next = array[i];
+            //if the words are equal
+            if(next.equals(last))
+            {
+                consecString.set(consecString.size()-1, consecString.get(consecString.size()-1) + next);
+            } else {
+                consecString.add(next);
+                last = next;
+            }
+        }
 
+        String[] newArray = consecString.toArray(new String[consecString.size() - 1]);
+        System.out.println(Arrays.toString(newArray));
+        return newArray;
+    }
 }