Est HashMap en Java collision sûr

Si le hachage de la clé dans la carte entre en collision avec une clé existante, la Carte se réorganiser ou de garder les clés dans une liste en vertu de hachage. Pas de touches d'être écrasés par d'autres clés que se passera donc être triés dans le même seau.

Si plusieurs threads à l'aide de la carte simultanément, vous pouvez synchroniser l'accès à la carte si il ne gère pas les accès concurrents. (Certaines Cartes standards faire, d'autres ne le font pas. Les Collections Java package contient les classes wrapper qui ajoutent de la synchronisation.)

OriginalL'auteur rsp

HashMap est de collision-coffre-fort: regarder le code source pour mettre:

     /**
      * Associates the specified value with the specified key in this map.
      * If the map previously contained a mapping for the key, the old
      * value is replaced.
      *
      * @param key key with which the specified value is to be associated
      * @param value value to be associated with the specified key
      * @return the previous value associated with <tt>key</tt>, or
      *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
      *         (A <tt>null</tt> return can also indicate that 
      *         previously associated <tt>null</tt> with <tt>key</tt>.)
      */
     public V put(K key, V value) {
         if (key == null)
             return putForNullKey(value);
         int hash = hash(key.hashCode());
         int i = indexFor(hash, table.length);
         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
             Object k;
             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                 V oldValue = e.value;
                 e.value = value;
                 e.recordAccess(this);
                 return oldValue;
             }
         }

         modCount++;
         addEntry(hash, key, value, i);
         return null;
     }

et

     /**
      * Adds a new entry with the specified key, value and hash code to
      * the specified bucket.  It is the responsibility of this
      * method to resize the table if appropriate.
      *
      * Subclass overrides this to alter the behavior of put method.
      */
     void addEntry(int hash, K key, V value, int bucketIndex) {
         Entry<K,V> e = table[bucketIndex];
         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
         if (size++ >= threshold)
             resize(2 * table.length);
     }

Les entrées de la table de la loi comme une liste chaînée. Lorsque vous placez une nouvelle entrée dans le même seau, qu'il ajoute à la liste liée.

OriginalL'auteur Chip Uni

Je contribuerait qu'une collision est pas le même que l'insertion d'une clé identique. Les Collisions se produisent lorsque les clés de hachage à la même valeur. Il est entendu que toute personne qui implémente l'interface de la Carte doit être équipé pour gérer les collisions. Ainsi, la réponse à votre question est oui, HashMap en Java sécu gérer les collisions.

Toutefois, si la même clé est insérée, puis la Valeur précédente associée à exactement la même clé sera mis à jour et remplacé. Ce n'est pas considéré comme une collision en soi, mais un lien direct casser de ce qui existe déjà.

OriginalL'auteur kodjeff1