part 1 & 2

src/main/java/Pair/Arrays.java

-package Pair;
-
-import java.util.ArrayList;
-import java.util.Collections;
-
-/**
- * In here you must make firstLast, which will return a pair of the first element in the array list and the last
- * element in the arraylist.
- * You must also make a min method that returns the smallest item in the array list
- * 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) {
-    }
-}
+//package Pair;
+//
+//import java.util.ArrayList;
+//import java.util.Collections;
+//
+///**
+// * In here you must make firstLast, which will return a pair of the first element in the array list and the last
+// * element in the arraylist.
+// * You must also make a min method that returns the smallest item in the array list
+// * 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) {
+//    }
+//}

src/main/java/StackArray/ObjectStack.java

-package StackArray;
-
-import java.util.Arrays;
-
-/**
- * Expand the ArrayList implementation of stack here to use an Object[] array.  Still implement push, pop, and isEmpty.
- * Remember, you might need to resize the stack in the push method.
- * @param <E>
- */
-public class ObjectStack<E> {
-    private Object[] elements;
-
-    public ObjectStack() {
-
-    }
-}
+//package StackArray;
+//
+//import java.util.Arrays;
+//
+///**
+// * Expand the ArrayList implementation of stack here to use an Object[] array.  Still implement push, pop, and isEmpty.
+// * Remember, you might need to resize the stack in the push method.
+// * @param <E>
+// */
+//public class ObjectStack<E> {
+//    private Object[] elements;
+//
+//    public ObjectStack() {
+//        this.elements = new Object[];
+//    }
+//    //the way stacks work, its just like generics accept you are using Objects
+//    public Object push(Object value){
+//
+//    }
+//}

src/main/java/StackArrayList/Stack.java

  * If you pop on an empty stack, throw an IndexOutOfBoundsException.
  */
 public class Stack<E> {
+
     private ArrayList elements;
 
 
     public Stack(){
+        this.elements = new ArrayList<E>();
+    }
+
+    public void push(E value){
+        //pushes adds an element
+        this.elements.add(value);
+    }
+
+    public E pop(){
+        //removes an element
+        return (E) elements.remove(this.elements.size()-1);
+    }
+
+    public boolean isEmpty(){
+        //Checks to see is the elements array is empty, if its equal to 0 its empty.
+        return (elements.size()==0);
+    }
 
+    public E pop() {
+        return (E) this.elements;
     }
 }

src/test/java/StackArrayList/StackTest.java

-//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
+    }
+}