# Problem beim schreiben einer eigene generische Klasse Hashtable



## MarioK (16. Mai 2011)

Hallo Gemeinschaft,

Gegeben ist folgendes:


```
package Pflichtaufgabe2;

public interface Map<K, V> {
	/* Typ-Parameter:
	 *  K - der Typ der Schluessel
	 *  V - der Typ der Werte
	 *  
	 *  Hinweis: zum Vergleich der Schluessel wird die equals-Methode verwendet
	 */
	
	/**
	 * fuegt ein Schluessel-Wert-Paar in die Map ein
	 * @param key der Schluessel
	 * @param value der Wert
	 * @return falls es schon einen Wert mit Schluessel key in der Map gab, 
	 *   wird der alte Wert entfernt und zurueckgegeben; sonst wird null zurueckgegeben
	 */
	V put(K key, V value);
	
	/**
	 * bestimmt den Wert zu einem Schluessel in der Map
	 * @param key der Schluessel
	 * @return den Wert zum Schluessel key, falls ein entsprechendes Schluessel-Wert-Paar vorhanden ist;
	 *   null sonst
	 */
	V get(K key);
	
	/**
	 * entfernt ein Schluessel-Wert-Paar aus der Map
	 * @param key der Schluessel
	 * @return der Wert zu dem Schluessel, falls ein entsprechendes Schluessel-Wert-Paar vorhanden ist;
	 *   null sonst
	 */
	V remove(K key);

}
```

bei raus gekommen ist folgendes:


```
package Pflichtaufgabe2;

public class Hashtable<K, V> implements Map<K, V>{
	
	private class KeyValue{
	      private K key;
	      private V value;
	      
	      /**
	       * Konstrukter zum erstellen eines SchlüsselWertePaares vom Typ KeyValue
	       * @param key, value ist ein Generische Typ, key ist Interger (int) 
	       */
	      public KeyValue(K key, V value){
	         this.key = key;
	         this.value = value;
	      }
	      
	      /**
	       * Gibt eine lesbare Stringrepresentation des Objektes zurück
	       * @return String die Werte der Variablen des Objektes
	       */
	      public String toString(){
	         return key + "," + value;
	      }
	}

	private LinkedList<KeyValue>[] arr;
	 
	
	/**
	* Konstruktor um die Größe des Arrays der Hashtabele zu setzten.
	* @param arraySize vom Typ int
	*/
	@SuppressWarnings("unchecked")
	 public Hashtable(int arraySize) {
		this.arr = new LinkedList[arraySize];
		for (int i=0; i < this.arr.length; i++) {
			this.arr[i] = new LinkedList<KeyValue>();
		}
	 }

	
	/**
	* Berechnet den Index an dem in der Hashtabelle eingefügt wird.
	* @param key vom Typ K (Generisch).
	* @return index der Wert an dem in der Hashtabelle eingefügt wird vom Typ int als Betrag.
	*/
	public int hashFunction(K key){   
		int index = Math.abs(key.hashCode() % arr.length);
	    return index;
	}
	
	
	/**
	* fuegt ein Schluessel-Wert-Paar in die Map ein
	* @param key der Schluessel
	* @param value der Wert
	* @return falls es schon einen Wert mit Schluessel key in der Map gab, 
	* 	wird der alte Wert entfernt und zurueckgegeben; sonst wird null zurueckgegeben
	*/
	@Override
	public V put(K key, V value) {
		LinkedList<KeyValue> kvList = arr[hashFunction(key)];
		V oldValue = null;
		for (KeyValue keyValue : kvList) {
			if (keyValue.key.equals(key)) {
				oldValue = keyValue.value;
				keyValue.value = value;
				return oldValue;
			}
		}
		kvList.add(new KeyValue(key, value));
		return null;
	}
	
	
	/**
	* bestimmt den Wert zu einem Schluessel in der Map
	* @param key der Schluessel
	* @return den Wert zum Schluessel key, falls ein entsprechendes Schluessel-Wert-Paar 
	* 	vorhanden ist; null sonst
	*/
	@Override
	public V get(K key) {
		LinkedList<KeyValue> kvList = arr[hashFunction(key)];
		for (KeyValue keyValue : kvList) {
			if (keyValue.key.equals(key)) 
				return keyValue.value;
		}
		return null;	 
	}
	
	
	/**
	 * entfernt ein Schluessel-Wert-Paar aus der Map
	 * @param key der Schluessel
	 * @return der Wert zu dem Schluessel, falls ein entsprechendes Schluessel-Wert-Paar 
	 * 	vorhanden ist; null sonst
	 */
	@Override
	public V remove(K key) {
		LinkedList<KeyValue> kvList = arr[hashFunction(key)];
		for (KeyValue keyValue : kvList) {
			if (keyValue.key.equals(key)) {
				kvList.remove(keyValue);
				return keyValue.value;
			}
		}
		return null;
	}
	
	public static void main(String[] args) {

		 Hashtable<Integer, String> ht = new Hashtable<Integer, String>(11);

		 // Fügt bla an Stelle 26 % länge des Array an.
		 System.out.println("5 mal Elemente unter Key = 26 speichern und HT ausgeben:");
		 ht.put(26, "str1");
		 ht.put(26, "str2");
		 ht.put(26, "str1");
		 ht.put(26, "str3");
		 ht.put(26, "str4");

		 // Gibt das gesamte Array aus
		 System.out.println(ht);

		 System.out.println("Zusätzlich 5 Elemente unter 1,27,28,29,30 einfügen und HT ausgeben:");
		 ht.put(27, "str1");
		 ht.put(28, "str2");
		 ht.put(29, "str1");
		 ht.put(30, "str3");
		 ht.put(1, "str3");

		 // Gibt das gesamte Array nochmal aus
		 System.out.println(ht);

		 // Gibt den Wert an Stelle 4 wieder
		 System.out.println("Element unter 4 = " + ht.get(4));

		 // Gibt den Wert an Stelle 4 wieder
		 System.out.println("Element unter 28 = " + ht.get(28));

		 System.out.println("Remove mit key 4 = " + ht.remove(4));

		 System.out.println("Remove mit key 28 = " + ht.remove(28));
		 System.out.println("Remove mit key 29 = " + ht.remove(29));

		 System.out.println(ht);

		 // und jetzt noch mal nen gaaaanz viel elemente einfügen und dabei alte überschreiben
		 for (int i = 0; i < 100; i++) {
			 ht.put(i, "Striiing" + i);
		 } 
		 System.out.println(ht);
		 System.out.println("Das wars");

	}

}
```

Für die LinkedList benutze ich die bereits selbst geschriebe LinkedList, siehe hier: http://www.java-forum.org/allgemein...en-eigene-generische-klasse-linkedlist-2.html .
Nun zum Problem:

```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Can only iterate over an array or an instance of java.lang.Iterable

	at Pflichtaufgabe2.Hashtable.put
```

Why?? Ich wollt mein Iterator aus der LinkedList benutzen, aber heraus kam der benannte Fehler (code zeile 65, 86 und 103 (kvlist)). Wisst ihr einen Rat bitte bzw was mache ich mir zu schwer?


----------



## zerix (16. Mai 2011)

Hallo,

deine List muss das Interface Iterable implementieren. 

Gruß

zerix


----------



## MarioK (16. Mai 2011)

Aber die class LinkedList<T> implements List<T> bekommt doch schon durch import java.util.Iterator den Iterator. Reicht das nicht aus ?? oder verstehe ich da jetzt was falsch??


----------



## zerix (16. Mai 2011)

Nein das reicht nicht aus. Damit ist nur sichergestellt, dass deine List ein Iterator ist, aber das Interable hat die Methode iterator() die einen Iterator zurückgeben muss. 

Gruß

zerix


----------



## MarioK (16. Mai 2011)

würde ein while ( ... != true) nicht auch das gleiche tun ??? ich tue mich gerade ein wenig schwer ´mit dem Iterator ...


----------



## zerix (16. Mai 2011)

Du kannst da jede Schleife nehmen, abgesehen von der foreach. Die verlangt nämlich, dass das was durchlaufen werden soll Iterable ist. 

Gruß

zerix


----------



## MarioK (17. Mai 2011)

also ich fand selbst heraus, dass eine Schleife doch quatsch ist ... contains ist doch viel einfacher ... muss doch die List nicht iterativ durchlaufen ....


----------



## MarioK (17. Mai 2011)

Also, das ganze ein wenig modifiziert, aber siehe am Ende dieses Eintrages.

```
public class Hashtable<K, V> implements Map<K, V> {
	
	//innerne Klasse KeyValue
	protected class KeyValue{
		private K key;
		private V value;
		
		/**
		 * Konstrukter zum erstellen eines SchlüsselWertePaares vom Typ KeyValue
		 * @param key, value ist ein Generische Typ, key ist Interger (int) 
		 */
		public KeyValue(K key, V value){
			this.key = key;
			this.value = value;
		}
		
		/**
		 * Standartkonstrukter
		 */
		public KeyValue(){
			
		}
		
		/**
		 * Gibt den Key zurück
		 * @return key key ist vom Typ K
		 */
		public K getKey(){
			return this.key;
		}
		
		/**
		 * Setzt den Key
		 * @param key vom Typ int
		 */
		public void setKey(K key){
			this.key = key;
		}
		
		/**
		 * Gibt den Value zurück
		 * @return value vom Typ V (Generisch)
		 */
		public V getValue(){
			return this.value;
		}
		
		/**
		 * Setzt den Value
		 * @param value vom Typ V (Generisch)
		 */
		public void setValue(V value){
			this.value = value;
		}
		

		/**
		 * Vergleicht den Key vom KeyValue-Objekt mit dem Key des übergebenen Objekt.
		 * @param Object Das zu vergleichende Objekt. 
		 * @return	boolean true wenn der Key der gleiche ist. 
		 */
		@SuppressWarnings("unchecked")
		@Override
		public boolean equals(Object obj){
			if (((KeyValue) obj).getKey() == this.key){
				return true;
			}
			return false;
		}
		
		/**
		 * Gibt eine lesbare Stringrepresentation des Objektes zurück
		 * @return String die Werte der Variablen des Objektes
		 */
		public String toString(){
			return "Schlüssel: " + key + "  Wert:" + value;
		}
	}
	
	private V[] array;
	private LinkedList<V> element;

	/**
	 * Standartkonstrukter
	 */
	public Hashtable(){
		
	}
	/**
	 * Konstruktor um die Größe des Arrays der Hashtabele zu setzten.
	 * Array wird mit leeren LinkedList-Objekten belegt.
	 * @param size Die größe des Arrays der Hashtable vom Typ int.
	 */
	@SuppressWarnings("unchecked")
	public Hashtable(int size){
		array = (V[]) new Object[size];
		for (int i = 0; i < array.length; i++){
			element = (LinkedList<V>) new LinkedList<KeyValue>();
			array[i] = (V) element;
		}
	}
	
	/**
	 * Berechnet den Index an dem in der Hashtabelle eingefügt wird.
	 * @param key vom Typ K (Generisch).
	 * @return index der Wert an dem in der Hashtabelle eingefügt wird vom Typ int als Betrag.
	 */
	public int hashFunction(K key){	
		int index = Math.abs(key.hashCode() % array.length);
	      return index;
	}
	/**
	 * fuegt ein Schluessel-Wert-Paar in die Map ein
	 * @param key Der Schluessel 
	 * @param value Der Wert
	 * @return falls es schon einen Wert mit Schluessel key in der Map gab, 
	 *   wird der alte Wert entfernt und zurueckgegeben; sonst wird null zurueckgegeben
	 */
	@SuppressWarnings("unchecked")
	@Override
	public V put(K key, V value) {
		int index = hashFunction(key);
		KeyValue keyValue = new KeyValue(key, value);
		LinkedList<KeyValue> list = (LinkedList<KeyValue>) array[index];
			if(list.contains(keyValue)){
				KeyValue alt = list.remove(list.get(keyValue));
				list.add(keyValue);
				return (V) alt;
			}
		list.add(keyValue);
		return null;
	}

	/**
	 * bestimmt den Wert zu einem Schluessel in der Map
	 * @param key der Schluessel
	 * @return den Wert zum Schluessel key, falls ein entsprechendes Schluessel-Wert-Paar vorhanden ist;
	 *   null sonst
	 */
	@SuppressWarnings("unchecked")
	@Override
	public V get(K key) {
		KeyValue suchKey = new KeyValue(key, null);
		for (int i = 0; i < array.length; i++){
			LinkedList<KeyValue> list = (LinkedList<KeyValue>) array[i];
			if (list.contains(suchKey)){
				KeyValue wert = list.get(suchKey);
				return wert.getValue();
			}
		}
		return null;
	}

	/**
	 * entfernt ein Schluessel-Wert-Paar aus der Map
	 * @param key der Schluessel
	 * @return der Wert zu dem Schluessel, falls ein entsprechendes Schluessel-Wert-Paar vorhanden ist;
	 *   null sonst
	 */
	@SuppressWarnings("unchecked")
	@Override
	public V remove(K key) {
		KeyValue reKey = new KeyValue(key, null);
		for (int i = 0; i < array.length; i++){
			LinkedList<KeyValue> list = (LinkedList<KeyValue>) array[i];
			if (list.contains(reKey)){
				KeyValue wert = list.remove(list.get(reKey));
				return wert.getValue();
			}
		}
		return null;
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public String toString(){
		StringBuilder ausgabe = new StringBuilder( );
	    for(int i = 0; i < array.length; i++){
	    	ausgabe.append("Arrayindex: " + i + "   ");
	    	LinkedList<KeyValue> list = (LinkedList<KeyValue>) array[i];
	    	ausgabe.append(list.toString() + "\n");
	    }
	    return ausgabe.toString(); 	
	}

}
```

Testklasse:

```
public class MainTestHashtable {

	   /**
	    * @param args
	    */
	   public static void main(String[] args) {
	      System.out.println("Test der Aufgabe 2.3 startet!!\n");
	      Hashtable<String, Integer> hash = new Hashtable<String, Integer>(5);
	      System.out.println("Leere Hashtable:\n" + hash.toString());
	      System.out.println("<-------------------------------------------------------->");
	      System.out.println("Leerer Hashtable Werte hinzufügen: \n");
	      System.out.println(hash.put("Test1",  1));
	      System.out.println(hash.put("Test2", 	2));
	      System.out.println(hash.put("Test3", 	3));
	      System.out.println(hash.put("Test4", 	4));
	      System.out.println(hash.put("Test5", 	5));
	      System.out.println(hash.put("Test6", 	10));
	      System.out.println(hash.put("Test7", 	20));
	      System.out.println(hash.put("Test8", 	30));
	      System.out.println(hash.put("Test9", 	40));
	      System.out.println(hash.put("Test10", 50));
	      System.out.println(hash.put("Test11", 100));
	      System.out.println(hash.put("Test12", 200));
	      System.out.println(hash.put("Test13", 300));
	      System.out.println(hash.put("Test14", 400));
	      System.out.println(hash.put("Test15", 500));
	      System.out.println("\n");
	      System.out.println("Hashtable mit hinzugefügten Werten:\n" + hash.toString());
	      System.out.println("<-------------------------------------------------------->");
	      System.out.println("Vorhandenen Schlüssel der Hashtable hinzufügen: \n");
	      System.out.println("Hashtable vorher:\n" + hash.toString() + "\n");
	      System.out.println(hash.put("Test3", 	200000));
	      System.out.println(hash.put("Test4", 	3));
	      System.out.println(hash.put("Test6", 	20));
	      System.out.println(hash.put("Test9", 	30));
	      System.out.println(hash.put("Test12", 2000));
	      System.out.println(hash.put("Test15", 300));
	      System.out.println(hash.put("Test11", 20));
	      System.out.println(hash.put("Test1", 	30000));
	      System.out.println("\n");
	      System.out.println("Hashtable nachher:\n" + hash.toString());
	      System.out.println("<-------------------------------------------------------->");
	      System.out.println("Mit einem Key den Schlüssel in der Hashtable auslesen: \n");
	      System.out.println("Hashtable:\n" + hash.toString());
	      System.out.println("Test1: 	" 	+ hash.get("Test1"));
	      System.out.println("Test11: 	" 	+ hash.get("Test11"));
	      System.out.println("Test15: 	" 	+ hash.get("Test15"));
	      System.out.println("Test6: 	" 	+ hash.get("Test6"));
	      System.out.println("Test10: 	" 	+ hash.get("Test10"));
	      System.out.println("Test7: 	" 	+ hash.get("Test7"));
	      System.out.println("\n");
	      System.out.println("<-------------------------------------------------------->");
	      System.out.println("Mit einem Key den Schlüssel in der Hashtable löschen: \n");
	      System.out.println("Hashtable vor löschen:\n" + hash.toString());
	      System.out.println("Test3: 	" 	+ hash.remove("Test3"));
	      System.out.println("Test6: 	" 	+ hash.remove("Test6"));
	      System.out.println("Test15:	" 	+ hash.remove("Test15"));
	      System.out.println("Test1: 	" 	+ hash.remove("Test1"));
	      System.out.println("Test12: 	" 	+ hash.remove("Test12"));
	      System.out.println("\n");
	      System.out.println("Hashtable nach löschen:\n" + hash.toString());
	      System.out.println("\n");

	   }

}
```

Und dieser Gartensalat inkl. NullPointer kommt bei raus und ich bin wieder am Anfang meiner Gedanken. Die toString MEthode sollte eigentlich passen und warum er NullPointer wirft, da muss ich gerade mal passen...

```
Test der Aufgabe 2.3 startet!!

Leere Hashtable:
Arrayindex: 0   Pflichtaufgabe2.LinkedList@23fc4bec
Arrayindex: 1   Pflichtaufgabe2.LinkedList@8dc8569
Arrayindex: 2   Pflichtaufgabe2.LinkedList@45bab50a
Arrayindex: 3   Pflichtaufgabe2.LinkedList@64c3c749
Arrayindex: 4   Pflichtaufgabe2.LinkedList@7150bd4d

<-------------------------------------------------------->
Leerer Hashtable Werte hinzufügen: 

null
null
null
null
null
null
null
null
null
null
null
null
null
null
null


Hashtable mit hinzugefügten Werten:
Arrayindex: 0   Pflichtaufgabe2.LinkedList@23fc4bec
Arrayindex: 1   Pflichtaufgabe2.LinkedList@8dc8569
Arrayindex: 2   Pflichtaufgabe2.LinkedList@45bab50a
Arrayindex: 3   Pflichtaufgabe2.LinkedList@64c3c749
Arrayindex: 4   Pflichtaufgabe2.LinkedList@7150bd4d

<-------------------------------------------------------->
Vorhandenen Schlüssel der Hashtable hinzufügen: 

Hashtable vorher:
Arrayindex: 0   Pflichtaufgabe2.LinkedList@23fc4bec
Arrayindex: 1   Pflichtaufgabe2.LinkedList@8dc8569
Arrayindex: 2   Pflichtaufgabe2.LinkedList@45bab50a
Arrayindex: 3   Pflichtaufgabe2.LinkedList@64c3c749
Arrayindex: 4   Pflichtaufgabe2.LinkedList@7150bd4d


null
null
Schlüssel: Test6  Wert:10
null
Schlüssel: Test12  Wert:200
Schlüssel: Test15  Wert:500
Schlüssel: Test11  Wert:100
null


Hashtable nachher:
Arrayindex: 0   Pflichtaufgabe2.LinkedList@23fc4bec
Arrayindex: 1   Pflichtaufgabe2.LinkedList@8dc8569
Arrayindex: 2   Pflichtaufgabe2.LinkedList@45bab50a
Arrayindex: 3   Pflichtaufgabe2.LinkedList@64c3c749
Arrayindex: 4   Pflichtaufgabe2.LinkedList@7150bd4d

<-------------------------------------------------------->
Mit einem Key den Schlüssel in der Hashtable auslesen: 

Hashtable:
Arrayindex: 0   Pflichtaufgabe2.LinkedList@23fc4bec
Arrayindex: 1   Pflichtaufgabe2.LinkedList@8dc8569
Arrayindex: 2   Pflichtaufgabe2.LinkedList@45bab50a
Arrayindex: 3   Pflichtaufgabe2.LinkedList@64c3c749
Arrayindex: 4   Pflichtaufgabe2.LinkedList@7150bd4d

Test1: 	30000
Test11: 	20
Test15: 	300
Test6: 	20
Test10: 	50
Test7: 	20


<-------------------------------------------------------->
Mit einem Key den Schlüssel in der Hashtable löschen: 

Hashtable vor löschen:
Arrayindex: 0   Pflichtaufgabe2.LinkedList@23fc4bec
Arrayindex: 1   Pflichtaufgabe2.LinkedList@8dc8569
Arrayindex: 2   Pflichtaufgabe2.LinkedList@45bab50a
Arrayindex: 3   Pflichtaufgabe2.LinkedList@64c3c749
Arrayindex: 4   Pflichtaufgabe2.LinkedList@7150bd4d

Test3: 	null
Exception in thread "main" java.lang.NullPointerException
	at Pflichtaufgabe2.Hashtable.remove(Hashtable.java:170)
	at Pflichtaufgabe2.MainTestHashtable.main(MainTestHashtable.java:58)
```


----------



## Suinos (17. Mai 2011)

Dein _Gartensalat_ ist ganz normal die 
	
	
	
	





```
toString
```
-Methode der Klasse 
	
	
	
	





```
LinkedList
```
, wie es in deiner Ausgabe ja auch steht, welche diese nicht überschrieben hat und darum die von 
	
	
	
	





```
Object
```
 verwendet wird.
Wahrscheinlich solltest du hier alle Einträge in den Listen ausgeben:
[JAVA=180]
LinkedList<KeyValue> list = (LinkedList<KeyValue>) array_;
ausgabe.append(list.toString() + "\n");
[/code]

Die NPEs bekommst du auf (vermutlich) diesen Zeilen:
[JAVA=166]
if (list.contains(reKey)){
       KeyValue wert = list.remove(list.get(reKey));
       return wert.getValue();
[/code]


		Code:In die Zwischenablage kopieren


wert

 ist also 
	
	
	
	






		Code:In die Zwischenablage kopieren


null

.
Findest du heraus, wieso?

---

Der Rest des Codes macht mir aber noch mehr Sorgen:


		Java:In die Zwischenablage kopieren


public class Hashtable<K, V> implements Map<K, V> {
// [...]
    private V[] array;
    private LinkedList<V> element;

// [...]
   LinkedList<KeyValue> list = (LinkedList<KeyValue>) array[index];

:autsch:

Ich würde mir nochmals die Anforderungen durchlesen, und auf Papier aufschreiben, wie diese sauber implementiert werden könnten.

All diese Warnungen, welche du unterdrückst?


		Java:In die Zwischenablage kopieren


@SuppressWarnings("unchecked")

Die sagen dir, dass du dort was falsch machst!
Also bitte nimm die Annotation weg, und löse das Problem, anstelle einfach nur die Warnung zu ignorieren._


----------



## MarioK (17. Mai 2011)

Also die Anforderungen für diese Hashtable sind die folgenden:
"Schreiben Sie eine generische Java-Klasse Hashtable, die das (reduzierte) Map-Interface
implementiert(Map Interface siehe oben).
Dabei soll – wie es der Name der Klasse schon ausdrückt – die Klasse intern durch eine Hashtabelle
realisiert werden. Die Hashtabelle selber soll als Array implementiert werden. Einträge in diesem
Array sollen verkettete Listen sein. Verwenden Sie dazu die selbst definierte Klasse LinkedList aus
Aufgabe 1.4. Einträge in dieser LinkedList sollen die Schlüssel-Wert-Paare sein. Günstig ist die
Verwendung einer selbst definierten (inneren) Klasse für Schlüssel-Wert-Paare.
In einem Konstruktor soll die Größe der Hashtabelle, d.h. die Größe des Arrays bestimmt werden
können. Um nun ein Schüssel-Wert-Paar in die Hashtabelle eintragen zu können, muss eine
Hashfunktion (Prototyp: int hashFunction(K key)) geschrieben werden. Diese Hashfunktion
soll den Index in der Hashtabelle bestimmen, an dem ein Schlüssel-Wert-Paar in der entsprechenden
verketteten Liste abgelegt wird. Nutzen Sie dazu das Divisionsrestverfahren, d.h. Index in der
Hashtabelle = key.hashCode() % Größe der Hashtabelle."

meine selbst geschriebene Klasse LinkedList siehe hier : http://www.java-forum.org/allgemein...en-eigene-generische-klasse-linkedlist-2.html enthält nicht wirklich eine toString Methode, ferne benutze ich da debug in VErbindung mit der gibAlles Methode. Eine toString MEhtode habe ich nicht wikrlich hinbekommen.


----------



## MarioK (19. Mai 2011)

toString Methode habe ich jetzt auch korrigiert in der Linked List .... bleibt jetzt noch die NullPointerException:

```
Test der Aufgabe 2.3 startet!!

Leere Hashtable:
Arrayindex: 0   
Arrayindex: 1   
Arrayindex: 2   
Arrayindex: 3   
Arrayindex: 4   

<-------------------------------------------------------->
Leerer Hashtable Werte hinzufügen: 

null
null
null
null
null
null
null
null
null
null
null
null
null
null
null


Hashtable mit hinzugefügten Werten:
Arrayindex: 0   Schlüssel: Test1  Wert:1,Schlüssel: Test6  Wert:10,Schlüssel: Test13  Wert:300,
Arrayindex: 1   Schlüssel: Test2  Wert:2,Schlüssel: Test7  Wert:20,Schlüssel: Test12  Wert:200,
Arrayindex: 2   Schlüssel: Test3  Wert:3,Schlüssel: Test8  Wert:30,Schlüssel: Test11  Wert:100,
Arrayindex: 3   Schlüssel: Test4  Wert:4,Schlüssel: Test9  Wert:40,Schlüssel: Test10  Wert:50,Schlüssel: Test15  Wert:500,
Arrayindex: 4   Schlüssel: Test5  Wert:5,Schlüssel: Test14  Wert:400,

<-------------------------------------------------------->
Vorhandenen Schlüssel der Hashtable hinzufügen: 

Hashtable vorher:
Arrayindex: 0   Schlüssel: Test1  Wert:1,Schlüssel: Test6  Wert:10,Schlüssel: Test13  Wert:300,
Arrayindex: 1   Schlüssel: Test2  Wert:2,Schlüssel: Test7  Wert:20,Schlüssel: Test12  Wert:200,
Arrayindex: 2   Schlüssel: Test3  Wert:3,Schlüssel: Test8  Wert:30,Schlüssel: Test11  Wert:100,
Arrayindex: 3   Schlüssel: Test4  Wert:4,Schlüssel: Test9  Wert:40,Schlüssel: Test10  Wert:50,Schlüssel: Test15  Wert:500,
Arrayindex: 4   Schlüssel: Test5  Wert:5,Schlüssel: Test14  Wert:400,


null
null
Schlüssel: Test6  Wert:10
null
Schlüssel: Test12  Wert:200
Schlüssel: Test15  Wert:500
Schlüssel: Test11  Wert:100
null


Hashtable nachher:
Arrayindex: 0   Schlüssel: Test6  Wert:20,Schlüssel: Test1  Wert:30000,
Arrayindex: 1   Schlüssel: Test2  Wert:2,Schlüssel: Test7  Wert:20,Schlüssel: Test12  Wert:2000,
Arrayindex: 2   Schlüssel: Test8  Wert:30,Schlüssel: Test11  Wert:20,
Arrayindex: 3   Schlüssel: Test10  Wert:50,Schlüssel: Test15  Wert:300,
Arrayindex: 4   Schlüssel: Test5  Wert:5,Schlüssel: Test14  Wert:400,

<-------------------------------------------------------->
Mit einem Key den Schlüssel in der Hashtable auslesen: 

Hashtable:
Arrayindex: 0   Schlüssel: Test6  Wert:20,Schlüssel: Test1  Wert:30000,
Arrayindex: 1   Schlüssel: Test2  Wert:2,Schlüssel: Test7  Wert:20,Schlüssel: Test12  Wert:2000,
Arrayindex: 2   Schlüssel: Test8  Wert:30,Schlüssel: Test11  Wert:20,
Arrayindex: 3   Schlüssel: Test10  Wert:50,Schlüssel: Test15  Wert:300,
Arrayindex: 4   Schlüssel: Test5  Wert:5,Schlüssel: Test14  Wert:400,

Test1: 	30000
Test11: 20
Test15: 300
Test6: 	20
Test10: 50
Test7: 	20


<-------------------------------------------------------->
Mit einem Key den Schlüssel in der Hashtable löschen: 

Hashtable vor löschen:
Arrayindex: 0   Schlüssel: Test6  Wert:20,Schlüssel: Test1  Wert:30000,
Arrayindex: 1   Schlüssel: Test2  Wert:2,Schlüssel: Test7  Wert:20,Schlüssel: Test12  Wert:2000,
Arrayindex: 2   Schlüssel: Test8  Wert:30,Schlüssel: Test11  Wert:20,
Arrayindex: 3   Schlüssel: Test10  Wert:50,Schlüssel: Test15  Wert:300,
Arrayindex: 4   Schlüssel: Test5  Wert:5,Schlüssel: Test14  Wert:400,

Test3: 	null
Exception in thread "main" java.lang.NullPointerException
	at Pflichtaufgabe2.Hashtable.remove(Hashtable.java:172)
	at Pflichtaufgabe2.MainTestHashtable.main(MainTestHashtable.java:55)
```


----------



## zerix (20. Mai 2011)

Was steht denn in der Zeile 172?

Gruß

zerix


----------

