# HashMap<String,Object> Werte auslesen



## tobito (1. Jun 2012)

Hallo,

ich möchte eine HashMap mit folgendem Muster aufbauen und danach die Value's Werte als "leserliche" Strings anstelle von Objects zurück erhalten.  Dazu möchte ich drei Klassen nutzen und in der MAIN Klasse die Abfrage starten. Was kann ich machen um dieses zu erreichen?


```
package de.training.hashmap;

public class Item {
	
	String keyWord,name;
	double wert1, wert2;

	public Item(String name, double wert1, double wert2){
		this.name = name;
		this.wert1 = wert1;
		this.wert2 = wert2;
	}
}
```


```
package de.training.hashmap;

import java.util.HashMap;

public class Customer {

	String outObj;

	Customer(){}

	public void datenZurueck(String keyWord) {
		HashMap<String, Item> cs = new HashMap<String, Item>();
		

		cs.put("Hans", new Item("Schneider", 23.86, 400 ));
		cs.put("Peter", new Item("Rumba", 7.56, 200));
		cs.put("Alf", new Item("Mueller", 3.22, 350));


		for (String name : cs.keySet()) {
			System.out.println(name + ": " + cs.get(name).toString());
			System.out.println(cs.values().toString());
		}
	}

	public String toString() {
		return outObj;
	}
}
```


```
package de.training.hashmap;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Customer cs = new Customer ();
		cs.datenZurueck("Hans");
		
		
	}

}
```

Danke und Gruss

Tobito


----------



## CortPoker (1. Jun 2012)

Erst mal empfehle ich, die HashMap nicht lokal in einer Methode zu deklarieren. Dann würde ich dir noch getter für die HashMap ans Herz legen, damit du in deiner Main Klasse drauf zugreifen kannst. Das wolltest du ja, richtig?

Schreib ne ordentliche toString() Methode für Item. Sowas wie 
	
	
	
	





```
public String toString() {
     return getName() + " " + ..... (all deine Attribute);
}
```
Dann rufst du die HashMap mit get(String key) auf und kriegst ein Object zurück, welches du als Item casten kannst
Also z.B. 
	
	
	
	





```
Item neuesItem = (Item) hashMap.get("Peter");
```
Darauf kannst du dann ganz einfach deine toString() Methode aus Item anwenden


----------



## HimBromBeere (1. Jun 2012)

Die 
	
	
	
	





```
toString()
```
-Methode deines Costumers ist überdies vollkommen sinnfrei, da du die Variablle outObj ja nie mit einem Wert belegst. Zeile 22 in deiner 
	
	
	
	





```
Costumer
```
-Klasse ist übrgiens obsolet, mach´s, wie CortPoler gesagt hat: hole dir erst das Objekt mit dem Schlüssel 
	
	
	
	





```
"name"
```
 und caste es in ein 
	
	
	
	





```
Item
```
. Danach kannst du darauf alle deine Item-Methoden anwenden, z.B. 
	
	
	
	





```
getName
```
 oder - sofern du eine solche schreiben willst - 
	
	
	
	





```
getValue(String key)
```
, um den Wert eines best. Schlüssels auszulesen bzw. 
	
	
	
	





```
getValue(int index)
```
 oder eben die 
	
	
	
	





```
toString
```
 von Item, in der alle Attribute einfach gelistet werden.


----------



## nillehammer (1. Jun 2012)

Den Tipps meiner Vorredner kann ich mich nur anschließen, aber wieso redet Ihr immer von Casten?

```
HashMap<String, Item> cs = new HashMap<String, Item>();
```
Die Map ist doch generisch und liefert direkt Items zurück.

Folgendes wäre übrigens statt obiger Zeile besser:

```
Map<String, Item> cs = new HashMap<String, Item>();
```


----------



## tobito (1. Jun 2012)

Zuerst einmal ein dickes Dankeschön für die schnelle Hilfe. Und deshalb poste ich hier noch einmal den kompletten Code:



```
package de.training.hashmap;

public class Item {
	
	String keyWord,name,vorName;
	double wert1, wert2;

	public Item(String name, String vorName, double wert1, double wert2){
		this.name = name;
		this.vorName = vorName;
		this.wert1 = wert1;
		this.wert2 = wert2;
	}
	
	public String toString() {
	     return (getName() + " " + name+ " " + vorName + " " + wert1+ " " + wert2);
	}

	public String getName() {
		return name;
	}
}
```


```
package de.training.hashmap;

import java.util.HashMap;

public class Customer {

	HashMap<String, Item> cs = new HashMap<String, Item>();
	
	Customer(){} //Standardkonstruktur

	public void datenZurueck(String keyWord) {

		cs.put("Hans", new Item("Schneider","Hans", 23.86, 400 ));
		cs.put("Peter", new Item("Rumba", "Peter", 7.56, 200));
		cs.put("Alf", new Item("Mueller", "Alf", 3.22, 350));


		Item neuesItem = (Item) cs.get(keyWord);
		System.out.println("Name    : " + neuesItem.name);
		System.out.println("Vorname : " + neuesItem.vorName);
		System.out.println("Wert 1  : " + neuesItem.wert1);
		System.out.println("Wert 2  : " + neuesItem.wert2);
		
		
	}
	
	// Getter für Map
	public HashMap<String, Item> getCs() {
		return cs;
	}
	
}
```


```
package de.training.hashmap;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		final String keyWord;
		
		keyWord = "Hans";
		Customer cs = new Customer ();
		cs.datenZurueck(keyWord);
		System.out.println("\n" +cs.getCs());
				
	}
}
```

Mir ist noch nicht klar, weshalb ich die Methode String überschreibe. Zur Zeit habe ich, wenn mich nicht alles täuscht gar keinen Nutzen von dieser überschriebenen Methode:


```
public String toString() {
	     return (getName() + " " + name+ " " + vorName + " " + wert1+ " " + wert2);
	}
```

Dann habe ich die empfohlenen getValue-Methoden gesucht und weiß noch nicht wie ich sie implementieren kann. Auf welches Objekt muss ich diese anwenden? 

nillehammer hat mir noch empfohlen Map anstelle von HashMap  zu nehmen. Worin genau liegt hier der Vorteil?

Und zum Abschluss noch die Frage : Wie kann ich aus "class Main" heraus auf die einzelnen Werte der Map zugreifen?

Gruss

tobito


----------



## CortPoker (1. Jun 2012)

Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 6.2 Privatsphäre und Sichtbarkeit
Der Link sollte erstmal deine Frage bzgl. den getValues() beantworten. Man arbeitet für gewöhnlich nicht auf den Variablen selbst.

Die Methode toString() überschreibst du deswegen, damit du nicht für jedes Item, dass du erzeugt hast, myItem.getName(), myItem.getVorname() usw. aufrufen musst, sondern alles kompakt in einer Methode hast.
Du kannst die Methode natürlich auch anders nennen, z.B. printItem().

Auf die Map kannst du aus deiner Main Klasse heraus zugreifen, indem du dir die Map über deine getCs() Methode holst.
Sprich: 
	
	
	
	





```
Customer customer = new Customer();
Item myItem = customer.getCs().get(key);
System.out.println(myItem.toString());
```
Davor evtl noch prüfen, ob die Map nicht leer ist.

Dabei ist das toString() natürlich nur exemplarisch und kann durch alle anderen öffentlichen Methoden der Klasse Item ersetzt werden.

PS: Den cast (Item) kannst du dir jetzt schenken, da in deiner Map nur Values vom Typ Item stehen dürfen, dies hast du durch die Generics festgelegt.
Und am besten den Variablen anständige Namen geben, die HashMap und die Instanz von Customer beide cs zu nennen, kann verwirrend sein.


----------

