From 61704f40c7a974d157ce828a6aadd439d1630663 Mon Sep 17 00:00:00 2001 From: obai Date: Sun, 25 Aug 2024 18:00:22 +0200 Subject: [PATCH] HashMap --- .classpath | 11 +++- Programmierung2/src/Hashmap/Hashmap.java | 21 +++++++ .../src/Hashmap/MyGenericHashMap.java | 40 ++++++++++++ Programmierung2/src/Hashmap/MyHashMap.java | 62 +++++++++++++++++++ Programmierung2/src/Teste/kopieArray.java | 31 +++++----- .../src/oop/Generics/Generics.java | 17 +++-- Programmierung2/src/oop/Generics/Pocket.java | 39 ++++++++++++ 7 files changed, 200 insertions(+), 21 deletions(-) create mode 100644 Programmierung2/src/Hashmap/Hashmap.java create mode 100644 Programmierung2/src/Hashmap/MyGenericHashMap.java create mode 100644 Programmierung2/src/Hashmap/MyHashMap.java create mode 100644 Programmierung2/src/oop/Generics/Pocket.java 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 + + + } + +}