Change Indices implementation to treeset

src/main/java/seedu/address/commons/core/index/Index.java

@@ -4,13 +4,13 @@
 
 /**
  * Represents a zero-based or one-based index.
- *
+ * <p>
  * {@code Index} should be used right from the start (when parsing in a new user input), so that if the current
  * component wants to communicate with another component, it can send an {@code Index} to avoid having to know what
  * base the other component is using for its index. However, after receiving the {@code Index}, that component can
  * convert it back to an int if the index will not be passed to a different component again.
  */
-public class Index {
+public class Index implements Comparable<Index> {
     private int zeroBasedIndex;
 
     /**
@@ -47,6 +47,11 @@ public static Index fromOneBased(int oneBasedIndex) {
         return new Index(oneBasedIndex - 1);
     }
 
+    @Override
+    public int compareTo(Index other) {
+        return this.zeroBasedIndex - other.zeroBasedIndex;
+    }
+
     @Override
     public boolean equals(Object other) {
         if (other == this) {

src/main/java/seedu/address/commons/core/index/Indices.java

@@ -1,7 +1,10 @@
 package seedu.address.commons.core.index;
 
-import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.SortedSet;
+import java.util.TreeSet;
 
 import seedu.address.commons.util.ToStringBuilder;
 
@@ -13,14 +16,14 @@
  * one index provided.
  */
 public class Indices {
-    private final ArrayList<Index> zeroBasedIndices;
+    private final SortedSet<Index> zeroBasedIndices;
     private int size;
 
     /**
      * Indices can only be created by calling {@link Indices#fromZeroBased} or
      * {@link Indices#fromOneBased(int[])}.
      */
-    private Indices(ArrayList<Index> zeroBasedIndices) {
+    private Indices(SortedSet<Index> zeroBasedIndices) {
         this.zeroBasedIndices = zeroBasedIndices;
         this.size = zeroBasedIndices.size();
     }
@@ -30,13 +33,11 @@ private Indices(ArrayList<Index> zeroBasedIndices) {
      */
     public static Indices fromZeroBased(int[] zeroBasedIndices) {
         Arrays.sort(zeroBasedIndices);
-        ArrayList<Index> result = new ArrayList<>();
+        SortedSet<Index> result = new TreeSet<>();
 
         for (int index : zeroBasedIndices) {
             Index zeroBasedIndex = Index.fromZeroBased(index);
-            if (!result.contains(zeroBasedIndex)) {
-                result.add(zeroBasedIndex);
-            }
+            result.add(zeroBasedIndex);
         }
         return new Indices(result);
     }
@@ -46,29 +47,33 @@ public static Indices fromZeroBased(int[] zeroBasedIndices) {
      */
     public static Indices fromOneBased(int[] oneBasedIndices) {
         Arrays.sort(oneBasedIndices);
-        ArrayList<Index> result = new ArrayList<>();
+        SortedSet<Index> result = new TreeSet<>();
 
         for (int index : oneBasedIndices) {
             Index oneBasedIndex = Index.fromOneBased(index);
-            if (!result.contains(oneBasedIndex)) {
-                result.add(oneBasedIndex);
-            }
+            result.add(oneBasedIndex);
         }
         return new Indices(result);
     }
 
     public int[] getZeroBased() {
         int[] result = new int[size];
-        for (int i = 0; i < size; i++) {
-            result[i] = this.zeroBasedIndices.get(i).getZeroBased();
+        Iterator<Index> iterator = this.zeroBasedIndices.iterator();
+        int counter = 0;
+        while (iterator.hasNext()) {
+            result[counter] = iterator.next().getZeroBased();
+            counter++;
         }
         return result;
     }
 
     public int[] getOneBased() {
         int[] result = new int[size];
-        for (int i = 0; i < size; i++) {
-            result[i] = this.zeroBasedIndices.get(i).getOneBased();
+        Iterator<Index> iterator = this.zeroBasedIndices.iterator();
+        int counter = 0;
+        while (iterator.hasNext()) {
+            result[counter] = iterator.next().getOneBased();
+            counter++;
         }
         return result;
     }
@@ -111,14 +116,14 @@ public int getSize() {
      * Returns the smallest zero-based index in indices.
      */
     public int getZeroBasedMin() {
-        return this.zeroBasedIndices.get(0).getZeroBased();
+        return Collections.min(this.zeroBasedIndices).getZeroBased();
     }
 
     /**
      * Returns the largest zero-based index in indices.
      */
     public int getZeroBasedMax() {
-        return this.zeroBasedIndices.get(size - 1).getZeroBased();
+        return Collections.max(this.zeroBasedIndices).getZeroBased();
     }
 
     @Override
@@ -137,13 +142,7 @@ public boolean equals(Object other) {
         if (this.size != otherIndices.size) {
             return false;
         }
-
-        for (int i = 0; i < this.size; i++) {
-            if (!this.zeroBasedIndices.get(i).equals(otherIndices.zeroBasedIndices.get(i))) {
-                return false;
-            }
-        }
-        return true;
+        return this.zeroBasedIndices.equals(otherIndices.zeroBasedIndices);
     }
 
     @Override

src/test/java/seedu/address/commons/core/index/IndexTest.java

@@ -37,6 +37,25 @@ public void createZeroBasedIndex() {
         assertEquals(6, Index.fromZeroBased(5).getOneBased());
     }
 
+    @Test
+    public void compareTo() {
+        //equal
+        assertEquals(0, Index.fromOneBased(1).compareTo(Index.fromOneBased(1)));
+        assertEquals(0, Index.fromZeroBased(0).compareTo(Index.fromOneBased(1)));
+
+        //less than
+        assertEquals(true, Index.fromOneBased(1)
+                .compareTo(Index.fromOneBased(2)) < 0);
+        assertEquals(true, Index.fromZeroBased(0)
+                .compareTo(Index.fromOneBased(2)) < 0);
+
+        //more than
+        assertEquals(true, Index.fromOneBased(2)
+                .compareTo(Index.fromOneBased(1)) > 0);
+        assertEquals(true, Index.fromZeroBased(1)
+                .compareTo(Index.fromOneBased(1)) > 0);
+    }
+
     @Test
     public void equals() {
         final Index fifthPersonIndex = Index.fromOneBased(5);