Made the hashmap extend Number to be a bit more generic

git-svn-id: https://java-algorithms-implementation.googlecode.com/svn/trunk@109 032fbc0f-8cab-eb90-e552-f08422b9a96a

Author: phishman3579

src/com/jwetherell/algorithms/DataStructures.java

@@ -138,7 +138,7 @@ public static void main(String[] args) {
         {
             // HashMap
             System.out.println("Hash Map.");
-            HashMap hash = new HashMap(unsorted);
+            HashMap<Integer> hash = new HashMap<Integer>(unsorted);
             System.out.println(hash.toString());
 
             int next = random.nextInt(unsorted.length*100);

src/com/jwetherell/algorithms/data_structures/HashMap.java

@@ -9,17 +9,17 @@
  * 
  * @author Justin Wetherell <phishman3579@gmail.com>
  */
-public class HashMap {
+public class HashMap<T extends Number> {
 
     private int hashingKey = 10;
-    private List<Integer>[] map = null;
+    private List<T>[] map = null;
     private int size = 0;
 
     public HashMap() {
         initializeMap();
     }
 
-    public HashMap(Integer[] values) {
+    public HashMap(T[] values) {
         hashingKey = values.length;
         if (hashingKey>100) hashingKey = 100;
         initializeMap();
@@ -30,48 +30,48 @@ public HashMap(Integer[] values) {
     private void initializeMap() {
         map = new ArrayList[hashingKey];
         for (int i=0; i<map.length; i++) {
-            map[i] = new ArrayList<Integer>();
+            map[i] = new ArrayList<T>();
         }
     }
 
-    private void populate(Integer[] values) {
-        for (int v : values) {
+    private void populate(T[] values) {
+        for (T v : values) {
             put(v,v);
         }
     }
 
-    private int hashingFunction(int key) {
-        return key % hashingKey;
+    private int hashingFunction(T key) {
+        return key.intValue() % hashingKey;
     }
 
-    public boolean put(int key, int value) {
+    public boolean put(T key, T value) {
         int hashedKey = hashingFunction(key);
-        List<Integer> list = map[hashedKey];
+        List<T> list = map[hashedKey];
         // Do not add duplicates
         for (int i=0; i<list.size(); i++) {
-            int v = list.get(i);
+            T v = list.get(i);
             if (v == value) return false;
         }
         list.add(value);
         size++;
         return true;
     }
 
-    public boolean remove(int key) {
+    public boolean remove(T key) {
         int hashedKey = hashingFunction(key);
-        List<Integer> list = map[hashedKey];
-        if (list.remove((Object)key)) {
+        List<T> list = map[hashedKey];
+        if (list.remove(key)) {
             size--;
             return true;
         }
         return false;
     }
 
-    public boolean contains(int value) {
+    public boolean contains(T value) {
         for (int key=0; key<map.length; key++) {
-            List<Integer> list = map[key];
+            List<T> list = map[key];
             for (int item=0; item<list.size(); item++) {
-                int v = list.get(item);
+                T v = list.get(item);
                 if (v == value) return true;
             }
         }
@@ -89,10 +89,10 @@ public int getSize() {
     public String toString() {
         StringBuilder builder = new StringBuilder();
         for (int key=0; key<map.length; key++) {
-            List<Integer> list = map[key];
+            List<T> list = map[key];
             for (int item=0; item<list.size(); item++) {
-                int value = list.get(item);
-                if (value!=Integer.MIN_VALUE) builder.append(key).append("=").append(value).append(", ");
+                T value = list.get(item);
+                if (value!=null) builder.append(key).append("=").append(value).append(", ");
             }
         }
         return builder.toString();