Korrekte Art, HashMap zu initialisieren und kann HashMap verschiedene Werttypen enthalten?

Also ich habe zwei Fragen über HashMaps in Java:

Was ist die richtige Methode zum initialisieren einer HashMap? Ich denke, es ist vielleicht das beste in meiner situation zu verwenden:
```
HashMap x = new HashMap();
```
Aber Eclipse hält, was darauf hindeutet, dass ich verwenden:
```
HashMap<something, something> map = new HashMap();
```
Was ist besser?
Kann ein HashMap verschiedene Arten von Objekten/Datentypen als Werte? Zum Beispiel würde das funktionieren und in Ordnung sein:
```
map.put("one", 1);
map.put("two", {1, 2});
map.put("three", "hello");
```
In der ersten put() ich will einen int als Wert, in der zweiten ein int[], und die Dritte ein string. Ist das in Ordnung zu tun, die in Java mit HashMaps? Auch ist es okay, zu speichern HashMap als einen Wert in einer HashMap?

InformationsquelleAutor der Frage sepiroth | 2009-08-28

94

Es hängt wirklich davon ab, welche Art von Art der Sicherheit, die Sie brauchen. Die nicht-generische Art und Weise zu tun, es ist am besten getan als:
```
 Map x = new HashMap();
```
Beachten Sie, dass x eingegeben wird als Map. dies macht es viel einfacher zu ändern-Implementierungen (TreeMap oder eine LinkedHashMap) in die Zukunft.

Können Sie Generika verwendet werden, um sicherzustellen, daß eine bestimmte Ebene der Typ-Sicherheit:
```
Map<String, Object> x = new HashMap<String, Object>();
```
In Java 7 und später die Sie tun können
```
Map<String, Object> x = new HashMap<>();
```
Oben, während Ausführlicher, vermeidet compiler-Warnungen. In diesem Fall wird der Inhalt der HashMap kann jede Object, so dass werden kann Integer, int[] usw. das ist, was Sie tun.

Wenn Sie noch mit Java 6, Guava Bibliotheken (obwohl es ist leicht genug, selbst zu tun) hat eine Methode namens newHashMap() vermeidet die Notwendigkeit, duplizieren Sie die generische Eingabe von Informationen wenn Sie eine new. Es leitet den Typ der Variablen-Deklaration (dies ist eine Java-Funktion nicht verfügbar auf Konstruktoren vor Java 7).

Durch die Art und Weise, wenn Sie fügen Sie eine " int " oder andere primitive, Java autoboxing. Das bedeutet, dass der code ist äquivalent zu:
```
 x.put("one", Integer.valueOf(1));
```
Können Sie sicher eine HashMap als Wert in einem anderen HashMap, aber ich denke, es gibt Probleme, wenn man es rekursiv (d.h. setzen die HashMap als ein Wert in sich).

InformationsquelleAutor der Antwort Yishai
13

Dies ist eine änderung, die mit Java 1.5. Was Sie Liste der erste ist der alte Weg, der zweite ist der neue Weg.

Mithilfe von HashMap, die Sie tun können, Dinge wie:
```
HashMap<String, Doohickey> ourMap = new HashMap<String, Doohickey>();

....

Doohickey result = ourMap.get("bob");
```
Wenn Sie nicht über den Typen auf die Karte, die Sie haben würden, um dies zu tun:
```
Doohickey result = (Doohickey) ourMap.get("bob");
```
Es ist wirklich sehr nützlich. Es hilft Ihnen, Fehler abzufangen und vermeiden Sie das schreiben von allen Arten von zusätzlichen wirft. Es war einer meiner Lieblings-features der 1.5 (und höher).

Kann man noch mehrere Dinge in die Karte, so geben Sie es als Karte, dann können Sie jedes andere Objekt (einen String, eine andere Karte, und Integer-und drei MyObjects, wenn Sie so geneigt).

InformationsquelleAutor der Antwort MBCook
4

Eclipse ist zu empfehlen, dass Sie erklären die Art der HashMap, denn das erzwingt eine gewisse Art der Sicherheit. Natürlich, es klingt wie Sie versuchen zu vermeiden, geben Sie die Sicherheit von Ihrem zweiten Teil.

Wenn Sie möchten, um letzteres zu tun, versuchen Sie deklarieren Karte als HashMap<String,Object>.

InformationsquelleAutor der Antwort Paul Tomblin
3

Den Weg, Sie schreiben es entspricht
```
HashMap<Object, Object> map = new HashMap<Object, Object>();
```
Was geht in den Klammern ist Sie, die Kommunikation mit dem compiler, was du gehst zu setzen in die HashMap so, dass Sie die Fehlerüberprüfung für Sie. Wenn der Objekt -, Objekt ist das, was Sie eigentlich wollen (wahrscheinlich nicht), müssen Sie explizit deklarieren. In der Regel sollten Sie so explizit wie können Sie mit der Erklärung zu erleichtern, die Fehlerprüfung durch den compiler. Was Sie beschrieben haben, sollte wohl erklärt werden, wie diese:
```
HashMap<String, Object> map = new HashMap<String, Object>();
```
So dass Sie zumindest erklären, dass Ihre Tasten werden Zeichenfolgen, aber Ihre Werte können alles sein. Denken Sie nur daran, eine Besetzung, wenn Sie einen Wert wieder raus.

InformationsquelleAutor der Antwort Graphics Noob
2

Die 2. ist die Verwendung von Generika, die kam mit Java 1.5. Es wird die Anzahl der casts in Ihrem code und können Ihnen helfen, fangen die Fehler an compile-Zeit statt der Laufzeit. Das heißt, es hängt davon ab, was Sie Programmieren. Eine quick & dirty-Karte, halten Sie ein paar Objekte von verschiedenen Typen, muss nicht die Generika. Aber wenn die Karte hält alle Objekte absteigend von einem anderen Typ als Objekt, es kann es Wert sein.

Vorherige poster ist falsch über das array in einer Karte. Ein array ist eigentlich ein Objekt, so ist es ein Gültiger Wert.
```
Map<String,Object> map = new HashMap<String,Object>();
map.put("one",1); //autoboxed to an object
map.put("two", new int[]{1,2} ); //array of ints is an object
map.put("three","hello"); //string is an object
```
Auch, da die HashMap ein Objekt ist, es kann auch ein Wert in eine HashMap.

InformationsquelleAutor der Antwort Billy Bob Bain
1

Einer HashMap halten kann jedes Objekt als Wert, auch wenn es eine weitere HashMap. Eclipse ist darauf hindeutet, dass Sie erklären dem Typen, weil das ist die empfohlene Praxis für die Sammlungen. unter Java 5. Sie sind frei, Sie zu ignorieren Eclipse Vorschläge.

Unter Java 5 ein int (oder eine beliebige primitive Art) werden autoboxed in eine ganze Zahl (oder anderen entsprechenden Art), wenn Sie es hinzufügen, um eine Sammlung. Seien Sie vorsichtig mit dieser, obwohl, wie es gibt einige Fänge, mit autoboxing.

InformationsquelleAutor der Antwort Ken Liu
1

Eclipse ist darauf hindeutet, Sie zu definieren generic type so, dass man type safety. Schreiben Sie
```
Map m = new HashMap();
```
denen nicht sichergestellt, dass die Typsicherheit aber folgenden wird sichergestellt, Art Sicherheit
```
Map<Object,Object> = new HashMap<Object,Object>();
```
Den Object kann jede Art, wie String, Integer etc.

InformationsquelleAutor der Antwort
0

In der Antwort auf Ihre zweite Frage: ja eine HashMap halten kann verschiedene Arten von Objekten. Ob das eine gute Idee ist oder nicht, hängt von dem problem, das Sie versuchen zu lösen.

Gesagt, dein Beispiel funktioniert nicht. Der int-Wert ist kein Objekt. Verwenden Sie den Integer-wrapper-Klasse zum speichern von int-Wert in eine HashMap

InformationsquelleAutor der Antwort Luke

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.