finished lab

StringArrayUtils.java

      * @return true if the array contains the specified `value`
      */ // TODO
     public static boolean contains(String[] array, String value) {
+        boolean contains = false;
         for (String ithString : array) {
             if (ithString.equals(value)) {
-                return true;
+                contains = true;
+                break;
             }
         }
-        return false;
+        return contains;
     }
 
     /**
      */ // TODO
     public static boolean isPalindromic(String[] array) {
         String[] reverse = reverse(array);
+        boolean isPalindrome = true;
         for (int i = 0; i < array.length; i++) {
             if (!array[i].equals(reverse[i])) {
-                return false;
+                isPalindrome = false;
+                break;
             }
         }
-        return true;
+        return isPalindrome;
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        //stringbuilder holding all letters of alpha
-        StringBuilder alphabet = new StringBuilder("abcdefghijklmnopqrstuvwxyz");
-        //iterate over each word of the array and then each char of word
-        for (String word : array) {
-            for (int i = 0; i < word.length(); i++) {
-                int index = alphabet.indexOf("" + word.toLowerCase().charAt(i));
-                if (index >= 0) {
-                    alphabet.deleteCharAt(index);
-                }
-                if (alphabet.length() == 0) {
-                    return true;
-                }
+        boolean isPangramic = true;
+        String alpha = "abcdefghijklmnopqrstuvwxyz";
+        String[] alphaArr = newArray(alpha);
+        StringBuilder allChars = new StringBuilder();
+        for(String word1 : array) {
+            allChars.append(word1);
+        }
+        String[] allCharsArr = newArray(allChars.toString().toLowerCase());
+        
+        for (String letter1 : alphaArr) {
+            if (!contains(allCharsArr, letter1)) {
+                isPangramic = false;
+                break;
             }
         }
-        return false;
+        return isPangramic;
+    }
+    
+    public static String[] newArray(String word) {
+        String[] newArr = new String[word.length()];
+        for (int i = 0; i < word.length(); i++) {
+            newArr[i] = "" + word.charAt(i);
+        }
+        return newArr;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        List<String> arrRemoved = new ArrayList<String>();
-        for (String word : array) {
-            if (!word.equals(valueToRemove)) {
-                arrRemoved.add(word);
+        int numOcc = getNumberOfOccurrences(array, valueToRemove);
+        String[] removedArr = new String[array.length - numOcc];
+        int i = 0;
+        for (String word1 : array) {
+            if (!word1.equals(valueToRemove)) {
+                removedArr[i] = word1;
+                i++;
             }
         }
-        String[] removedArray = new String[arrRemoved.size()];
-        removedArray = arrRemoved.toArray(removedArray);
-        return removedArray;
-             
+        return removedArr;
+    }
+    
+    public static int countDuplicated(String[] array) {
+        int count = 0;
+        for (int i = 1; i < array.length; i++) {
+            if (array[i].equals(array[i - 1])) {
+                count++;
+            }
+        }
+        return count;
     }
-
     /**
      * @param array array of chars
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        List<String> removedValues = new ArrayList<String>();
-        for (String word : array) {
-            //empty or last added value doesnt equal iterated word of array
-            if (removedValues.isEmpty() || 
-            !removedValues.get(removedValues.size() - 1).equals(word)) {
-                removedValues.add(word);
+        int totalDups = countDuplicated(array);
+        String[] removedArr = new String[array.length - totalDups];
+        
+        int index = 1;
+        removedArr[0] = array[0];
+        for (int i = 1; i < array.length; i++) {
+            if (!array[i].equals(array[i - 1])) {
+                removedArr[index] = array[i];
+                index++;
             }
         }
-        String[] nonDuplicate = new String[removedValues.size()];
-        nonDuplicate = removedValues.toArray(nonDuplicate);
-        return nonDuplicate;
+        return removedArr;
     }
 
     /**
      * @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) {
-        for (String singleChar : array) {
-            
+        StringBuilder dupB = new StringBuilder(array[0]);
+        String[] packedDupArr= new String[array.length - countDuplicated(array)];
+        
+        int index = 0;
+        for (int i = 1; i < array.length; i++) {
+            if (array[i].equals(array[i - 1])) {
+                dupB.append(array[i]);
+            } else {
+                packedDupArr[index] = dupB.toString();
+                dupB.setLength(0);
+                dupB.append(array[i]);
+                index++;
+            }
         }
-        return null;
+        packedDupArr[index] = dupB.toString();
+        return packedDupArr;
     }
 
 }