Différence entre les méthodes Map.put et Map.putAll?

Map.putAll est équivalent à celui de l'appel d' Map.put(k, v) sur la carte une fois pour chaque mappage à partir de la clé k à la valeur v dans la carte spécifiée. Donc, avec l'aspect fonctionnel, les deux sont les mêmes.

Donc, je suis curieux de savoir quelles sont les différences et quand utiliser un?

source d'informationauteur GuruKulki

9

.. Dépend.

put et putAll sont les méthodes d'interface, de sorte chaque réel de la mise en œuvre de cette interface permettra de garantir que les put méthode met une seule paire clé/valeur dans la carte pr putAll va mettre toutes les paires clé/valeur de la source.

Mais c'est à l'implémenteur comment faire et quoi faire en plus (en interne).

Sûr, une implémentation simple serait d'appeler put pour chaque entrée de la carte source, mais peut-être que quelqu'un invente une autre méthode pour atteindre l'objectif. Ou putAll va faire autre carte interne des trucs avant/après/pendant la saisie ajoutant des paires.

Ma règle de base: si vous devez mettre toutes les paires clé/valeur à partir d'une carte à l'autre, puis s'appuyer sur l'intelligence du réalisateur et de l'utilisation de la putAll méthode. Il y a toujours une bonne chance qu'il fournit une meilleure performance que d'appeler put pour toutes les paires manuellement.
5

Comme indiqué dans les docs:

Carte.mettre

Associe la valeur spécifiée avec
la clé spécifiée dans cette carte
(facultatif). Si la carte
contenait auparavant une cartographie de la
la clé, l'ancienne valeur est remplacée par la
valeur spécifiée. (Une carte m est dit
contient une cartographie d'une clé k si et
seulement si m.containsKey(k) serait de retour
vrai.)

Vous permet de mettre une seule paire clé-valeur dans la carte.

Carte.putAll

Les Copies de tous les mappages de la
carte spécifiée pour cette carte (en option
l'opération). L'effet de cet appel est
équivalent à celui de l'appel put(k,
v) sur cette carte une fois pour chaque cartographie
à partir de la clé k à la valeur v dans le
carte. Le comportement de cette opération est
undefined si la carte spécifiée est
modifiée alors que l'opération est en
progrès.

mettre toutes les données à partir d'une carte à une autre carte.

à utiliser?

Si vous souhaitez copier des données complètes à partir d'une carte à l'autre, vous pouvez utiliser map.putAll d'autre, vous pouvez simplement ajouter une paire clé-valeur à l'aide de map.put.

Carte.putAll est équivalent à celui de
l'appel de la Carte.put(k, v) sur la carte une fois
pour chaque configuration de la clé k à la valeur v
dans la carte spécifiée. Donc, avec
l'aspect fonctionnel les deux sont les mêmes.

Pas lorsque vous mettez en place la carte dans hasmap puis copier les données d'une carte à l'autre en utilisant les mettre(k,v) demandera plus d'efforts et vous pouvez dire plus de codage à l'aide de putAll(m), on peut copier la carte avec une seule ligne de code.
5

Utilisation putAll(Map) lorsque vous avez une Carte de plusieurs valeurs que vous voulez ajouter à votre Carte, et l'utilisation put(K,V) lorsque vous avez un ou un couple de valeurs que vous voulez ajouter à votre Carte.

putAll(Map) dans la plupart des implémentations appelle juste put(K,V) dans une boucle, lire la source.
4

Depuis la Carte est juste une interface, sans mise en œuvre, il ne peut y avoir aucune différence entre un putAll et répétée de mettre d'autres que de la différence fonctionnelle, c'est à dire, aucun. Si vous regardez certaines implémentations de la Carte (par exemple, HashMap) il y a peut être un problème de performance. Un putAll doit être au moins aussi efficace qu'un répétée mettre pour toute mise en œuvre raisonnable, mais il peut être exactement le même.
2

La différence la plus évidente est la synchronisation des collections.

Pour un synchornized carte, putAll va ajouter toutes les entrées en une seule opération. Si vous avez deux threads tentent de putAll les mêmes clés avec des valeurs différentes, vous obtenez seulement un ensemble complet de valeurs. c'est à dire soit à partir de la première ou de la deuxième thread, mais pas une combinaison des deux.

Si vous utilisez put() à plusieurs reprises dans deux threads, vous pouvez obtenir n'importe quelle combinaison de valeurs étant retenue qui ne peut être une combinaison valide.

J'ai vu/mise en œuvre les opérations transactionnelles pour les mettre() et putAll(). Lorsque putAll est transactionnelle, toutes ou aucune clé/valeurs seront ajoutées. par exemple, si une clé ou une valeur ne peut pas être ajouté pour une raison quelconque. Si vous utilisez put (), seule la indiviudal clé/valeur (et, éventuellement, de ne pas ajoutée) sera arrêté, la réalisation d'une potentiellement mise à jour incomplète.

putAll( ) la méthode

Copies all the elements from a specified map to the current Map object.

put( ) la méthode

Adds an element at a specific key entry to a Map object.

Je vois un énorme avantage en termes de performances lors de l'utilisation de putAll au lieu de mettre.
Voir l'exemple de programme ci-dessous:

public class Exempledetest {

public static void main(final String[] args) {

    final Map<String, String> testMap = new HashMap<>();
    final Map<String, String> testMap2 = new HashMap<>();

    final LocalDateTime startTestTime = LocalDateTime.now();
    for(int i=0; i < 1000000; i++) {
        testMap.put(i+"", i+"");
    }
    final LocalDateTime endTestTime = LocalDateTime.now();
    System.out.println("<<<<<<<<<Time for put>>>>>>>>>>>");
    System.out.println(ChronoUnit.MILLIS.between(startTestTime, endTestTime));

    final LocalDateTime startTestTime1 = LocalDateTime.now();
    testMap2.putAll(testMap);
    final LocalDateTime endTestTime1 = LocalDateTime.now();
    System.out.println("<<<<<<<<<Time for put all>>>>>>>>>>>");
    System.out.println(ChronoUnit.MILLIS.between(startTestTime1, endTestTime1));
}

}

Cela renvoie (en Millisecondes):

<<<<<<<<<Time for put>>>>>>>>>>>
1934
<<<<<<<<<Time for put all>>>>>>>>>>>
116

Conclusion:
putAll() est certainement plus performant que de le mettre() avec les désistements.
1. Ce résultat est sur ma machine (j'.e dépend de la configuration de la machine). Mais vous pouvez encore voir une grande différence.
2. Comme dessus décrite ci-dessus la Carte est une interface, de sorte que la performance dépendra de la mise en œuvre, que j'ai considéré comme HashMap comme il est largement utilisé.
Donc, si la performance est une contrainte, vous pouvez préférer putAll() pour HashMap atleast.

0

Map.put(Object key, Object value) vous permet d'ajouter une entrée unique dans le tout Map.putAll(Map t) ajoute toutes les entrées contenues dans la Carte t pour la Carte spécifiée. putAll() est utile lors de la combinaison de deux Cartes.

Vous devez vous connecter pour publier un commentaire.