group and sorted group passing

src/main/java/rocks/zipcode/io/quiz4/collections/ComparableTreeSet.java

@@ -5,31 +5,45 @@ import java.util.TreeSet;
 /**
  * @author leon on 11/12/2018.
  */
-public class ComparableTreeSet<T> implements Comparable<T> {
+public class ComparableTreeSet<T> extends TreeSet<T> implements Comparable<ComparableTreeSet<T>> {
 
     TreeSet<T> treeSet;
 
     public ComparableTreeSet(T... arr) {
-        for(T item: arr){
-            treeSet.add(item);
+        this.treeSet = new TreeSet<>();
+        for(T item: arr) {
+            this.treeSet.add(item);
         }
     }
 
     public ComparableTreeSet() {
-    }
-
-    public Integer compareTo(ComparableTreeSet<T> o) {
-
-        return 0;
+        this.treeSet = new TreeSet<>();
     }
 
     public TreeSet<T> getTreeSet() {
         return treeSet;
     }
 
-    @Override
-    public int compareTo(T o) {
+    public int compareTo(ComparableTreeSet<T> o) {
 
+//        return this.treeSet.first().compareTo(o.getTreeSet().first());
         return 0;
     }
+
+    @Override
+    public String toString() {
+        StringBuilder str = new StringBuilder();
+        str.append("[");
+
+        for(T item: this.treeSet) {
+            str.append(item.toString());
+            str.append(", ");
+        }
+        str.deleteCharAt(str.length() - 1);
+        str.deleteCharAt(str.length() - 1);
+
+        return str + "]";
+    }
+
+
 }

src/main/java/rocks/zipcode/io/quiz4/generics/Group.java

@@ -1,37 +1,64 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 
 /**
  * @author leon on 18/12/2018.
  */
-public class Group<_> {
+public class Group<T> implements Iterable, GroupInterface {
+
+    List<T> groupList;
+
     public Group() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        this.groupList = new ArrayList<>();
     }
 
     public Integer count() {
-        return null;
+        return this.groupList.size();
     }
 
-    public void insert(_ value) {
+    @Override
+    public Boolean has(Object valueToInsert) {
+        return this.groupList.contains(valueToInsert);
     }
 
-    public Boolean has(_ value) {
-        return null;
+
+    public T fetch(int indexOfValue) {
+        return this.groupList.get(indexOfValue);
     }
 
-    public _ fetch(int indexOfValue) {
-        return null;
+    @Override
+    public void insert(Object string) {
+        this.groupList.add((T) string);
     }
 
-    public void delete(_ value) {
+    @Override
+    public void delete(Object valueToInsert) {
+        this.groupList.remove(valueToInsert);
     }
 
     public void clear() {
+        this.groupList.clear();
     }
 
-    public Iterator<_> iterator() {
-        return null;
+
+    @Override
+    public Iterator iterator() {
+        return this.groupList.iterator();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder str = new StringBuilder();
+        str.append("[");
+        for(T item: this.groupList){
+            str.append(item.toString() + ", ");
+        }
+        str.delete(str.length() - 2, str.length());
+        str.append("]");
+
+        return str.toString();
     }
 }

src/main/java/rocks/zipcode/io/quiz4/generics/SortedGroup.java

@@ -1,18 +1,27 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.Collections;
+
 /**
  * @author leon on 18/12/2018.
  */
-public class SortedGroup<_> extends Group<_> {
+public class SortedGroup<T extends Comparable> extends Group<T> {
+
     @Override
-    public void insert(_ value) {
+    public void insert(Object value) {
+        this.groupList.add((T)value);
+        Collections.sort(this.groupList);
     }
 
     @Override
-    public void delete(_ value) {
+    public void delete(Object value) {
+        this.groupList.remove(value);
+        Collections.sort(this.groupList);
+
     }
 
-    public Integer indexOf(_ firstValue) {
-        return null;
+    public Integer indexOf(T firstValue) {
+
+        return this.groupList.indexOf(firstValue);
     }
 }