Problem mit Implementierung von einer HashMap aufgabe

[Tigga]

Hallo allerseits,
also ich habe folgendes Problem habe ein Programm geschrieben das eine Hash-Map darstellen soll aber irgendwie funtzt es nicht wirklich,
den immer wenn ich einen Schlüssel > der länge des Arrays mithilfe meienr put Methode ins Array eingebe (das mittels meiner hashfunktion wieder in ein indexwert des Arrays angepasst wird) scheint er mir wenn ich mir den zu dem Schlüssel zugehörigen Wert ausgeben will (mittels get Methode) nicht gespeichert zu haben, weil er mir dann immer null ausgibt.

Bei Schlüsselwerten die < max array sind macht er es wunderbar


Ich denke der fehler ist relativ simpel aber ich komme nicht drauf.. nachdem ich mir den halben tag den kopf zerbrochen habe

Hoffe jmd kann mir dabei helfen
achja und Fehleranzeigen gibt der Compiler mir auch keine

noch zum Verständnis: ich habe noch eine Klassse Entry(mit Schlüssel und Wert) und dann noch eine test Klasse mit main(args...) aber diese sollten selbsterklärend sein deswegen post ich die hier jetzt mal nicht :roll:

Hier mal mein Porgramm:

public class HashMap {
	
	public HashMap()
	{
	this.tabellensize=9;
	map=new Entry[tabellensize];
        }

private int tabellensize;
	public Entry[] map;
	private int size;
	
	
	//hashfunktion
	private int hash(int key)
	{
		return(key%this.tabellensize);
	}
	
	private int hash2(int key)
	{
		return((this.tabellensize-1)-(key%(this.tabellensize-1)));
	}
	
	//Mapmethoden
	
	public int size()
	{
		return size;
	}
	
	public  boolean isEmpty()
	{
		if (size==0)
		{	
			return true;
		}
		return false;
	}
	
	public int berrechneHash(int key)
	{
		
		int i=hash(key);
		if (map[i]==null)
		{
			System.out.println("hash key ist: "+hash(key));
			return hash(key);
		}
		else
		{
			{
				for(int j=0;j<map.length;j++)
				{	
					int Sondierungsfunktion=((hash(key) + (j* hash2(key)))%this.tabellensize);
			
					if(map[Sondierungsfunktion]==null)
					{   
						System.out.println("hash key ist: "+Sondierungsfunktion);
						return Sondierungsfunktion;
					}
				}
			}		
		}	
			
		
		return -1;
	}

	public Object get(int k)
	{
		Object result=null;
		for(int i=0;i<map.length;i++)
		{
		if (map[i]!=null && map[i].getKey()==k)
		{	
				result=map[k].getWert();
}
		}
		return result;
	}
	
	public Object put(int key,Object Wert)
	{	
		
		int i = berrechneHash(key);
		if(map[i]==null)
		{
			Entry NeuerTabelleneintrag=new Entry(key,Wert);
			size++;
			
			map[i]=NeuerTabelleneintrag;
			map[i].setWert(Wert);
			map[i].setKey(key);
	                return null;	
		}
		
		
		return Wert;
	}


	public Object remove(int k)
	{
		Object result=null;
		
		for(int i=0;i<=map.length;i++)
		{
			if(map[i]!=null && map[i].getKey()==k)
			{	
				size--;
				
				result=map[i].Wert;
				map[i]=null;
				return result;	
			}
		}
		return result;
	}
	
	
}

 

[Marco13]

Was compilierbares ist immer gut, um es schnell testen zu können. Aber das mache ich jetzt frühestens morgen :wink:

 

[didjitalist]

eigentlich ganz simpel: wenn kollisionen auftreten, ersetzt du den vorhandenen wert nicht. wenn du zum testen aufsteigende keys einfügst, dann tritt die erste kollision aufgrund deiner hash methode genau dann auf, wenn der erste wert eingefügt werden soll, der größer als die table ist.

dadurch können natürlich werte, die zu kollisionen geführt haben, nicht mehr gefunden werden.

daher verwalten viele hashmap implementierungen die einträge selbst aus verkettete liste. je mehr kollisionen, desto langsamer der zugriff.

deine hashmap erfüllt übrigens in keiner weise die anforderung, die man an die komplexität von lesendem zugriff stellt. der ist bei dir nämlich immer linear und nicht konstant.