HashMap

.classpath

@@ -1,6 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="src" path="Programmierung2/src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

Programmierung2/src/Hashmap/Hashmap.java

@@ -0,0 +1,21 @@
+package Hashmap;
+
+import java.util.LinkedHashMap;
+
+public class Hashmap {
+
+	/* Was ist das? ist ein Array(Array ist HashMap) auf Entry(Entry ist LinkedList) 
+	 * 
+	 *  - Eine HashMap in Java ist eine spezielle Datenstruktur, die eine schnelle Speicherung und 
+	 *  	den schnellen Zugriff auf Daten ermöglicht, indem sie Schlüssel-Wert-Paare speichert. 
+	 *  
+	 *  - akzeptiert zwei generische Parameter: HashMap<K, V>, wobei K der Schlüsseltyp und V der Werttyp ist.
+	 *  - 
+	 *  - mit Hashmap kann ich: 
+	 *  	. suchen:   O(1)
+	 *  	. einfügen: O(1)
+	 *  	. lösche:   O(1)
+	 *  
+	 *  
+	 */
+}

Programmierung2/src/Hashmap/MyGenericHashMap.java

@@ -0,0 +1,40 @@
+package Hashmap;
+
+public class MyGenericHashMap <K,V>{
+	
+	 K key;
+	 V value;
+	 
+	 final int SIZE = 10;
+	 Object[] table;
+	 
+	 public MyGenericHashMap() {
+		 table = new Object[SIZE];
+	 }
+	 
+	 private int Hashadresse(int key) {
+		 return key % SIZE;
+	 }
+	 
+	 public void put(K key, V value) {
+		 int index = 0;
+		 
+		 // wenn key int,double,float ist, wird auf integer Wert umgewandelt
+		 if (key instanceof Number)
+			 index = Hashadresse(((Number) key).intValue());
+		 
+		 else if(key instanceof Character) 
+			 index =(Character) key - 'a';
+		 
+		 table[index] = value;
+		 
+		 System.out.println("[" + index + "]: " + table[index]);
+		 
+	 }
+
+	public static void main(String[] args) {
+		MyGenericHashMap <Integer,String> t1 = new MyGenericHashMap<>();
+		t1.put(112, "hallo");
+	}
+
+}

Programmierung2/src/Hashmap/MyHashMap.java

@@ -0,0 +1,62 @@
+package Hashmap;
+
+import java.util.ArrayList;
+
+public class MyHashMap {
+	
+	int key;
+	String value;
+	
+	// Ein Array von MyHashMap-Objekten erstellen
+    String table[];
+    final int SIZE  =10;
+
+    // Konstruktor, der das Array initialisiert
+    public MyHashMap() {
+        table = new String[SIZE];  //Array mit 10 MyHashMap-Objekten erstellen
+        this.key = 0;
+        this.value = null;
+    }
+    
+    
+    private int Hashadresse(int key) {
+    	return key % table.length;
+    }
+
+	public void put(int key, String value) {
+	int index = Hashadresse(key);
+	table[index] = value;
+		
+    }
+	
+	public void getValue(int key) {
+		int index = Hashadresse(key);
+		System.out.println(table[index]);
+	}
+	
+	public void printHashMap() {
+		for (int i = 0; i < table.length; i++) {
+			System.out.println("[" + i + "]" + " : " + table[i]);
+		}
+	}
+
+	public boolean isEmpty(int key) {
+		int index = Hashadresse(key);
+		
+		if (table[index] == null)
+			return true;
+		
+		return false;
+	}
+	
+	public static void main(String[] args) {
+		MyHashMap m1 = new MyHashMap();
+		m1.put(14, "Schrank");
+		m1.put(12, "Sofa");
+		m1.put(8, "TV");
+		m1.printHashMap();
+		m1.getValue(14);
+		
+		System.out.println(m1.isEmpty(9));
+	}
+}

Programmierung2/src/Teste/kopieArray.java

@@ -3,20 +3,23 @@ package Teste;
 public class kopieArray {
 
 	public static void main(String[] args) {
-		/*
-		 * das ein falsches Verfahren, um ein Array in einem anderen Array
-		 * zu koopieren, in dem Fall kopieArray ist ein RefrenzVariable, die auf das selbe Array zeigt
-		 * also wir haben nur ein Array und auf diese Array zeigen zwei RefrenzVariable 
-		 */
-		int[] orgArray = {1,2,3,4,5};
-		int[] kopieArray = orgArray;
+//		/*
+//		 * das ein falsches Verfahren, um ein Array in einem anderen Array
+//		 * zu koopieren, in dem Fall kopieArray ist ein RefrenzVariable, die auf das selbe Array zeigt
+//		 * also wir haben nur ein Array und auf diese Array zeigen zwei RefrenzVariable 
+//		 */
+//		int[] orgArray = {1,2,3,4,5};
+//		int[] kopieArray = orgArray;
+//		
+//		/*
+//		 * 	Richtige Kopie von Array
+//		 */
+//		int[] richtigeKopieArray = new int[orgArray.length];
+//		for (int i = 0; i <orgArray.length; i++)
+//			richtigeKopieArray[i] = orgArray[i];
+//
+	System.out.println(2 % 7);
 			
-		/*
-		 * 	Richtige Kopie von Array
-		 */
-		int[] richtigeKopieArray = new int[orgArray.length];
-		for (int i = 0; i <orgArray.length; i++)
-			richtigeKopieArray[i] = orgArray[i];
 
 	}
 }

Programmierung2/src/oop/Generics/Generics.java

@@ -3,13 +3,18 @@ package oop.Generics;
 public class Generics {
 	
 	/*
-	 * Generics ist ein Konzept in der Programmierung, das es ermöglicht, Klassen, Methoden und Schnittstellen so zu schreiben
+	 * - Generics ist ein Konzept in der Programmierung, das es ermöglicht, Klassen, Methoden und Schnittstellen so zu schreiben
 	 * 	,dass sie mit beliebigen Datentypen arbeiten können. 
 	 * 	 Anstatt festzulegen, dass eine Klasse oder Methode nur mit einem bestimmten Datentyp (z.B. int, String) arbeiten kann
-	 * , können Generics verwendet werden, um den Datentyp flexibel zu gestalten.
-	 * 
-	 * Generic wird durch: Namen ein Typparameter in spitzen Klammern (<>) angegeben wird
+	 * 	 ,können Generics verwendet werden, um den Datentyp flexibel zu gestalten.
 	 * 
+	 * - Generic wird durch: Namen ein Typparameter in spitzen Klammern (<>) angegeben wird
+	 * - Generic akzptiert keine Primitiven Daten Typen
+	 * - Generic Variable (Platzhalter): 
+	 * 		. T (Steht für Typ)
+	 * 		. E (Element)
+	 * 		. K (Key)
+	 * 		. V (Value) 
 	 * Generic funktionert mit:
 	 * 1. Klassen: (public class Box<T>)
 	 * 2. Methoden: (public static <T> void printArray(T[] array))

Programmierung2/src/oop/Generics/Pocket.java

@@ -0,0 +1,39 @@
+package oop.Generics;
+
+public class Pocket<T> {
+	
+	private T value;
+	public Pocket() {}
+	
+	public Pocket(T value) {
+		this.value = value;
+	}
+	
+	
+	public T getValue() {
+		return value;
+	}
+
+	public void setValue(T value) {
+		this.value = value;
+	}
+	
+
+	@Override
+	public String toString() {
+		return "Pocket [value=" + value + "]";
+	}
+
+	
+	public static void main(String[] args) {
+		Pocket<Pocket<String>> pocketOfPockets = new Pocket<>();
+		pocketOfPockets.setValue(new Pocket<String>());
+		pocketOfPockets.getValue().setValue("Innere Pocket");
+		System.out.println(pocketOfPockets.getValue().getValue());
+	//-----------------------------------------------------------------
+		Pocket<String>[] pocket = new Pocket[10]; // mit 10 Plätzen
+
+		
+	}
+
+}