IdentityHashMap Classe

Définition

[Android.Runtime.Register("java/util/IdentityHashMap", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "K", "V" })]
public class IdentityHashMap : Java.Util.AbstractMap, IDisposable, Java.IO.ISerializable, Java.Lang.ICloneable

[<Android.Runtime.Register("java/util/IdentityHashMap", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "K", "V" })>]
type IdentityHashMap = class
    inherit AbstractMap
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface ICloneable
    interface IMap

Héritage

Object

JavaObject

Object

AbstractMap

IdentityHashMap

Attributs

RegisterAttribute JavaTypeParametersAttribute

Implémente

IJavaObject IJavaPeerable ISerializable ICloneable IMap IDisposable

Remarques

Cette classe implémente l’interface avec une table de hachage, à l’aide de l’égalité des références à la place de l’égalité d’objet lors de la Map comparaison des clés (et des valeurs). En d’autres termes, dans un IdentityHashMap, deux clés k1 et k2 sont considérées comme égales si et seulement si (k1==k2). (Dans les implémentations normales Map (comme HashMap) deux clés k1 et k2 sont considérées comme égales si et seulement si (k1==null ? k2==null : k1.equals(k2)).)

<b>Cette classe n’est pas une implémentation à usage Map général ! Bien que cette classe implémente l’interface Map , elle enfreint intentionnellement le Map's contrat général, ce qui impose l’utilisation de la méthode lors de la equals comparaison d’objets. Cette classe est conçue pour être utilisée uniquement dans les rares cas où la sémantique d’égalité des références est requise.</b>

Les collections d’affichages de cette carte ont également une sémantique d’égalité des références pour leurs éléments. Pour plus d’informations, consultez les méthodes et keySet() keySetvalues() values les entrySet() entrySetméthodes.

Une utilisation classique de cette classe est la conservation de transformations de graphiques d’objets de topologie, telles que la sérialisation ou la copie approfondie. Pour effectuer une telle transformation, un programme doit conserver une « table de nœuds » qui effectue le suivi de toutes les références d’objet qui ont déjà été traitées. La table de nœuds ne doit pas correspondre à des objets distincts, même s’ils sont égaux. Une autre utilisation classique de cette classe consiste à conserver des objets proxy. Par exemple, une installation de débogage peut souhaiter conserver un objet proxy pour chaque objet du programme en cours de débogage.

Cette classe fournit toutes les opérations de mappage facultatives et autorise les null valeurs et la null clé. Cette classe ne garantit pas l’ordre de la carte ; en particulier, elle ne garantit pas que l’ordre restera constant au fil du temps.

Cette classe fournit des performances à temps constant pour les opérations de base (get et put), en supposant que la fonction de hachage d’identité système (System#identityHashCode(Object)) disperse correctement les éléments entre les compartiments.

Cette classe a un paramètre de réglage (qui affecte les performances, mais pas la sémantique) : taille maximale attendue. Ce paramètre est le nombre maximal de mappages clé-valeur que la carte doit contenir. En interne, ce paramètre est utilisé pour déterminer le nombre de compartiments qui composent initialement la table de hachage. La relation précise entre la taille maximale attendue et le nombre de compartiments non spécifiés.

Si la taille de la carte (le nombre de mappages clé-valeur) dépasse suffisamment la taille maximale attendue, le nombre de compartiments est augmenté. L’augmentation du nombre de compartiments (« rehashing ») peut être assez coûteuse, ce qui permet de créer des cartes de hachage d’identité avec une taille maximale suffisamment importante attendue. En revanche, l’itération sur les vues de collection nécessite du temps proportionnel au nombre de compartiments dans la table de hachage, de sorte qu’elle ne paie pas pour définir la taille maximale attendue trop élevée si vous êtes particulièrement préoccupé par les performances d’itération ou l’utilisation de la mémoire.

< >notez que cette implémentation n’est pas synchronisée.</strong> Si plusieurs threads accèdent simultanément à une carte de hachage d’identité et qu’au moins un des threads modifie la carte structurellement, il doit être synchronisé en externe. (Une modification structurelle est toute opération qui ajoute ou supprime un ou plusieurs mappages ; il suffit de modifier la valeur associée à une clé qu’une instance contient déjà n’est pas une modification structurelle.) Cette opération est généralement effectuée en synchronisant sur un objet qui encapsule naturellement la carte.

Si aucun objet de ce type n’existe, la carte doit être « encapsulée » à l’aide de la Collections#synchronizedMap Collections.synchronizedMap méthode. Cela est le mieux fait au moment de la création, pour empêcher l’accès non synchronisé accidentel à la carte :

Map m = Collections.synchronizedMap(new IdentityHashMap(...));

Les itérateurs retournés par la iterator méthode des collections retournées par toutes les « méthodes de vue de collection » de cette classe échouent : si la carte est modifiée structurellement à tout moment après la création de l’itérateur, à tout moment, à l’exception de la méthode de remove l’itérateur, l’itérateur lève un ConcurrentModificationException. Par conséquent, face à la modification simultanée, l’itérateur échoue rapidement et correctement, plutôt que de risquer un comportement arbitraire et non déterministe à un moment indéterminé à l’avenir.

Notez que le comportement de défaillance rapide d’un itérateur ne peut pas être garanti, en général, impossible d’apporter des garanties difficiles en présence d’une modification simultanée non synchronisée. Les itérateurs à vitesse d’échec lèvent ConcurrentModificationException un meilleur effort. Par conséquent, il serait incorrect d’écrire un programme qui dépendait de cette exception pour son exactitude : les itérateurs à vitesse d’échec doivent être utilisés uniquement pour détecter les bogues.

Cette classe est membre de l’infrastructure de collections Java.

Ajouté dans la version 1.4.

Java documentation pour java.util.IdentityHashMap.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.