Implemented String Utilities

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

@@ -1,56 +1,56 @@
 package com.zipcodewilmington;
+import java.util.HashSet;
+import java.util.*;
+import java.util.List;
+//import com.sun.tools.javac.util.ArrayUtils;
+import java.util.ArrayList;
+import java.lang.CharSequence;
+
+import java.util.*;
 
-/**
- * Created by leon on 1/29/18.
- */
 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];
     }
 
-    /**
-     * @param array array of String objects
-     * @return second element in specified array
-     */
     public static String getSecondElement(String[] array) {
-        return null;
+
+        return array[1];
     }
 
-    /**
-     * @param array array of String objects
-     * @return last element in specified array
-     */ // TODO
+
     public static String getLastElement(String[] array) {
-        return null;
+        return array[array.length - 1];
     }
 
-    /**
-     * @param array array of String objects
-     * @return second to last element in specified array
-     */ // TODO
+
     public static String getSecondToLastElement(String[] array) {
-        return null;
+
+        return array[array.length - 2];
     }
 
-    /**
-     * @param array array of String objects
-     * @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) {
+
+        for (String str : array) {
+            if (value.equals(str))
+                return true;
+        }
         return false;
     }
 
-    /**
-     * @param array of String objects
-     * @return an array with identical contents in reverse order
-     */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+
+        String[] myStr = new String[array.length];
+        int myInt;
+        myInt = (array.length) - 1;
+        for (String str : array) {
+            myStr[myInt--] = str;
+            System.out.println(str);
+        }
+        //  int i = array.length;
+        return myStr;
     }
 
     /**
@@ -58,6 +58,17 @@ public class StringArrayUtils {
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
+        String s[] = new String[array.length];
+        int myInt;
+        myInt = (array.length) - 1;
+        for (String str : array) {
+            s[myInt--] = str;
+        }
+
+        for (int i = 0, j = 0; i < array.length; i++, j++) {
+            if (array[i].equals(s[j]))
+                return true;
+        }
         return false;
     }
 
@@ -66,16 +77,44 @@ public class StringArrayUtils {
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        StringBuffer sb = new StringBuffer();
+        String alpha = "abcdefghijklmnopqrstuvwxyz";
+        int count = 0;
+        String str = "";
+        // create a string from stringarray
+        for (int i = 0; i < array.length; i++) {
+            sb.append(array[i]);
+        }
+        str = sb.toString().toLowerCase();
+        //check if all the alphabets are in the input array
+        for (int i = 0; i < 26; i++) {
+            if (str.contains( String.valueOf(alpha.charAt(i)))) {
+                count++;
+            }
+            System.out.println("Total count value" + count);
+        }
+
+        //check if counter is 26
+        if (count == 26)
+            return true;
+        else
+            return false;
     }
 
-    /**
+
+
+    /*}*
      * @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 str : array) {
+            if (value.equals(str))
+                count++;
+        }
+        return count;
     }
 
     /**
@@ -84,7 +123,18 @@ public class StringArrayUtils {
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+
+
+        ArrayList<String> nameList = new ArrayList<String>();
+        for(String str : array) {
+            if (!valueToRemove.equalsIgnoreCase(str)) {
+                nameList.add(str);
+            }
+        }
+            String[] names = nameList.toArray(new String[nameList.size()]);
+
+
+        return names;
     }
 
     /**
@@ -92,7 +142,42 @@ public class StringArrayUtils {
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+      /*  ArrayList<String> nameList = new ArrayList<String>();
+        Collections.addAll(nameList,array) ;
+        HashSet<String> hs = new HashSet();
+        hs.add(nameList);
+        nameList.clear() ;
+        nameList.addAll(hs);
+        String[] names = nameList.toArray(new String[nameList.size()]);
+*/
+       ArrayList<String> nameList=new ArrayList<String>();
+       int len=array.length;
+        for(int i=0;i<len;i++) {
+            if (i + 1 < len && (array[i].equals(array[i + 1]))) {
+                continue;
+            } else {
+                nameList.add(array[i]);
+            }
+        }
+            String names[]= nameList.toArray(new String[nameList.size()]);
+
+      return names;
+
+     /*  String s[]=new String[array.length];
+       int len =array.length;
+        String str[]={};
+       for(int i=0;i<=len;i++) {
+           if (i+1<len && (array[i].equals( array[i + 1]))) {
+               continue;
+           }
+           else
+           {
+
+            System.out.println(array[i]);
+
+           }
+       }*/
+
     }
 
     /**
@@ -100,8 +185,49 @@ public class StringArrayUtils {
      * @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>  str1=new ArrayList<String>();
+
+      int len=array.length;
+
+      StringBuffer sbTemp = new StringBuffer("");
+      boolean flag = false;
+      int i=0;
+    while (i < len-1  ) {
+
+    if (array[i].equalsIgnoreCase(array[i + 1])) {
+              flag = true;
+              sbTemp.append(array[i]);
+          } else {
+              if (flag==true) {
+                  sbTemp.append(array[i]);
+                  str1.add(sbTemp.toString());
+                  sbTemp = new StringBuffer("");
+              } else {
+                  str1.add(array[i]);
+
+              }
+              flag = false;
+          }
+          i++;
+
+      }
+        if (flag==true) {
+            sbTemp.append(array[i]);
+            str1.add(sbTemp.toString());
+            sbTemp = new StringBuffer("");
+        } else {
+            str1.add(array[i]);
+
+        }
+
+      String names[]= str1.toArray(new String[str1.size()]);
+
+             System.out.println(names);
+
+            return names;
+
+
+    }
 }

src/test/java/com/zipcodewilmington/StringArrayUtilsTest.java

@@ -193,7 +193,7 @@ public class StringArrayUtilsTest {
         String[] array = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] expected = {"dog", "lazy", "the", "over", "jumps", "fox", "brown", "quick", "the"};
         String[] actual = StringArrayUtils.reverse(array);
-        Assert.assertEquals(expected, actual);
+        Assert.assertArrayEquals(expected, actual);
     }
 
 
@@ -202,7 +202,7 @@ public class StringArrayUtilsTest {
         String[] array  = {"dog", "lazy", "the", "over", "jumps", "fox", "brown", "quick", "the"};
         String[] expected = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] actual = StringArrayUtils.reverse(array);
-        Assert.assertEquals(expected, actual);
+        Assert.assertArrayEquals(expected, actual);
     }
 
 
@@ -210,7 +210,7 @@ public class StringArrayUtilsTest {
     public void testReverse3() {
         String[] expected = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] actual = StringArrayUtils.reverse(StringArrayUtils.reverse(expected));
-        Assert.assertEquals(expected, actual);
+        Assert.assertArrayEquals(expected,actual);
     }
 
 
@@ -246,14 +246,6 @@ public class StringArrayUtilsTest {
         Assert.assertFalse(outcome);
     }
 
-
-
-
-
-
-
-
-
     @Test
     public void testIsPangramic1() {
         String[] array = {"The quick brown", "Fox jumps over", "The lazy dog"};
@@ -324,7 +316,13 @@ public class StringArrayUtilsTest {
 
 
 
-
+    @Test
+    public void testRemoveValue() {
+        String[] array = {"aba", "aba", "baa", "bab", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        String[] actual = StringArrayUtils.removeConsecutiveDuplicates(array);
+        String[] expected = {"aba", "baa", "bab", "bba", "bbb"};
+        Assert.assertEquals(actual, expected);
+    }
 
 
 
@@ -365,10 +363,6 @@ public class StringArrayUtilsTest {
 
 
 
-
-
-
-
     @Test
     public void testRemovePackDuplicates1() {
         String[] array = {"a", "a", "a", "b", "c", "c", "a", "a", "d"};
@@ -404,19 +398,11 @@ public class StringArrayUtilsTest {
 
 
     @Test
-    public void testRemoveValue() {
-        String[] array = {"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
-        String[] expected = {"quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
-        String[] actual = StringArrayUtils.removeValue(array, "The");
-        Assert.assertEquals(expected, actual);
-    }
-
-    @Test
     public void testRemoveValue1() {
         String[] array = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] expected = {"the", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] actual = StringArrayUtils.removeValue(array, "quick");
-        Assert.assertEquals(expected, actual);
+        Assert.assertArrayEquals(expected, actual) ;
     }
 
     @Test
@@ -424,7 +410,7 @@ public class StringArrayUtilsTest {
         String[] array = {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] expected = {"the", "quick", "fox", "jumps", "over", "the", "lazy", "dog"};
         String[] actual = StringArrayUtils.removeValue(array, "brown");
-        Assert.assertEquals(expected, actual);
+        Assert.assertArrayEquals(expected, actual);
     }