HashMap

Programmierung2/src/Hashmap/Hashmap.java

@@ -1,5 +1,6 @@
 package Hashmap;
 
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 
 public class Hashmap {
@@ -18,4 +19,49 @@ public class Hashmap {
 	 *  
 	 *  
 	 */
+	
+	public static void main(String[] args) {
+        // Erstellen einer Instanz der Klasse HashMap
+        HashMap<String, Integer> map = new HashMap<>();
+
+        // Hinzufügen von Einträgen in die HashMap
+        map.put("Apfel", 3);
+        map.put("Apfe", 3);
+        map.put("Banane", 5);
+        map.put("Orange", 2);
+
+        // Zugriff auf ein Element der HashMap mittels Schlüssel
+        int apfelMenge = map.get("Apfel");
+        System.out.println("Anzahl der Äpfel: " + apfelMenge);
+
+        // Überprüfen, ob ein Schlüssel in der HashMap vorhanden ist
+        boolean hatOrange = map.containsKey("Orange");
+        System.out.println("Hat Orange: " + hatOrange);
+        
+        // Überprüfen, ob ein bestimmter Wert in der HashMap vorhanden ist
+        boolean hatWert5 = map.containsValue(5);
+        System.out.println("Enthält die HashMap den Wert 5? " + hatWert5);
+        
+        // Entfernen eines Eintrags aus der HashMap
+        map.remove("Banane");
+        System.out.println("Banane entfernt. Aktueller Inhalt der HashMap: " + map);
+
+        // Iterieren über die Einträge in der HashMap
+        System.out.println("Inhalt der HashMap:");
+        for (HashMap.Entry<String, Integer> entry : map.entrySet()) {
+            System.out.println("Frucht: " + entry.getKey() + ", Menge: " + entry.getValue());
+        }
+
+        // Überprüfen, ob die HashMap leer ist
+        boolean istLeer = map.isEmpty();
+        System.out.println("Ist die HashMap leer? " + istLeer);
+
+        // Erhalten der Größe der HashMap
+        int größe = map.size();
+        System.out.println("Größe der HashMap: " + größe);
+
+        // Leeren der HashMap
+        map.clear();
+        System.out.println("HashMap nach dem Leeren: " + map);
+    }
 }

Programmierung2/src/Hashmap/JunitTest.java

@@ -1,5 +1,7 @@
 package Hashmap;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import static org.junit.jupiter.api.Assertions.*;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -8,18 +10,38 @@ import org.junit.jupiter.api.Test;
 import Hashmap.MyGenericHashMap.Entry;
 
 class JunitTest {
+	private MyGenericHashMap<Integer,String> h1;
 	@BeforeEach
 	void list() {
-		
+		h1 = new MyGenericHashMap<>();
+		h1.put(3009594, "obai");
+		h1.put(3129594, "omar");
+		h1.put(3129592, "abd");
+		h1.put(3129392, "basel");
 	}
 	
 	@Test
-	void test() {
+	void testPut() {
-		MyGenericHashMap<Integer,String> h1 = new MyGenericHashMap<>();
         h1.put(3009594, "omar");
         String value = h1.getValue(3009594);
         assertEquals("omar",value);
         
 	}
+	
+	@Test
+	void testcontainsKey() {
+		assertTrue(h1.containsKey(3129592));
+		assertFalse(h1.containsKey(3213213));
+	}
+	
+	@Test
+	void testSize() {
+		assertEquals(4,h1.size());
+	}
+	
+	@Test
+	void testisEmpty() {
+		assertTrue(h1.isEmpty());
+	}
 
 }

Programmierung2/src/Hashmap/MyGenericHashMap.java

@@ -46,7 +46,8 @@ public class MyGenericHashMap<K, V> {
 		}
         
     }
-
+    //Fügt ein Schlüssel-Wert-Paar in die HashMap ein. 
+    //Wenn der Schlüssel bereits existiert, wird der alte Wert durch den neuen ersetzt.
     public Entry<K, V> put(K key, V value) {
         int hash = key.hashCode() % SIZE;
         Entry<K,V> e = table[hash];
@@ -70,6 +71,8 @@ public class MyGenericHashMap<K, V> {
         }
     }
     
+    //Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. 
+    //Wenn der Schlüssel nicht existiert, wird null zurückgegeben.
     public V getValue(K key) {
     	int hash = key.hashCode() % SIZE;
     	//fange beim Head Index an
@@ -84,20 +87,8 @@ public class MyGenericHashMap<K, V> {
     	return null;
     }
     
-    public void printAll() {
+    //Entfernt das Schlüssel-Wert-Paar für den angegebenen Schlüssel aus der HashMap.
-    	for (Entry<?,?> temp : table) {
+    //Gibt den Wert zurück, der entfernt wurde, oder null, wenn der Schlüssel nicht existiert.
-    		if (temp != null) {
-    			System.out.println("[" + temp.key + "] :" + temp.value + " ");
-    			while(temp.next != null) {
-    				temp = temp.next;
-    				System.out.println("[" + temp.key + "] :" + temp.value + " ");
-    			}
-    		}
-    			
-    	}
-    		
-    }
-    
     public V removeValue(K key) {
     	
     	int hash = key.hashCode() % SIZE;
@@ -124,19 +115,71 @@ public class MyGenericHashMap<K, V> {
     	return null;
     	
     }
-
+   
+    //Ausgabe der Elemente
+    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 + " ");
+    			}
+    		}
+    			
+    	}
+    		
+    }
     
+   //Überprüft, ob der angegebene Schlüssel in der HashMap vorhanden ist. 
+   //Gibt true zurück, wenn der Schlüssel existiert, andernfalls false.
+    public boolean containsKey(K key) {
+    	int  hash = key.hashCode() % SIZE;
+    	Entry<K,V> temp = table[hash];
+    	while (temp != null) {
+    		if (temp.getKey().equals(key))
+    			return true;
+    		
+    		temp = temp.next;
+    	}
+    	
+    	return false;
+    }
     
+    //Gibt die Anzahl der Schlüssel-Wert-Paare in der HashMap zurück.
+    public int size() {
+    	int index = 0;
+    	for (int i = 0; i < SIZE; i++) {
+    		Entry<K,V> temp = table[i];
+    		if (temp != null) {
+    			index++;
+    			while(temp.next != null) {
+    				index++;
+    				temp = temp.next;
+    			}
+    		}
+    	}
+    	return index;
+    }
     
-    // Main-Methode zum Testen der MyGenericHashMap-Klasse.
+    //Überprüft, ob die HashMap leer ist (keine Einträge enthält). Gibt true zurück, 
+    //wenn sie leer ist, andernfalls false.
+    public boolean isEmpty() {
+    	for (int i = 0 ; i < SIZE; i++) {
+    		Entry<K,V> temp = table[i];
+    		if (temp != null)
+    			return true;
+    	}
+    	
+    	return false;
+    }
     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(3129592, "abd");
        t1.put(3129392, "basel");
+      
        t1.printAll();
    
     }