completed part1

src/main/java/Pair/Arrays.java

@@ -10,7 +10,7 @@ import java.util.Collections;
  * A max method that returns the largest item in the arraylist
  * And a minmax method that returns a pair containing the largest and smallest items from the array list
  */
-public class Arrays {
-    public static <___> Pair<E> firstLast(ArrayList<___> a) {
-    }
-}
+//public class Arrays {
+//    public static <___> Pair<E> firstLast(ArrayList<___> a) {
+//    }
+//}

src/main/java/StackArray/GenericStack.java

@@ -1,5 +1,7 @@
 package StackArray;
 
+//import com.sun.java.util.jar.pack.ConstantPool;
+
 import java.util.Arrays;
 
 /**
@@ -8,8 +10,36 @@ import java.util.Arrays;
  * @param <E>
  */
 public class GenericStack<E> {
-    private E[] elements;
+
+    private Object[] elements;
+    private int top;
+    private final static int EMPTY = -1;
+    private final static int DEFAULT_Capacity = 10;
 
     public GenericStack() {
+        this(DEFAULT_Capacity);
+    }
+
+    public GenericStack(int initialCapacity) {
+        elements =  new Object [initialCapacity];
+             top = EMPTY;
+    }
+
+    public boolean isEmpty(){
+        return (top == EMPTY);
+    }
+
+    @SuppressWarnings("unchecked")
+    public E pop(){
+        if (top == EMPTY){
+            throw new IndexOutOfBoundsException();
+        }
+        return (E)elements[top--];
+    }
+
+    public void push(E e) {
+        elements[++top] = e;
     }
 }
+
+

src/main/java/StackArrayList/Stack.java

@@ -1,16 +1,45 @@
 package StackArrayList;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
+import java.util.Arrays;
 
 /**
  * Implement Stack<E> by adding the push, pop, and isEmpty functions.  It must pass the prewritten unit tests.
  * If you pop on an empty stack, throw an IndexOutOfBoundsException.
  */
-public class Stack<E> {
-    private ArrayList elements;
+public class Stack<E>  {
 
+    private ArrayList<E> elements;
 
-    public Stack(){
+    public Stack() {
+        this.elements = new ArrayList();
+    }
+
+    /**
+     * @return true if this list contains no elements
+     */
+    public boolean isEmpty() {
+        return this.elements.size() == 0;
+    }
 
+    /**
+     * Pushes an item onto the top of this stack. This has exactly the same effect as:
+     * addElement(item)
+     * @param item the item to be pushed onto this stack.
+     *   //should return the item argument.
+     */
+    public void push(E item) {
+        elements.add(item);
+    }
+
+    /*
+    *Removes the object at the top of this stack
+    *returns that object as the value of this function.
+     */
+    public E pop() throws IndexOutOfBoundsException{
+        return this.elements.remove(this.elements.size() - 1);
     }
 }
+
+

src/test/java/StackArray/GenericStackTest.java

@@ -1,41 +1,41 @@
-//package StackArray;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//public class GenericStackTest {
-//    @Test
-//    public void testPushingGrowsTheStack() throws Exception {
-//        // Given an empty stack
-//        GenericStack<String> stack = new GenericStack<>();
-//
-//        // Assert that it is empty.
-//        Assert.assertEquals(true, stack.isEmpty());
-//        // When we push something onto the stack
-//        stack.push("foobar");
-//        // Then it shouldn't be empty
-//        Assert.assertEquals(false, stack.isEmpty());
-//    }
-//
-//    @Test
-//    public void testPushingAndPoppingOrder() throws Exception {
-//        // Given an empty stack
-//        GenericStack<String> stack = new GenericStack<>();
-//        // When we push two elements on it
-//        stack.push("foo");
-//        stack.push("bar");
-//        // Then we should see them returned in the correct order
-//        Assert.assertEquals("bar", stack.pop());
-//        Assert.assertEquals("foo", stack.pop());
-//    }
-//
-//    @Test(expected = IndexOutOfBoundsException.class)
-//    public void testPopFirst() throws Exception {
-//        // Given an empty stack
-//        GenericStack<String> stack = new GenericStack<>();
-//        // When it's popped
-//        stack.pop();
-//        // Then we should get an exception
-//    }
-//
-//}
+package StackArray;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class GenericStackTest {
+    @Test
+    public void testPushingGrowsTheStack() throws Exception {
+        // Given an empty stack
+        GenericStack<String> stack = new GenericStack<>();
+
+        // Assert that it is empty.
+        Assert.assertEquals(true, stack.isEmpty());
+        // When we push something onto the stack
+        stack.push("foobar");
+        // Then it shouldn't be empty
+        Assert.assertEquals(false, stack.isEmpty());
+    }
+
+    @Test
+    public void testPushingAndPoppingOrder() throws Exception {
+        // Given an empty stack
+        GenericStack<String> stack = new GenericStack<>();
+        // When we push two elements on it
+        stack.push("foo");
+        stack.push("bar");
+        // Then we should see them returned in the correct order
+        Assert.assertEquals("bar", stack.pop());
+        Assert.assertEquals("foo", stack.pop());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testPopFirst() throws Exception {
+        // Given an empty stack
+        GenericStack<String> stack = new GenericStack<>();
+        // When it's popped
+        stack.pop();
+        // Then we should get an exception
+    }
+
+}

src/test/java/StackArrayList/StackTest.java

@@ -1,45 +1,45 @@
-//package StackArrayList;
-//
-//import org.junit.Test;
-//
-//import org.junit.Assert;
-//
-//public class StackTest {
-//    @Test
-//    public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception {
-//        // Given an empty stack
-//        Stack<String> stack = new Stack<>();
-//        // Assert that it starts empty
-//        Assert.assertEquals(true, stack.isEmpty());
-//        // When an element gets pushed
-//        stack.push("foobar");
-//        // Then the stack should not be empty.
-//        Assert.assertEquals(false, stack.isEmpty());
-//    }
-//
-//    @Test
-//    public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception {
-//        // Given an empty stack
-//        Stack<String> stack = new Stack<>();
-//
-//        //When two items are pushed
-//        stack.push("foo");
-//        stack.push("bar");
-//
-//        // Then they should come off in reverse order.
-//        Assert.assertEquals("bar", stack.pop());
-//        Assert.assertEquals("foo", stack.pop());
-//
-//        // And then the stack should be empty
-//        Assert.assertEquals(true, stack.isEmpty());
-//    }
-//
-//    @Test(expected = IndexOutOfBoundsException.class)
-//    public void testPopFirst() throws Exception {
-//        // Given an empty stack
-//        Stack<String> stack = new Stack<>();
-//        // Then it is popped
-//        stack.pop();
-//        // We should get an exception
-//    }
-//}
+package StackArrayList;
+
+import org.junit.Test;
+
+import org.junit.Assert;
+
+public class StackTest {
+    @Test
+    public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception {
+        // Given an empty stack
+        Stack<String> stack = new Stack<>();
+        // Assert that it starts empty
+        Assert.assertEquals(true, stack.isEmpty());
+        // When an element gets pushed
+        stack.push("foobar");
+        // Then the stack should not be empty.
+        Assert.assertEquals(false, stack.isEmpty());
+    }
+
+    @Test
+    public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception {
+        // Given an empty stack
+        Stack<String> stack = new Stack<>();
+
+        //When two items are pushed
+        stack.push("foo");
+        stack.push("bar");
+
+        // Then they should come off in reverse order.
+        Assert.assertEquals("bar", stack.pop());
+        Assert.assertEquals("foo", stack.pop());
+
+        // And then the stack should be empty
+        Assert.assertEquals(true, stack.isEmpty());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testPopFirst() throws Exception {
+        // Given an empty stack
+        Stack<String> stack = new Stack<>();
+        // Then it is popped
+        stack.pop();
+        // We should get an exception
+    }
+}