assignment complete. enjoy.

src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -1,5 +1,7 @@
 package ArrayListCombiner;
 
+import Table.Entry;
+
 import java.util.ArrayList;
 
 /**
@@ -9,4 +11,16 @@
  * The second method should be called superCombiner and should use ? super E
  */
 public class ArrayListCombiner {
+
+    public static <E> ArrayList extendCombiner(ArrayList <E> firstArray, ArrayList <? extends E> secondArray){
+        firstArray.addAll(secondArray);
+        return firstArray;
+
+    }
+
+    public static <E> ArrayList superCombiner(ArrayList <? super E> firstArray, ArrayList <E> secondArray){
+        firstArray.addAll(secondArray);
+        return firstArray;
+
+    }
 }

src/main/java/MapFunc/MapFunc.java

@@ -9,4 +9,14 @@
  */
 public class MapFunc {
 
+    // in this case, T is input and R is output
+    public static <T, R> ArrayList<R> map(ArrayList<T> myInput, Function<T,R> myFunc){
+        ArrayList<R> output = new ArrayList<>();
+        for (T element : myInput){
+            output.add(myFunc.apply(element));
+        }
+        return output;
+
+    }
+
 }

src/main/java/Pair/Arrays.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 
 /**
  * In here you must make firstLast, which will return a pair of the first element in the array list and the last
@@ -10,7 +11,42 @@
  * 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<E extends Comparable> {
+    public static <E extends Comparable> Pair<E> firstLast(ArrayList<E> arrayList) {
+       E firstItem = arrayList.get(0);
+       E lastItem = arrayList.get(arrayList.size()-1);
+
+       Pair<E> answer= new Pair<>(firstItem,lastItem);
+
+       return answer;
+
+    }
+
+    public static <E extends Comparable> E min (ArrayList<E> arrayList) {
+        arrayList.sort(Comparator.naturalOrder());
+        E minItem = arrayList.get(0);
+
+        return minItem;
+
     }
+
+    public static <E extends Comparable> E max (ArrayList<E> arrayList) {
+        arrayList.sort(Comparator.naturalOrder());
+        E maxItem = arrayList.get(arrayList.size()-1);
+
+        return maxItem;
+
+
+    }
+
+    public static <E extends Comparable> Pair<E> minMax (ArrayList<E> arrayList) {
+        arrayList.sort(Comparator.naturalOrder());
+
+        Pair <E> answer = new Pair(arrayList.get(0), arrayList.get(arrayList.size()-1));
+
+        return answer;
+
+    }
+
+
 }

src/main/java/Pair/Pair.java

@@ -7,6 +7,39 @@
  * min -> returns the minimum of the pair
  * max -> returns the maximum of the pair
  */
-public class Pair {
+public class Pair<E extends Comparable> {
+
+    E firstVal;
+    E secondVal;
+
+    public Pair(E firstVal, E secondVal){
+        this.firstVal=firstVal;
+        this.secondVal=secondVal;
+    }
+
+    public E getFirst(){
+        return firstVal;
+    }
+
+    public E getSecond(){
+        return secondVal;
+    }
+
+    public E min(){
+
+        E smallerOfTwo;
+        smallerOfTwo= firstVal.compareTo(secondVal) == 1 ? secondVal:firstVal;
+
+        return smallerOfTwo;
+    }
+
+    public E max(){
+
+        E largerOfTwo;
+        largerOfTwo= firstVal.compareTo(secondVal) == 1 ? firstVal:secondVal;
+
+        return largerOfTwo;
+
+    }
 
 }

src/main/java/Stack.java

@@ -0,0 +1,5 @@
+//public class Stack <E>{
+//    public boolean isEmpty(){
+//        return false;
+//    }
+//}

src/main/java/StackArray/GenericStack.java

@@ -1,6 +1,7 @@
 package StackArray;
 
 import java.util.Arrays;
+import java.util.Stack;
 
 /**
  * Expand the ArrayList implementation of stack here to use an E[] array.  Still implement push, pop, and isEmpty.
@@ -10,6 +11,31 @@
 public class GenericStack<E> {
     private E[] elements;
 
+   // GenericStack<String> myStack = new GenericStack<>();
+
     public GenericStack() {
+        elements = (E[]) new Object[0];
+
+        //casting to just an object: (not array)
+        // element = (E) new Object;
+
+    }
+
+    public boolean isEmpty() {
+
+        return elements.length==0;
+
+    }
+
+    public void push(E foobar) {
+        elements= Arrays.copyOf(elements, elements.length+1);
+        elements[elements.length-1] = foobar;
+    }
+
+
+    public E pop() {
+        E lastElement = (E) elements[elements.length-1];
+        elements=Arrays.copyOf(elements,elements.length-1);
+        return lastElement;
     }
 }

src/main/java/StackArray/ObjectStack.java

@@ -1,5 +1,6 @@
 package StackArray;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 
 /**
@@ -11,6 +12,22 @@ public class ObjectStack<E> {
     private Object[] elements;
 
     public ObjectStack() {
+        elements= new Object[0];
 
     }
+
+    public boolean isEmpty() {
+        return elements.length==0;
+    }
+
+    public void push(E foobar) {
+        elements=Arrays.copyOf(elements,elements.length+1);
+        elements[elements.length-1] = foobar;
+    }
+
+    public E pop() {
+        E lastElement = (E) elements[elements.length-1];
+        elements= Arrays.copyOf(elements,elements.length-1);
+        return lastElement;
+    }
 }

src/main/java/StackArrayList/Stack.java

@@ -7,10 +7,29 @@
  * If you pop on an empty stack, throw an IndexOutOfBoundsException.
  */
 public class Stack<E> {
+
     private ArrayList elements;
 
 
     public Stack(){
+        this.elements = new ArrayList();
+    }
+
+    public boolean isEmpty() {
+        boolean answer = false;
+        answer = elements.size()==0;
+
+        return answer;
+    }
+
+    public void push(E foobar) {
+        elements.add(foobar);
+
+    }
 
+    public E pop() {
+        E lastElement = (E) elements.get(elements.size()-1);
+        elements.remove(elements.size()-1);
+        return lastElement;
     }
 }

src/main/java/Table/Table.java

@@ -1,5 +1,6 @@
 package Table;
 
+import java.lang.annotation.ElementType;
 import java.util.ArrayList;
 
 /**
@@ -10,8 +11,58 @@
  * Void return on `remove`.
  */
 public class Table<K, V> {
-    private ArrayList entries;
+    private ArrayList<Entry> entries;
 
     public Table() {
+        entries= new ArrayList<>();
     }
+
+//    public V get(K key){
+//
+//        for (Entry element: entries){
+//            if (element.getKey().equals(key)){
+//                return (V) element.getValue();
+//            }
+//        }
+//
+//        return null;
+//
+//    }
+
+    public V get(K key){
+
+        V ourLocalVariable = null;
+
+
+        for (Entry element: entries){
+            if (element.getKey().equals(key)){
+                ourLocalVariable =(V) element.getValue();
+            }
+        }
+
+        return ourLocalVariable;
+
+    }
+
+    public void put(K foo, V i){
+        Entry ourEntry = new Entry(foo, i);
+        for (Entry element: entries){
+            if (element.getKey().equals(ourEntry.getKey())){
+                entries.set(entries.indexOf(element),ourEntry);
+            }
+        }
+
+        entries.add(ourEntry);
+
+    }
+
+    public void remove(K foo){
+        for (Entry element: entries){
+            if (element.getKey().equals(foo)){
+                entries.remove(element);
+                break;
+            }
+        }
+    }
+
 }

src/main/java/TableNested/TableNested.java

@@ -8,4 +8,68 @@
  */
 public class TableNested<K, V> {
 
+    private ArrayList<Entry> entries;
+
+    public TableNested() {
+        entries= new ArrayList<>();
+    }
+
+
+    public class Entry<K, V> {
+        private K key;
+        private V value;
+
+        public Entry(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+    }
+
+
+    public V get(K key){
+
+        V ourLocalVariable = null;
+
+
+        for (Entry element: entries){
+            if (element.getKey().equals(key)){
+                ourLocalVariable =(V) element.getValue();
+            }
+        }
+
+        return ourLocalVariable;
+
+    }
+
+    public void put(K foo, V i){
+        Entry ourEntry = new Entry(foo, i);
+        for (Entry element: entries){
+            if (element.getKey().equals(ourEntry.getKey())){
+                entries.set(entries.indexOf(element),ourEntry);
+            }
+        }
+
+        entries.add(ourEntry);
+
+    }
+
+    public void remove(K foo){
+        for (Entry element: entries){
+            if (element.getKey().equals(foo)){
+                entries.remove(element);
+                break;
+            }
+        }
+    }
+
+
 }