ConcurrentHashMap JDK 8 lors de l'utilisation de computeIfPresent

La nouvelle version de la Simultanées de Hachage Carte de jdk 8 dispose de deux nouvelles Méthodes.

computeIfAbsent

computeIfPresent

putIfAbsent - Vieille méthode

Je comprends les cas d'utilisation de putIfAbsent et computeIfAbsent.
Mais je ne suis pas sûr de l'scénarios lorsque je vais utiliser computeIfPresent.
Pourquoi ai-je besoin putIfAbsent si j'ai computeIfPresent maintenant.
putIfAbsent ne créer au moins une instance de la valeur.

Est la raison en est le seul à avoir l'arrière de compatibilité?

OriginalL'auteur veritas | 2014-07-21

29

Comme mentionné dans la réponse à faire: des Méthodes de toujours être conservé pour la compatibilité ascendante, même si il y a de nouveaux, plus "puissant" méthodes introduites.

Concernant le cas d'utilisation de computeIfPresent: Il peut être difficile de trouver un exemple qui est assez petit pour ne pas paraître artificiel et encore convaincre. En général, l'intention de cette méthode est à mise à jour une valeur existante dans n'importe quelle forme.

Un exemple pourrait être un (contraint) nombre de mots: Pour un ensemble donné de mots, on stocke un décompte de 0 dans la carte. Ensuite, une séquence de mots est traitée: à Chaque fois qu'on trouve un mot à partir de l'ensemble initial, son nombre est augmenté de 1:
```
import java.util.LinkedHashMap;
import java.util.Map;

public class ComputeIfPresentExample 
{
    public static void main(String[] args) 
    {
        Map<String, Integer> wordCounts = new LinkedHashMap<String, Integer>();

        String s = 
            "Lorem ipsum dolor sit amet consetetur iam nonumy sadipscing " + 
            "elitr, sed diam nonumy eirmod tempor invidunt ut erat sed " + 
            "labore et dolore magna dolor sit amet aliquyam erat sed diam";

        wordCounts.put("sed", 0);
        wordCounts.put("erat", 0);

        for (String t : s.split(" "))
        {
            wordCounts.computeIfPresent(t, (k,v) -> v+1);
        }
        System.out.println(wordCounts);
    }
}
```
(Bien sûr, ce genre de choses pourrait être résolu autrement, mais c'est plutôt une des tâches les plus fréquentes dans l'une ou l'autre forme, et de la nouvelle méthode permet une assez concise et élégante solution)

OriginalL'auteur Marco13

Une commune de cas d'utilisation sont cartes avec collections, comme

Map<String, Collection<String>> strings = new HashMap<>();

computeIfAbsent et computeIfPresent sont très pratique des opérations d'ajout et de suppression d'éléments/de la collection. Voici un exemple que les groupes des chaînes par leur premier caractère. Notez que les clés et les collections sont créées en cas de besoin et à la nettoyer quand la collection est vide:

void addString(String a) {
    String index = a.substring(0, 1);
    strings.computeIfAbsent(index, ign -> new HashSet<>()).add(a);
}

void removeString(String a) {
    String index = a.substring(0, 1);
    strings.computeIfPresent(index, (k, c) -> {
        c.remove(a);
        return c.isEmpty() ? null : c;
    });
}

Ce qui est extrêmement puissant dans le multithreading environnements ConcurrentMaps effectuer ces opérations de manière atomique.

Exemple:

                         //{}
addString("a1");         //{a=[a1]}      <-- collection dynamically created
addString("a2");         //{a=[a1, a2]}
removeString("a1");      //{a=[a2]}
removeString("a2");      //{}            <-- both key and collection removed

Certains de sucre supplémentaire:

void addString(String a) {
    String index = a.substring(0, 1);
    strings.computeIfAbsent(index, ign -> new HashSet<>()).add(a);
}

void removeString(String a) {
    String index = a.substring(0, 1);
    strings.computeIfPresent(index, (i, c) -> c.remove(a) && c.isEmpty() ? null : c);
}

OriginalL'auteur steffen

0

Le JDK presque jamais de pauses rétro-compatibilité. Parce qu'alors vous ne pouvez pas facilement de port ou d'exécuter des logiciels à partir d'une version antérieure à la dernière version.

Vous pouvez exécuter le logiciel compilé avec une version plus ancienne de la bibliothèque avec n'importe quelle version (ce qui signifie que les utilisateurs ont JRE) qui n'a toujours ces fonctions.

ohh je sais que c'est la rétro compatibilité. ma question est-ce la seule raison? et également en cas d'utilisation de computeIfPresent.

OriginalL'auteur Thirler

J'ai utilisé computeIfPresent comme un null-sûr moyen de récupérer les minuscules valeurs à partir d'une carte de chaînes.

String s = fields.computeIfPresent("foo", (k,v) -> v.toLowerCase())

Avant computeIfPresent était disponible, je serais obligé de le faire:

String s = map.get("foo");
if (s != null) {
    s = s.toLowerCase();
}

Ou ceci:

String s = map.containsKey("foo") ? map.get("foo").toLowerCase() : null;

OriginalL'auteur austin327

Vous devez vous connecter pour publier un commentaire.