// Comments on ArrayIntSet.

1. Implement the missing methods in the ArrayIntSet class. Tester code in included.
2. You may only add new code inside the bodies of the 2 methods you are asked to write. You may also write new private helper methods. Key Ideas/Tips

When the ArrayIntSet is created, the client/user specifies an initial capacity for the array being used to hold the elements of the set. However, the set is initially empty. Elements can be added to it. This means that most of the time, the size of the array is bigger than the size of the set, meaning that some of the slots in the array are not being used. Write your code to maintain the following invariants:

• The size field is always equal to the size of the set. (In other words, it tells you how many of the slots of the array are actually in use.)
• The numbers in the set are stored in slots 0 through size-1 of the data array.

If the client/user tries to add a new element but there are no empty slots left in the data array, you will need to create a new array that is larger, copy over all the elements, and then start using the new array to store newly inserted elements (including the currently inserted element.

//Trying to addelement and remove element from ArrayIntSet

//Here is code:

public class ArrayIntSet { private int[] data; private int size;

public ArrayIntSet(int capacity) { data = new int[capacity]; //array named data size = 0; //has size 0 }

public int size() { return size; }

public boolean contains(int i) { for (int index = 0; index < size; index++) { if (data[index] == i) return true; } return false; }

// Ignore this equals method. Used for testing. public boolean equals(Object otherObject) { ArrayIntSet other = (ArrayIntSet) otherObject; return this.equals(other); public boolean addElement(int element) { // Code here }

/** * Removes an element from the set. * * @param element the element to be removed * @return ture if the element was removed and false * otherwise. */ public boolean removeElement(int element) { // Code here }

//And here is the tester code

public void test01AddElementToEmpty() { ArrayIntSet s1 = new ArrayIntSet(4); //s1 new ArrayIntSet(4); ArrayIntSet s2 = new ArrayIntSet(4); //s2 new ArrayIntSet(4);

assertTrue(s1.addElement(1)); assertEquals(1, s1.size()); assertEquals(0, s2.size()); assertTrue(s1.contains(1)); assertFalse(s2.contains(1)); //falseCheck

assertTrue(s2.addElement(1)); //adding 1 to s2 assertEquals(1, s1.size()); //checking size of the set s1 assertEquals(1, s2.size()); //checking size of the set s2 assertTrue(s1.contains(1)); //s1 contains 1 }

@Test public void test01AddElementToNonEmpty() { // s1 = {1, -1, 0}; // s2 = {-4, 2, 9}; ArrayIntSet s1 = new ArrayIntSet(10); s1.addElement(1); // s1 = {1, -1, 0}; s1.addElement(-1); s1.addElement(0); ArrayIntSet s2 = new ArrayIntSet(10); s2.addElement(-4); //s2 = {-4, 2, 9}; assertTrue(s1.addElement(-5)); assertEquals(4, s1.size()); //s1 = {1, -1, 0, -5}; //after adding -5 our set looks like this assertTrue(s1.contains(1)); assertTrue(s1.contains(0)); assertTrue(s1.contains(-1)); assertTrue(s1.contains(-5)); assertFalse(s1.contains(2)); //falseCheck assertFalse(s1.contains(9)); //falseCheck assertFalse(s1.contains(-4)); //falseCheck

// Check s2 assertEquals(3, s2.size()); assertTrue(s2.contains(-4)); assertTrue(s2.contains(2)); assertTrue(s2.contains(9)); assertFalse(s2.contains(-5)); //falseCheck }

@Test public void test01removeEmpty() { ArrayIntSet s1 = new ArrayIntSet(10); assertFalse(s1.removeElement(-4)); assertEquals(0, s1.size()); assertFalse(s1.removeElement(1)); assertEquals(0, s1.size()); assertFalse(s1.removeElement(0)); // assertEquals(0, s1.size()); // }

@Test public void test01removeSingle() { // s1 = {5} // s2 = {5} ArrayIntSet s1 = new ArrayIntSet(10); s1.addElement(5); //MAKING new set with size of 10 named s1 // add 5 to it ArrayIntSet s2 = new ArrayIntSet(10); s2.addElement(5); //MAKING new set with size of 10 named s2 // add 5 to it assertTrue(s1.removeElement(5)); //removeElement 5 from set s1 assertEquals(0, s1.size()); assertEquals(1, s2.size()); assertFalse(s1.contains(5)); assertTrue(s2.contains(5));

assertTrue(s2.removeElement(5)); //removeElement 5 from set s2 assertEquals(0, s1.size()); assertEquals(0, s2.size()); assertFalse(s1.contains(5)); assertFalse(s2.contains(5)); }

@Test public void test01removeMultiple() { // s1 = {1, 3, 5} // s2 = {2, 3, 4} ArrayIntSet s1 = new ArrayIntSet(10); s1.addElement(1); s1.addElement(3); s1.addElement(5); ArrayIntSet s2 = new ArrayIntSet(10); s2.addElement(2); s2.addElement(3); s2.addElement(4);

assertTrue(s2.removeElement(3)); assertEquals(3, s1.size()); assertTrue(s1.contains(1)); assertFalse(s1.contains(2)); assertTrue(s1.contains(3)); assertFalse(s1.contains(4));

assertTrue(s1.removeElement(5)); assertEquals(2, s1.size()); assertTrue(s1.contains(1)); assertFalse(s1.contains(2));

assertTrue(s1.removeElement(3)); assertEquals(1, s1.size()); assertTrue(s1.contains(1)); assertFalse(s1.contains(2)); assertFalse(s1.contains(3)); assertFalse(s1.contains(4)); assertFalse(s1.contains(5)); assertFalse(s2.contains(1)); assertTrue(s2.contains(2)); assertFalse(s2.contains(3)); assertTrue(s2.contains(4)); assertFalse(s2.contains(5));

assertTrue(s1.removeElement(1)); assertEquals(0, s1.size()); assertFalse(s1.contains(1)); assertFalse(s1.contains(2)); assertFalse(s1.contains(3)); assertFalse(s1.contains(4)); assertFalse(s1.contains(5)); assertFalse(s2.contains(1)); assertTrue(s2.contains(2)); assertFalse(s2.contains(3)); assertTrue(s2.contains(4)); assertFalse(s2.contains(5)); }

@Test public void test01removeMissing() { // s1 = {1, 3, 5} // s2 = {2, 4, 6} ArrayIntSet s1 = new ArrayIntSet(10); s1.addElement(1); s1.addElement(3); s1.addElement(5); ArrayIntSet s2 = new ArrayIntSet(10); s2.addElement(2); s2.addElement(4); s2.addElement(6); assertFalse(s2.removeElement(1)); assertFalse(s1.removeElement(2)); assertFalse(s2.removeElement(3)); assertFalse(s1.removeElement(4)); assertFalse(s2.removeElement(5)); assertFalse(s1.removeElement(6)); assertEquals(3, s1.size()); assertTrue(s1.contains(1)); assertFalse(s1.contains(2)); assertTrue(s1.contains(3)); assertFalse(s1.contains(4)); assertTrue(s1.contains(5)); assertFalse(s1.contains(6)); assertEquals(3, s2.size()); assertFalse(s2.contains(1)); assertTrue(s2.contains(2)); assertFalse(s2.contains(3)); assertTrue(s2.contains(4)); assertFalse(s2.contains(5)); assertTrue(s2.contains(6)); }