diff --git a/.classpath b/.classpath
index 4943bea..403a6f4 100644
--- a/.classpath
+++ b/.classpath
@@ -1,6 +1,15 @@
-
+
+
+
+
+
+
+
+
+
+
diff --git a/Programmierung2/src/Hashmap/Hashmap.java b/Programmierung2/src/Hashmap/Hashmap.java
new file mode 100644
index 0000000..764759d
--- /dev/null
+++ b/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, 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)
+ *
+ *
+ */
+}
diff --git a/Programmierung2/src/Hashmap/MyGenericHashMap.java b/Programmierung2/src/Hashmap/MyGenericHashMap.java
new file mode 100644
index 0000000..db6567b
--- /dev/null
+++ b/Programmierung2/src/Hashmap/MyGenericHashMap.java
@@ -0,0 +1,40 @@
+package Hashmap;
+
+public class MyGenericHashMap {
+
+ 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 t1 = new MyGenericHashMap<>();
+ t1.put(112, "hallo");
+ }
+
+}
diff --git a/Programmierung2/src/Hashmap/MyHashMap.java b/Programmierung2/src/Hashmap/MyHashMap.java
new file mode 100644
index 0000000..777f0c9
--- /dev/null
+++ b/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));
+ }
+}
diff --git a/Programmierung2/src/Teste/kopieArray.java b/Programmierung2/src/Teste/kopieArray.java
index 770724d..e0572a9 100644
--- a/Programmierung2/src/Teste/kopieArray.java
+++ b/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;
-
- /*
- * Richtige Kopie von Array
- */
- int[] richtigeKopieArray = new int[orgArray.length];
- for (int i = 0; i ) angegeben wird
+ * - 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
+ * - 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)
* 2. Methoden: (public static void printArray(T[] array))
diff --git a/Programmierung2/src/oop/Generics/Pocket.java b/Programmierung2/src/oop/Generics/Pocket.java
new file mode 100644
index 0000000..4b4f1ab
--- /dev/null
+++ b/Programmierung2/src/oop/Generics/Pocket.java
@@ -0,0 +1,39 @@
+package oop.Generics;
+
+public class Pocket {
+
+ 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> pocketOfPockets = new Pocket<>();
+ pocketOfPockets.setValue(new Pocket());
+ pocketOfPockets.getValue().setValue("Innere Pocket");
+ System.out.println(pocketOfPockets.getValue().getValue());
+ //-----------------------------------------------------------------
+ Pocket[] pocket = new Pocket[10]; // mit 10 Plätzen
+
+
+ }
+
+}