VVG

src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -8,5 +8,24 @@
  * The first method should be called extendCombiner and should use ? extends E
  * The second method should be called superCombiner and should use ? super E
  */
-public class ArrayListCombiner {
+public class ArrayListCombiner<E> {
+
+//    private ArrayList<E> first;
+//    private ArrayList<E> second;
+
+    public ArrayListCombiner() {
+//        first = new ArrayList<>();
+//        second = new ArrayList<>();
+    }
+
+    public static <E> void extendCombiner(ArrayList<E> first, ArrayList<? extends E> second) {
+        first.addAll(second);
+
+    }
+
+    public static <E> void superCombiner(ArrayList<? super E> first, ArrayList<E> second) {
+        first.addAll(second);
+
+    }
+
 }

src/main/java/MapFunc/MapFunc.java

@@ -9,4 +9,16 @@
  */
 public class MapFunc {
 
+    public static <T,R,E extends T> ArrayList<R> map(ArrayList<E> list, Function<T,R> function) {
+
+        ArrayList<R> newList = new ArrayList<>();
+
+        for (int i = 0; i < list.size(); i++) {
+            R after = function.apply(list.get(i));
+            newList.add(after);
+        }
+
+        return newList;
+    }
+
 }

src/main/java/Pair/Arrays.java

@@ -11,6 +11,25 @@
  * 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 static <E extends Comparable> Pair<E> firstLast(ArrayList<E> list) {
+        return new Pair<E>(list.get(0), list.get(list.size()-1));
+    }
+
+    public static <E extends Comparable> E min(ArrayList<E> list) {
+        Collections.sort(list);
+        return list.get(0);
+    }
+
+    public static <E extends Comparable> E max (ArrayList<E> list) {
+        Collections.sort(list);
+        return list.get(list.size() - 1);
     }
+
+    public static <E extends Comparable> Pair<E> minMax(ArrayList<E> list) {
+        return new Pair<E>(min(list), max(list));
+
+    }
+
 }

src/main/java/Pair/Pair.java

@@ -1,12 +1,48 @@
 package Pair;
 
+import java.util.ArrayList;
+import java.util.Collections;
+
 /**
  * You need to store two values of type `E`, set them in a constructor, and have the following methods,
  * getFirst
  * getSecond
  * min -> returns the minimum of the pair
  * max -> returns the maximum of the pair
  */
-public class Pair {
+public class Pair<E extends Comparable> {
+
+    private E first;
+    private E second;
+
+    public Pair(E thing1, E thing2) {
+        this.first = thing1;
+        this.second = thing2;
+    }
+
+    public E getFirst() {
+        return this.first;
+    }
+
+    public E getSecond() {
+        return this.second;
+    }
+
+    public E min() {
+        if (first.compareTo(second) < 0) {
+            return first;
+        } else {
+            return second;
+        }
+    }
+
+    public E max() {
+        if (first.compareTo(second) > 0) {
+            return first;
+        } else{
+            return second;
+        }
+    }
+
 
 }

src/main/java/StackArray/GenericStack.java

@@ -5,11 +5,46 @@
 /**
  * Expand the ArrayList implementation of stack here to use an E[] array.  Still implement push, pop, and isEmpty.
  * Remember, you might need to resize the stack in the push method.
+ *
  * @param <E>
  */
 public class GenericStack<E> {
+
     private E[] elements;
 
     public GenericStack() {
+        elements = (E[]) new Object[0];
+    }
+
+    public E push(E aThing) {
+
+        E[] temp = Arrays.copyOf(elements, elements.length + 1);
+
+        temp[elements.length] = aThing;
+        elements = temp;
+        return aThing;
+    }
+
+    public E pop() throws IndexOutOfBoundsException {
+
+        E poppedObj = elements[elements.length - 1];
+
+        if (elements.length > 0) {
+            E[] temp = Arrays.copyOf(elements, elements.length - 1);
+            for (int i = 0; i < elements.length - 1; i++) {
+                temp[i] = elements[i];
+            }
+            elements = temp;
+        }
+        return poppedObj;
     }
+
+    public boolean isEmpty() {
+        if (elements.length > 0) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
 }

src/main/java/StackArray/ObjectStack.java

@@ -5,12 +5,44 @@
 /**
  * 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() {
+        elements = new Object[0];
+    }
+
+    public Object push(Object aThing) {
+
+        Object[] temp = Arrays.copyOf(elements, elements.length + 1);
+
+        temp[elements.length] = aThing;
+        elements = temp;
+        return aThing;
+    }
+
+    public Object pop() throws IndexOutOfBoundsException {
+
+        Object poppedObj = elements[elements.length - 1];
+
+        if (elements.length > 0) {
+            Object[] temp = Arrays.copyOf(elements, elements.length - 1);
+            for (int i = 0; i < elements.length - 1; i++) {
+                temp[i] = elements[i];
+            }
+            elements = temp;
+        }
+        return poppedObj;
+    }
 
+    public boolean isEmpty() {
+        if (elements.length > 0) {
+            return false;
+        } else {
+            return true;
+        }
     }
 }

src/main/java/StackArrayList/Stack.java

@@ -1,6 +1,7 @@
 package StackArrayList;
 
 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.
@@ -11,6 +12,28 @@ public class Stack<E> {
 
 
     public Stack(){
+        elements = new ArrayList();
+    }
+
+    public E push(E aThing) {
+
+        elements.add(aThing);
+        return (E)elements.get(elements.size() - 1);
+    }
+
+    public E pop() throws IndexOutOfBoundsException {
 
+        return (E)elements.remove(elements.size() - 1);
+
+    }
+
+    public boolean isEmpty() {
+        if (elements.size() > 0) {
+            return false;
+        } else {
+            return true;
+        }
     }
+
+
 }

src/main/java/Table/Entry.java

@@ -17,4 +17,8 @@ public V getValue() {
         return value;
     }
 
+    public void setValue(V anotherValue) {
+        this.value = anotherValue;
+    }
+
 }

src/main/java/Table/Table.java

@@ -10,8 +10,50 @@
  * Void return on `remove`.
  */
 public class Table<K, V> {
-    private ArrayList entries;
+    private ArrayList<Entry> entries;
 
     public Table() {
+        this.entries = new ArrayList();
     }
+
+    public V get(K key) {
+
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)) {
+                return (V) entries.get(i).getValue();
+            }
+        }
+        return null;
+    }
+
+    public void put(K key, V value) {
+        if (containsKey(key)) {
+            for (int i = 0; i < entries.size(); i++) {
+                if (entries.get(i).getKey().equals(key)) {
+                    entries.get(i).setValue(value);
+                }
+            }
+        } else {
+            entries.add(new Entry(key, value));
+        }
+    }
+
+    public void remove(K key) {
+
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)){
+                entries.remove(i);
+            }
+        }
+    }
+
+    public boolean containsKey(K key) {
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
 }

src/main/java/TableNested/TableNested.java

@@ -1,5 +1,7 @@
 package TableNested;
 
+import Table.Entry;
+
 import java.util.ArrayList;
 
 /**
@@ -8,4 +10,72 @@
  */
 public class TableNested<K, V> {
 
+    private class EntryNested {
+        private K key;
+        private V value;
+
+        private EntryNested(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        private K getKey() {
+            return key;
+        }
+
+        private V getValue() {
+            return value;
+        }
+
+        private void setValue(V anotherValue) {
+            this.value = anotherValue;
+        }
+    }
+
+    private ArrayList<EntryNested> entries;
+
+    public TableNested() {
+        this.entries = new ArrayList();
+    }
+
+    public V get(K key) {
+
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)) {
+                return entries.get(i).getValue();
+            }
+        }
+        return null;
+    }
+
+    public void put(K key, V value) {
+        if (containsKey(key)) {
+            for (int i = 0; i < entries.size(); i++) {
+                if (entries.get(i).getKey().equals(key)) {
+                    entries.get(i).setValue(value);
+                }
+            }
+        } else {
+            entries.add(new EntryNested(key, value));
+        }
+    }
+
+    public void remove(K key) {
+
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)){
+                entries.remove(i);
+            }
+        }
+    }
+
+    private boolean containsKey(K key) {
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
 }