HashMap

Programmierung2/src/Hashmap/JunitTest.java

@@ -0,0 +1,25 @@
+package Hashmap;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import Hashmap.MyGenericHashMap.Entry;
+
+class JunitTest {
+	@BeforeEach
+	void list() {
+		
+	}
+	
+	@Test
+	void test() {
+		MyGenericHashMap<Integer,String> h1 = new MyGenericHashMap<>();
+        h1.put(3009594, "omar");
+        String value = h1.getValue(3009594);
+        assertEquals("omar",value);
+        
+	}
+
+}

Programmierung2/src/Hashmap/MyGenericHashMap.java

@@ -1,40 +1,122 @@
 package Hashmap;
 
-public class MyGenericHashMap <K,V>{
+import java.util.ArrayList;
 
-	 K key;
+import java.util.ArrayList;
-	 V value;
+import java.util.LinkedList;
 
-	 final int SIZE = 10;
+public class MyGenericHashMap<K, V> {
-	 Object[] table;
+    // Konstantenwert für die Größe der HashMap (Anzahl der Buckets).
+    final int SIZE = 10;
 
-	 public MyGenericHashMap() {
+    // Array, das die Einträge (key-value Paare) der HashMap speichert.
-		 table = new Object[SIZE];
+    Entry<K,V>[] table;
-	 }
 
-	 private int Hashadresse(int key) {
+    // Konstruktor für die MyGenericHashMap-Klasse.
-		 return key % SIZE;
+    public MyGenericHashMap() {
-	 }
+        // Initialisiert das Array mit der angegebenen Größe.
+        table = new Entry[SIZE];
+    }
 
-	 public void put(K key, V value) {
+    // Innere Klasse, die ein einzelnes key-value Paar darstellt.
-		 int index = 0;
+    class Entry<K, V> {
+        K key; // Der Schlüssel des Eintrags.
+        V value; // Der Wert, der dem Schlüssel zugeordnet ist.
+        Entry<K,V> next;
         
-		 // wenn key int,double,float ist, wird auf integer Wert umgewandelt
+        // Konstruktor für ein Entry-Objekt.
-		 if (key instanceof Number)
+        public Entry(K key, V value) {
-			 index = Hashadresse(((Number) key).intValue());
+            this.key = key; // Initialisiert den Schlüssel.
+            this.value = value; // Initialisiert den Wert.
+        }
+        public Entry() {
+        	this.key = null;
+        }
 
-		 else if(key instanceof Character) 
+		public K getKey() {
-			 index =(Character) key - 'a';
+			return key;
+		}
 
-		 table[index] = value;
+		public void setKey(K key) {
+			this.key = key;
+		}
 
-		 System.out.println("[" + index + "]: " + table[index]);
+		public V getValue() {
+			return value;
+		}
 
-	 }
+		public void setValue(V value) {
+			this.value = value;
+		}
+        
+    }
+
+    public Entry<K, V> put(K key, V value) {
+        int hash = key.hashCode() % SIZE;
+        Entry<K,V> e = table[hash];
+        
+        if (e == null) {
+            table[hash] = new Entry<K,V>(key, value);
+            return table[hash]; // Gibt den neuen Eintrag zurück
+        } else {
+            while (e != null) {
+                if (e.getKey().equals(key)) {
+                    e.setValue(value);
+                    return e; // Gibt den aktualisierten Eintrag zurück
+                }
+                if (e.next == null) {
+                    break;
+                }
+                e = e.next;
+            }
+            e.next = new Entry<K,V>(key, value);
+            return e.next; // Gibt den neuen Eintrag zurück
+        }
+    }
+    
+    public V getValue(K key) {
+    	int hash = key.hashCode() % SIZE;
+    	//fange beim Head Index an
+    	Entry<K,V> temp = table[hash];
+    	while (temp != null) {
+    		if (temp.getKey().equals(key)) {
+    			return temp.getValue();
+    		}
+    		temp = temp.next;
+    	}
+    	
+    	return null;
+    }
+    
+    public void printAll() {
+    	for (Entry<?,?> temp : table) {
+    		if (temp != null) {
+    			System.out.println("[" + temp.key + "] :" + temp.value + " ");
+    			while(temp.next != null) {
+    				temp = temp.next;
+    				System.out.println("[" + temp.key + "] :" + temp.value + " ");
+    			}
+    		}
+    			
+    	}
+    		
+    }
+
+    
+    
+    
+    // Main-Methode zum Testen der MyGenericHashMap-Klasse.
+    public static void main(String[] args) {
+        // Erstellen einer neuen Instanz von MyGenericHashMap für Integer-Schlüssel und String-Werte.
+        MyGenericHashMap<Integer, String> t1 = new MyGenericHashMap<>();
+        // Fügt das key-value Paar (3009594, "obai") zur HashMap hinzu.
+       t1.put(3009594, "obai");
+       t1.put(3129594, "omar");
+       t1.put(3129593, "abd");
+       t1.put(3129393, "abd");
+       t1.printAll();
+   
+    }
     
-	public static void main(String[] args) {
-		MyGenericHashMap <Integer,String> t1 = new MyGenericHashMap<>();
-		t1.put(112, "hallo");
-	}
     
 }

Programmierung2/src/Hashmap/MyHashMap.java

@@ -58,5 +58,9 @@ public class MyHashMap {
 		m1.getValue(14);
 		
 		System.out.println(m1.isEmpty(9));
+		
+		Character key = 'a';
+		int hash = key.hashCode();
+		System.out.println(hash);
 	}
 }