Utilized class extract feature to clean up code. All test cases passed.

src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java

@@ -1,8 +1,83 @@
 package com.zipcodewilmington.looplabs;
 
+import java.util.Arrays;
+
 /**
  * Created by leon on 1/29/18.
  * @ATTENTION_TO_STUDENTS You are forbidden from modifying the signature of this class.
  */
 public final class IntegerDuplicateDeleter extends DuplicateDeleter<Integer> {
+    public IntegerDuplicateDeleter(Integer[] intArray) {
+        super(intArray);
+    }
+
+    @Override
+    public Integer[] removeDuplicates(int maxNumberOfDuplications) {
+        boolean checking = true;
+        int currentNumber;
+        int count = 0;
+        int currentIndex = 0;
+        StringBuilder dupString = new StringBuilder();
+
+        Arrays.sort(array);
+        if (maxNumberOfDuplications < 2) {
+            return new Integer[0];
+        } else {
+            while (checking) {
+                currentNumber = array[currentIndex];
+                count = Utils.countMatches(currentIndex, count, array, currentNumber);
+                Utils.appender(maxNumberOfDuplications, dupString, currentNumber, count);
+
+                if (Utils.isComplete(currentIndex, count, array)) {
+                    checking = false;
+                } else {
+                    currentIndex += count;
+                    count = 0;
+                }
+            }
+            String[]  dupArray= dupString.toString().split(",");
+            Integer[] dupNumArray = new Integer[dupArray.length];
+            int i = 0;
+
+            for (String str: dupArray) {
+                dupNumArray[i] = Integer.parseInt(str);
+                i++;
+            }
+            return dupNumArray;
+        }
+    }
+
+    @Override
+    public Integer[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+        boolean checking = true;
+        int currentNumber;
+        int count = 0;
+        int currentIndex = 0;
+        StringBuilder dupString = new StringBuilder();
+
+        Arrays.sort(array);
+        while(checking) {
+            currentNumber = array[currentIndex];
+            count = Utils.countMatches(currentIndex, count, array, currentNumber);
+            Utils.appendExact(exactNumberOfDuplications, dupString, currentNumber, count);
+
+            if (Utils.isComplete(currentIndex, count, array)) {
+                checking = false;
+            } else {
+                currentIndex += count;
+                count = 0;
+            }
+        }
+        String[]  dupArray= dupString.toString().split(",");
+        Integer[] dupNumArray = new Integer[dupArray.length];
+        int i = 0;
+
+        for (String str: dupArray) {
+            dupNumArray[i] = Integer.parseInt(str);
+            i++;
+        }
+        return dupNumArray;
+
+    }
+
 }

src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java

@@ -1,8 +1,68 @@
 package com.zipcodewilmington.looplabs;
 
+import java.util.Arrays;
+
 /**
  * Created by leon on 1/28/18.
  * @ATTENTION_TO_STUDENTS You are forbidden from modifying the signature of this class.
  */
 public final class StringDuplicateDeleter extends DuplicateDeleter<String> {
-}
+
+
+    public StringDuplicateDeleter(String[] intArray) {
+        super(intArray);
+    }
+
+    public String[] removeDuplicates(int maxNumberOfDuplications) {
+        boolean checking = true;
+        String currentString = "";
+        int count = 0;
+        int currentIndex = 0;
+        StringBuilder dupString = new StringBuilder();
+
+        Arrays.sort(array);
+        if (maxNumberOfDuplications < 2) {
+            return new String[0];
+        } else {
+            while (checking) {
+                currentString = array[currentIndex];
+                count = Utils.countMatches(currentIndex, count, array, currentString);
+                Utils.appender(maxNumberOfDuplications, dupString, currentString, count);
+
+                if (Utils.isComplete(currentIndex, count, array)) {
+                    checking = false;
+                } else {
+                    currentIndex += count;
+                    count = 0;
+                }
+            }
+            String[] dupArray = dupString.toString().split(",");
+            return dupArray;
+        }
+    }
+
+
+    public String[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+        boolean checking = true;
+        String currentString = "";
+        int count = 0;
+        int currentIndex = 0;
+        StringBuilder dupString = new StringBuilder();
+
+        Arrays.sort(array);
+        while(checking) {
+            currentString = array[currentIndex];
+            count = Utils.countMatches(currentIndex, count, array, currentString);
+            Utils.appendExact(exactNumberOfDuplications, dupString, currentString, count);
+
+            if (Utils.isComplete(currentIndex, count, array)) {
+                checking = false;
+            } else {
+                currentIndex += count;
+                count = 0;
+            }
+        }
+    String[] dupArray = dupString.toString().split(",");
+    return dupArray;
+    }
+}

src/main/java/com/zipcodewilmington/looplabs/Utils.java

@@ -0,0 +1,93 @@
+package com.zipcodewilmington.looplabs;
+
+public class Utils {
+
+    public static void appender(int maxNumberOfDuplications, StringBuilder dupString, String currentString, int count) {
+        if (count < maxNumberOfDuplications) {
+            for (int i = 0; i < count; i++) {
+                dupString.append(currentString + ",");
+            }
+        }
+    }
+
+    public static void appender(int maxNumberOfDuplications, StringBuilder dupString, int currentNumber, int count) {
+        if (count < maxNumberOfDuplications) {
+            for (int i = 0; i < count; i++) {
+                dupString.append(currentNumber + ",");
+            }
+        }
+    }
+
+    public static boolean isMatch(String currentString, String currentIndex) {
+        if (currentString.equals(currentIndex)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean isMatch(int currentNumber, int currentIndex) {
+        if (currentNumber == (currentIndex)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean isComplete(int currentIndex, int count, String[] array) {
+        if (currentIndex + count == array.length) {
+            return true;
+
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean isComplete(int currentIndex, int count, Integer[] array) {
+        if (currentIndex + count == array.length) {
+            return true;
+
+        } else {
+            return false;
+        }
+    }
+
+    public static void appendExact(int exactNumberOfDuplications, StringBuilder dupString, String currentString, int count) {
+        if (count != exactNumberOfDuplications) {
+            for (int i = 0; i < count; i++) {
+                dupString.append(currentString + ",");
+            }
+        }
+    }
+
+    public static void appendExact(int exactNumberOfDuplications, StringBuilder dupString, int currentString, int count) {
+        if (count != exactNumberOfDuplications) {
+            for (int i = 0; i < count; i++) {
+                dupString.append(currentString + ",");
+            }
+        }
+    }
+
+    public static int countMatches(int currentIndex, int count, String[] array, String currentString) {
+
+        for(int i = currentIndex; i<array.length;i++){
+
+            if (Utils.isMatch(currentString, array[i])) {
+                count++;
+            } else break;
+        }
+        return count;
+    }
+
+    public static int countMatches(int currentIndex, int count, Integer[] array, int currentNumber) {
+
+        for(int i = currentIndex; i<array.length;i++){
+
+            if (Utils.isMatch(currentNumber, array[i])) {
+                count++;
+            } else break;
+        }
+        return count;
+    }
+
+}