done

StringArrayUtils.java

- 
 
 /**
  * Created by leon on 1/29/18.
  */
+import java.util.*;
 public class StringArrayUtils {
     /**
      * @param array array of String objects
      * @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;
+        int last_index=array.length-1;
+        return array[last_index];
     }
 
     /**
      * @return second to last element in specified array
      */ // TODO
     public static String getSecondToLastElement(String[] array) {
-        return null;
+
+        int last_index=array.length-2;
+        return array[last_index];
     }
 
     /**
      * @return true if the array contains the specified `value`
      */ // TODO
     public static boolean contains(String[] array, String value) {
-        return false;
+        Boolean b=false;
+        for(int i=0;i<array.length;i++)
+        {
+            if(array[i].equals(value))
+            {
+                b=true;
+            }
+        }
+        return b;
     }
 
     /**
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+        String[] str=new String[array.length];
+        int k=0;
+        for(int i=array.length-1;i>=0;i--)
+        {
+
+            str[k]=array[i];
+            k++;
+
+        }
+        //System.out.println((str));
+        return str;
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        return false;
+
+        String[] reversed=new String[array.length];
+        reversed=reverse(array);
+        boolean flag=true;
+        for( int i=0;i<reversed.length;i++)
+        {
+            if(!array[i].equals(reversed[i]))
+            {
+                flag=false;
+                break;
+
+            }
+        }
+        return flag;
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        ArrayList<Character> albha = new ArrayList<Character>();
+        String str="";
+        int count =0;
+        boolean result=false;
+        for(int i=0;i<array.length;i++)
+        {
+            str=str+array[i];
+        }
+        System.out.println(str);
+        str=str.toLowerCase();
+        for(int i=0;i<str.length();i++)
+        {
+            int k=str.charAt(i);
+            if(k>=65&&k<=90 || k>=97&&k<=122)
+            {
+               
+                if(!albha.contains(str.charAt(i)))
+                {
+
+                    albha.add(str.charAt(i));
+
+                    count ++;
+                }
+            }
+        }
+        
+        System.out.println(count);
+        System.out.println(albha);
+        
+        if(count==26)
+        {
+            result=true;
+        }
+        else
+        {
+            result=false;
+        }
+        return result;
     }
 
     /**
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int k=0;
+        for(int i=0;i<array.length;i++)
+        {
+            if(value.equals(array[i].toString()))
+            {
+                k++;
+            }
+        }
+        return k;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        int k=0;
+        int n=getNumberOfOccurrences(array,valueToRemove);
+        String[] newArray= new String[array.length-n];
+        for(int i=0;i<array.length;i++)
+        {
+            if(!array[i].equals(valueToRemove))
+            {
+                newArray[k]=array[i];
+                k++;
+
+            }
+
+        }
+        System.out.println(Arrays.toString(array));
+        return newArray;
     }
 
     /**
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+        int k=0;
+        
+        ArrayList<String> resultList = new ArrayList<String>();
+        resultList.add(array[0]);
+        for(int i = 1; i < array.length; i++) {
+
+            if(!array[i-1].equals(array[i])) {
+                resultList.add(array[i]);
+            }
+
+        }
+        String[] resultArray = resultList.toArray(new String[resultList.size()]);
+
+        return resultArray;
     }
 
     /**
      * @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> list = new ArrayList<>();
+        list.add(array[0]);
+        int k=0;
+
+        for(int i = 1 ; i < array.length ; i++) {
+
+            if(array[i-1].equalsIgnoreCase(array[i])){
 
+                String lastElement = list.get(list.size()-1);
+
+                lastElement = lastElement.concat(array[i]);
+
+                list.set(list.size()-1,lastElement);
+            }
+            else{
+                list.add(array[i]);
+            }
+        }
+
+        String[] newArray = list.toArray(new String[list.size()]);
+        return newArray;
+
+    }
 
 }

package.bluej

+#BlueJ package file
+dependency1.from=StringArrayUtilsTest
+dependency1.to=StringArrayUtils
+dependency1.type=UsesDependency
+editor.fx.0.height=729
+editor.fx.0.width=1280
+editor.fx.0.x=0
+editor.fx.0.y=23
+objectbench.height=101
+objectbench.width=461
+package.divider.horizontal=0.6
+package.divider.vertical=0.8007380073800738
+package.editor.height=427
+package.editor.width=674
+package.editor.x=353
+package.editor.y=162
+package.frame.height=600
+package.frame.width=800
+package.numDependencies=1
+package.numTargets=2
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+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=130
+target1.y=10
+target2.height=50
+target2.name=StringArrayUtils
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=120
+target2.x=70
+target2.y=70