Quelle est la différence entre la table de hachage et les objets de la Carte en Java?

Il n'y a pas de différence entre les objets; vous avez une HashMap<String, Object> dans les deux cas. Il y a une différence dans la interface vous avez de l'objet. Dans le premier cas, l'interface est HashMap<String, Object>, tandis que dans le second c'est Map<String, Object>. Mais l'objet sous-jacent est le même.

L'avantage de l'utilisation de Map<String, Object> est que vous pouvez changer l'objet sous-jacent à un autre type de carte sans rupture de votre contrat avec tout le code qui l'utilise. Si vous déclarez que HashMap<String, Object>, vous devez modifier votre contrat, si vous souhaitez modifier l'implémentation sous-jacente.

---

Exemple: disons que j'écris cette classe:

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...
}

La classe a un couple de cartes interne de la chaîne->objet qui il partage (via des méthodes accesseur) avec des sous-classes. Disons que je l'écris avec HashMaps de départ, parce que je pense que c'est la structure appropriée à utiliser lors de l'écriture de la classe.

Plus tard, Marie écrit le code sous-classement. Elle a quelque chose qu'elle doit faire avec les deux things et moreThings, alors, naturellement, elle le met que dans une méthode commune, et elle utilise le même type que j'ai utilisé sur getThings/getMoreThings lors de la définition de sa méthode:

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

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

    //...more...
}

Plus tard, je décide qu'en fait, c'est mieux si j'utilise TreeMap au lieu de HashMap dans Foo. - Je mettre à jour Foo, l'évolution HashMap à TreeMap. Maintenant, SpecialFoo ne compile pas plus, parce que j'ai rompu le contrat: Foo l'habitude de dire qu'il a fourni HashMaps, mais maintenant c'est le TreeMaps à la place. Nous avons donc à résoudre SpecialFoo maintenant (et ce genre de chose peut se propagent par le biais d'une base de code).

Sauf si j'ai eu une très bonne raison pour le partage de ma mise a l'aide d'un HashMap (et ça arrive), ce que j'aurais fait a été de déclarer getThings et getMoreThings comme juste retour Map<String, Object>, sans être plus précis que ça. En fait, à moins d'une bonne raison pour faire quelque chose d'autre, même au sein de Foo je devrais probablement déclarer things et moreThings comme Map, pas 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...
}

Note comment je suis maintenant en utilisant Map<String, Object> partout où je le peux, seul être précis, quand je créer des objets réels.

Si j'avais fait cela, alors Marie aurait fait ceci:

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

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

...et de changer de Foo n'aurait pas eu de SpecialFoo arrêt de la compilation.

(Interfaces et les classes de base) nous révèlent qu'autant qu'il est nécessaire, en gardant la flexibilité de nos sous les couvertures pour faire les changements appropriés. En général, nous voulons avoir nos références être aussi simple que possible. Si nous n'avons pas besoin de savoir c'est un HashMap, il vous suffit d'appeler un Map.

Ce n'est pas aveugle de la règle, mais en général, de codage à la plus générale de l'interface va être moins cassant que le codage à quelque chose de plus spécifique. Si j'avais de rappeler que, je n'aurais pas créé un Foo que défini Marie à l'échec avec SpecialFoo. Si Marie a rappeler que, même si j'ai foiré Foo, elle aurait déclaré sa méthode privée avec Map au lieu de HashMap et mon changement de Foos'contrat n'aurait pas eu des répercussions sur son code.

Parfois, vous ne pouvez pas faire cela, parfois, vous avez à être précis. Mais à moins d'avoir une raison d'être, err vers le moins-interface spécifique.

Carte a les implémentations suivantes:

1. HashMap Map m = new HashMap();

2. LinkedHashMap Map m = new LinkedHashMap();

3. Tree Map Map m = new TreeMap();

4. WeakHashMap Map m = new WeakHashMap();

Supposons que vous ayez créé une méthode (c'est juste pseudo-code).

public void HashMap getMap(){
   return map;
}

Supposons que les besoins de votre projet de changement:

1. La méthode doit retourner contenu de la carte - Besoin de retourner HashMap.
2. La méthode doit retourner une carte de la clé dans la commande d'insertion - Besoin de changer le type de retour HashMap à LinkedHashMap.
3. La méthode doit retourner la carte-clé de l'ordre de tri - Besoin de changer le type de retour LinkedHashMap à TreeMap.

Si votre méthode renvoie classes spécifiques au lieu de quelque chose qui met en œuvre la Map interface, vous devez changer le type de retour de getMap() méthode à chaque fois.

Mais si vous utilisez le polymorphisme de la fonctionnalité de Java, et au lieu de retourner classes spécifiques, l'utilisation de l'interface Map, il améliore code de réutilisabilité et de réduire l'impact des changements d'exigences.

Comme l'a noté TJ Crowder et Adamski, une référence à une interface, l'autre à une mise en œuvre spécifique de l'interface. Selon Joshua Bloc, vous devriez toujours essayer de coder des interfaces, pour vous permettre de mieux gérer les changements sous-jacents de la mise en œuvre - c'est à dire si HashMap soudain n'était pas idéal pour votre solution et vous avez besoin de modifier le plan de mise en œuvre, vous pouvez toujours utiliser l'interface de la Carte, et de changer l'instanciation de type.

Carte est le de type statique de la carte, tandis que la table de hachage est la de type dynamique de la carte. Cela signifie que le compilateur va traiter votre carte de l'objet comme étant un type de Carte, même si au moment de l'exécution, il peut pointer vers n'importe quel sous-type de il.

Cette pratique de la programmation à l'aide d'interfaces au lieu de les implémentations a l'avantage de rester souple: Vous pouvez par exemple remplacer le type dynamique de la carte au moment de l'exécution, tant qu'il est un sous-type de Carte (par exemple, LinkedHashMap), et de modifier le plan du comportement à la volée.

Une bonne règle de base est de rester aussi abstrait que possible sur le niveau de l'API: Si, par exemple, une méthode de programmation doivent travailler sur les cartes, puis il suffit de déclarer un paramètre comme la Carte au lieu de la plus stricte (parce que moins abstraite) de type HashMap. De cette façon, le consommateur de votre API peut être flexible sur ce type de Carte de mise en œuvre qu'ils veulent transmettre à votre méthode.

Carte est de l'interface et de la table de hachage est une classe qui implémente l'Interface de Carte

Carte est l'Interface et de la table de hachage est la classe qui implémente cette.

Donc, dans cette application, vous créez les mêmes objets

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

Tout d'abord Map est une interface qu'il a mises en œuvre différentes comme - HashMap, TreeHashMap, LinkedHashMap etc. L'Interface fonctionne comme un super classe pour la mise en œuvre de la classe. Ainsi, selon la programmation orientée objet est la règle concrète de la classe qui implémente Map est un Map aussi. Cela signifie que nous pouvons attribuer/mettre des HashMap type de variable à une Map variable de type sans aucun type de casting.

Dans ce cas, nous pouvons attribuer map1 à map2 sans aucun moulage ou de toute perte de données -

map2 = map1