finished lab

StringArrayUtils.java

-import java.util.Arrays;
+import java.util.*;
 
 /**
  * Created by leon on 1/29/18.
      * @param array array of String objects
      * @return last element in specified array
      */ // TODO
-    public static String getLastElement(String[] array) {        
-        return array[array.length - 1];
+    public static String getLastElement(String[] array) {
+        return array[array.length-1];
     }
 
     /**
      * @param value value to check array for
      * @return true if the array contains the specified `value`
      */ // TODO
-    public static boolean contains(String[] array, String value) {        
+    public static boolean contains(String[] array, String value) {
         
         for(String x : array) {
-            if(value == x) {
+            if(value.equals(x)) {
                 return true;
             }
         }
         return false;
     }
 
+
     /**
      * @param array of String objects
      * @return an array with identical contents in reverse order
         
         String[] reverseArr = new String[array.length];
         
-        for(int i=0; i<array.length; i++){            
+        for(int i = 0; i < array.length; i++){
             reverseArr[i] = array[array.length - i - 1];
         }
         return reverseArr;
         String[] reverseArr = reverse(array);
         String[] regArr = new String[array.length];
         
-        for(int i=0; i<array.length; i++){
-             regArr[i] = array[i];
-        }
-        
-        if(regArr ==  reverseArr) {
-            return true;
-        }
+        for(int i= 0; i < array.length; i++){
+            regArr[i] = array[i];
+                if(regArr[i] == reverseArr[i]) {
+                    return true;
+                }
+            }
         return false;
     }
 
-
-
     /**
      * @param array array of String objects
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        String alphabet = "abcdefghijklmnopqrstuvwxyz";
+        String fullCombinedString = String.join("", array).toLowerCase();
+        for(char c : alphabet.toCharArray()) {
+            if(fullCombinedString.indexOf(c) < 0) {
+                return false;
+            }
+        }
+        return true;
+        
+        
+        /*
+        for(char c : alphabet.toCharArray()) {
+            boolean found = false;
+            for(String word : array) {
+                word = word.toLowerCase();
+                if(word.indexOf(c) >= 0)
+                found = true;
+                break;
+            }
+            if(!found) {
+                return false;
+        }
+    }
+        return true;*/
     }
 
+
     /**
      * @param array array of String objects
      * @param value value to check array for
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int count = 0;
+        for(String s : array) {
+            if(s == value) {
+                count++;
+            }
+        }
+        return count;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        List<String> newArray = new ArrayList<>();
+        
+        for(String s : array) {
+            if(s != valueToRemove) {
+                newArray.add(s);
+            }
+        }
+        return newArray.toArray(new String[] {});
     }
 
     /**
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
+        List<String> newArray = new ArrayList<>();
         
+        for(int i = 0; i < array.length; i++) {
+            String added = array[i];
+            newArray.add(added);
+            int toRemove = 0;
+            
+            for(; toRemove + i + 1 < array.length; toRemove++) {
+                if(array[i + 1 + toRemove] != added){
+                    break;
+                }                
+            }
+            i += toRemove;        
+        }
+        return newArray.toArray(new String[] {});
+}
 
-        
-        return null;    
-    }
-    
     /**
      * @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;
+        List<String> newArray = new ArrayList<>();
+        
+        for(int i = 0; i < array.length; i++) {
+            String added = array[i];
+            String toAdd = added;
+            int toRemove = 0;
+            
+            for(; toRemove + i + 1 < array.length; toRemove++) {
+                if(array[i + 1 + toRemove] != added){
+                    break;
+                }  
+                toAdd += array[i + 1 + toRemove];
+            }
+            newArray.add(toAdd);
+            i += toRemove;        
+        }
+        System.out.println(Arrays.toString(newArray.toArray()));
+        return newArray.toArray(new String[] {});
     }
 
 

StringArrayUtilsTest.java

         Assert.assertEquals(expected, actual);
     }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
     @Test
     public void testGetSecondElement1() {
         String[] array = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         Assert.assertEquals(expected, actual);
     }
 
+
     @Test
     public void testGetSecondElement3() {
         String[] array = {"brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         Assert.assertEquals(expected, actual);
     }
 
+
+
+
+
+
+
+
+
+
+
     @Test
     public void testGetLastElement1() {
         String[] array = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         Assert.assertEquals(expected, actual);
     }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     @Test
     public void testGetSecondToLastElement1() {
         String[] array = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};

package.bluej

+#BlueJ package file
+dependency1.from=StringArrayUtilsTest
+dependency1.to=StringArrayUtils
+dependency1.type=UsesDependency
+editor.fx.0.height=1087
+editor.fx.0.width=1239
+editor.fx.0.x=600
+editor.fx.0.y=0
+objectbench.height=155
+objectbench.width=760
+package.divider.horizontal=0.6
+package.divider.vertical=0.676
+package.editor.height=331
+package.editor.width=670
+package.editor.x=78
+package.editor.y=78
+package.frame.height=600
+package.frame.width=800
+package.numDependencies=1
+package.numTargets=2
+package.showExtends=true
+package.showUses=true
+project.charset=windows-1252
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=StringArrayUtilsTest
+target1.showInterface=false
+target1.type=UnitTestTargetJunit4
+target1.width=150
+target1.x=120
+target1.y=10
+target2.height=50
+target2.name=StringArrayUtils
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=120
+target2.x=70
+target2.y=70