Was ist der Unterschied zwischen HashMap und Map-Objekten in Java?

Gibt es keinen Unterschied zwischen den Objekten; Sie haben eine HashMap<String, Object> in beiden Fällen. Es gibt einen Unterschied in der Schnittstelle Sie auf das Objekt. Im ersten Fall ist die Schnittstelle HashMap<String, Object>, während in der zweiten es ist Map<String, Object>. Aber das zugrunde liegende Objekt ist das gleiche.

Den Vorteil der Verwendung Map<String, Object> ist, dass Sie ändern können, das zugrunde liegende Objekt um eine andere Art von Karte, ohne zu brechen Ihren Vertrag mit irgendwelchen code, der es nutzt. Wenn Sie deklarieren es als HashMap<String, Object> Sie müssen Ihren Vertrag ändern, wenn Sie möchten, ändern Sie die zugrunde liegende Implementierung.

Beispiel: sagen wir, ich Schreibe diese Klasse:

class Foo {
    private HashMap<String, Object> things;
    private HashMap<String, Object> moreThings;

    protected HashMap<String, Object> getThings() {
        return this.things;
    }

    protected HashMap<String, Object> getMoreThings() {
        return this.moreThings;
    }

    public Foo() {
        this.things = new HashMap<String, Object>();
        this.moreThings = new HashMap<String, Object>();
    }

    //...more...
}

Die Klasse hat ein paar interne Karten von string->Objekt, das es teilt (über accessor-Methoden) mit Unterklassen. Sagen wir, ich Schreibe es mit HashMaps, mit zu beginnen, weil ich denke, dass das die geeignete Struktur zu verwenden, wenn das schreiben der Klasse.

Später, Mary schreibt code Unterklassen. Sie hat etwas, was Sie braucht, um mit beiden things und moreThings, so natürlich Sie sagt, dass in einer gemeinsamen Methode, und Sie verwendet die gleiche Art, die ich verwendet getThings/getMoreThings bei der Definition Ihrer Methode:

class SpecialFoo extends Foo {
    private void doSomething(HashMap<String, Object> t) {
        //...
    }

    public void whatever() {
        this.doSomething(this.getThings());
        this.doSomething(this.getMoreThings());
    }

    //...more...
}

Später, beschließe ich, tatsächlich, es ist besser, wenn ich TreeMap statt HashMap im Foo. Ich update Foo, ändern HashMap zu TreeMap. Jetzt SpecialFoo nicht mehr übersetzen, denn ich habe den Vertrag gebrochen: Foo verwendet, um zu sagen, dass es, sofern HashMaps, aber jetzt ist es die Bereitstellung TreeMaps statt. Also müssen wir fix SpecialFoo jetzt (und diese Art der Sache kann die welligkeit durch eine Codebasis).

Es sei denn, ich hatte einen wirklich guten Grund für die Freigabe, dass meine Umsetzung war mit einem HashMap (und das passiert), was ich getan haben sollte war erklären getThings und getMoreThings als Rückgabe nur Map<String, Object> ohne sein mehr spezifisch, als dass. In der Tat, abgesehen von ein guter Grund, etwas anderes zu tun, sogar innerhalb Foo ich sollte wohl erklären things und moreThings als Map, nicht HashMap/TreeMap:

class Foo {
    private Map<String, Object> things;             //<== Changed
    private Map<String, Object> moreThings;         //<== Changed

    protected Map<String, Object> getThings() {     //<== Changed
        return this.things;
    }

    protected Map<String, Object> getMoreThings() { //<== Changed
        return this.moreThings;
    }

    public Foo() {
        this.things = new HashMap<String, Object>();
        this.moreThings = new HashMap<String, Object>();
    }

    //...more...
}

Hinweis, wie ich jetzt mit Map<String, Object> überall, wo ich kann, nur, wenn ich bestimmte erstellen, die die eigentlichen Objekte.

Wenn ich das gemacht hätte, dann Mary hat dies getan:

class SpecialFoo extends Foo {
    private void doSomething(Map<String, Object> t) { //<== Changed
        //...
    }

    public void whatever() {
        this.doSomething(this.getThings());
        this.doSomething(this.getMoreThings());
    }
}

...und ändern Foo würde nicht gemacht haben SpecialFoo halt kompilieren.

Schnittstellen (und Basisklassen) lasst uns zeigen nur so viel wie nötig, um unsere Flexibilität unter der Decke, sind änderungen angebracht. Im Allgemeinen, wir wollen unsere Referenzen werden so einfach wie möglich. Wenn wir nicht brauchen, zu wissen, dass es eine HashMap, nur nennen Sie es eine Map.

Dies ist nicht ein blind-Regel, aber im Allgemeinen Codierung, um die meisten Allgemeinen Schnittstelle wird weniger spröde als Kodierung, um etwas genauer zu sein. Wenn ich erinnerte mich, dass ich nicht hätte erstellt eine Foo eingestellt, dass Mary sich für das scheitern mit SpecialFoo. Wenn Maria hatte sich daran erinnerte, dass, dann, auch wenn ich Durcheinander Foo Sie würden deklariert haben Ihr eigenes Methode mit Map statt HashMap und meine wechselnden Foo's Vertrag wäre nicht ausgewirkt haben, Ihr code.

Manchmal kann man nicht tun, manchmal müssen Sie spezifisch sein. Aber es sei denn, Sie haben einen Grund zu sein, irren in Richtung der Beine-spezifische Schnittstelle.

InformationsquelleAutor T.J. Crowder

Karte verfügt über die folgenden Implementierungen:

1. HashMap Map m = new HashMap();

2. LinkedHashMap Map m = new LinkedHashMap();

3. Baum Anzeigen Map m = new TreeMap();

4. WeakHashMap Map m = new WeakHashMap();

Angenommen, Sie haben erstellt eine Methode (das ist nur pseudocode).

public void HashMap getMap(){
   return map;
}

Angenommen, Ihr Projekt ändern sich die Anforderungen:

1. Die Methode zurückgeben soll, anzeigen Inhalt - Müssen zurück HashMap.
2. Sollte die Methode return-Taste map, die in der insertion order - ändern Müssen Rückgabetyp HashMap zu LinkedHashMap.
3. Die Methode zurückgeben soll, Karte, Schlüssel in sortierter Reihenfolge - ändern Müssen Rückgabetyp LinkedHashMap zu TreeMap.

Wenn Ihr Methode gibt bestimmte Klassen anstelle von etwas, das realisiert die Map - Schnittstelle, müssen Sie ändern Sie den Rückgabetyp der getMap() Methode jedes mal.

Aber wenn Sie den Polymorphismus feature von Java, und anstatt spezifische Klassen, die die Schnittstelle Map es verbessert die code-Wiederverwendbarkeit und reduziert die Auswirkungen von änderungen der Anforderung.

InformationsquelleAutor atish shimpi

Wie bereits von TJ Crowder und Adamski, ein Verweis auf eine Schnittstelle, die andere zu einer spezifischen Implementierung der Schnittstelle. Laut Joshua Block, sollten Sie immer versuchen, um code-Schnittstellen, damit Sie besser in den Griff änderungen der zugrunde liegenden Implementierung - d.h. wenn HashMap plötzlich war nicht ideal für Ihre Lösung, und Sie Bedarf, um den map-Implementierung, Sie konnte immer noch die Karte-Schnittstelle, und ändern Sie die Instanziierung geben.

InformationsquelleAutor aperkins

Map ist der statischen Typ der Karte, während HashMap ist die dynamische Typ der Karte. Dies bedeutet, dass der compiler behandeln Sie Ihre map-Objekt als eine Art Karte, obwohl zur Laufzeit, kann es keinen Subtyp.

Diese Praxis der Programmierung gegen Schnittstellen statt-Implementierungen hat den zusätzlichen Vorteil, flexibel bleiben: Sie können zum Beispiel ersetzen Sie den dynamischen Typ von map zur Laufzeit, solange es ist ein Subtyp von Map (z.B. LinkedHashMap), und ändern Sie die map-Verhalten on-the-fly.

Eine gute Faustregel ist, um zu bleiben so Abstrakt wie möglich auf der API-Ebene: Wenn zum Beispiel eine Methode, die Sie Programmieren müssen die Karten, dann es ist ausreichend, um einen parameter zu deklarieren, die als Karte anstelle der strengeren (da weniger Abstrakt) HashMap geben. Dass die Art und Weise, die Verbraucher Ihre API flexibel sein können, über welche Art von Map-Implementierung, die Sie übergeben möchten, auf Ihre Methode.

InformationsquelleAutor Matthias

Map-Schnittstelle und Hashmap ist eine Klasse, die Map-Schnittstelle

InformationsquelleAutor

Karte ist die Schnittstelle und ist die Klasse Hashmap implementiert.

So, in dieser Implementierung erstellen Sie die gleichen Objekte

InformationsquelleAutor Diego Dias

HashMap<String, Object> map1 = new HashMap<String, Object>();
Map<String, Object> map2 = new HashMap<String, Object>();  

Zunächst Map ist eine Schnittstelle es hat verschiedene Implementierung wie - HashMap, TreeHashMap, LinkedHashMap etc. - Schnittstelle funktioniert wie ein super-Klasse für die Umsetzung Klasse. So nach OOP-Regel, die eine konkrete Klasse, die Map ist ein Map auch. Das heißt, wir ordnen/setzen keine HashMap variable vom Typ einer Map variable vom Typ ohne jede Art von casting.

In diesem Fall können wir zuordnen map1 zu map2 ohne casting oder jeglichen Verlust von Daten -

map2 = map1

InformationsquelleAutor Razib