[Java] Map # merge est difficile à comprendre.

Alors que maintenant

Même si Java 9 est sorti l'autre jour, j'ai osé commencer à étudier Java 8 à ce moment-là. Le retard au tour est également bon, mais les nouvelles fonctionnalités de Java 8 sont encore trop belles et impressionnées. Vous pouvez trouver un certain nombre d'articles faciles à comprendre sur les nouvelles fonctionnalités de Java 8 par google, donc je leur laisserai toute l'explication, mais ici je n'ai pas compris et il n'y a pas d'article qui explique trop en détail Map # merge Notez le mouvement de.

Map#merge

Dans Java 7 et Java 8, le processus "écraser la valeur par" CCC "si la clé" key1 "existe dans la carte et ajouter la valeur" BBB "comme nouvelle clé si elle n'existe pas" est exécuté. Comparons comment écrire.

Jusqu'à Java7 ("key1"Existe)

Map<String, String> map = new HashMap<String, String>();
map.put("key1", "AAA");

System.out.println(map);

if (map.containsKey("key1")) {
	map.put("key1", "CCC");
} else {
	map.put("key1", "BBB");
}

System.out.println(map);

Résultat d'exécution

{key1=AAA}
{key1=CCC}

Jusqu'à Java7 ("key1"N'existe pas)

Map<String, String> map = new HashMap<String, String>();

System.out.println(map);

if (map.containsKey("key1")) {
	map.put("key1", "CCC");
} else {
	map.put("key1", "BBB");
}

System.out.println(map);

Résultat d'exécution

{}
{key1=BBB}

Si vous essayez d'utiliser Map # merge ajoutée dans Java 8, ce sera comme suit. Si la clé ("key1") spécifiée dans le premier argument n'existe pas dans Map, la valeur du deuxième argument ("BBB") est placée par cette clé ("key1"), et si la clé existe, le troisième argument La fonction de remappage de est exécutée.

Java8（"key1"Existe)

Map<String, String> map = new HashMap<String, String>();
map.put("key1", "AAA");

System.out.println(map);

map.merge("key1", "BBB", 
	(v1, v2) -> {
		return "CCC";
	});

System.out.println(map);

Résultat d'exécution

{key1=AAA}
{key1=CCC}

Java8（"key1"N'existe pas)

Map<String, String> map = new HashMap<String, String>();

System.out.println(map);

map.merge("key1", "BBB", 
	(v1, v2) -> {
		return "CCC";
	});

System.out.println(map);

Résultat d'exécution

{}
{key1=BBB}

Quels sont les deux arguments?

Je me demandais quels sont les deux arguments passés à la fonction de remappage qui est appelée lorsque la clé existe dans la carte? à propos de ça. Les "v1" et "v2" dans l'exemple ci-dessus ne sont pas du tout utilisés.

Donc, pour le moment, sortons ce qui est passé.

Java8（"key1"Existe)

Map<String, String> map = new HashMap<String, String>();
map.put("key1", "AAA");

System.out.println(map);

map.merge("key1", "BBB", 
	(v1, v2) -> {
		Sytem.out.printf("v1:%s, v2:%s\n", v1, v2);
		return "CCC";
	});

System.out.println(map);

Résultat d'exécution

{key1=AAA}
v1:AAA, v2:BBB
{key1=CCC}

est devenu. Autrement dit, lorsque la clé "key1" existe, la valeur qui existe déjà ("AAA" dans l'exemple) et la valeur à définir si elle n'existe pas ("BBB" dans l'exemple) sont passées à cette fonction. Cependant, même si la "valeur à définir lorsque la clé n'existe pas" est passée en argument, je pense qu'elle est rarement utilisée lorsque la clé existe. La transmission de cette valeur peut être utile à des fins limitées, comme lors de la concaténation de cette valeur avec une valeur existante (chaîne). Dans le cas d'un simple remplacement comme celui-ci, l'écriture vers Java 7 est plutôt plus facile à comprendre.

Au fait, une concaténation simple peut être réalisée en spécifiant String :: concat dans la fonction de remappage comme indiqué ci-dessous.

Une connexion simple est OK avec ça!

Map<String, String> map = new HashMap<String, String>();

map.put("key1", "AAA");

System.out.println(map);

map.merge("key1", "BBB", String::concat);

System.out.println(map);

Résultat d'exécution

{key1=AAA}
{key1=AAABBB}

Pourquoi avez-vous regardé la fusion

Cette fois, j'ai étudié en détail le comportement de Map # merge. Ce qui est nouveau dans Java 8, c'est que l'opération de Map <String, List <String >> ajoute une valeur à List lorsqu'une clé existe. Je me suis demandé si je pouvais le rendre plus intelligent. Plus précisément, je l'ai implémenté comme suit.

Java8

Map<String, List<String>> map = new HashMap<String, List<String>>();

map.put("key1", new ArrayList<String>(Arrays.asList("AAA")));
System.out.println(map);

//Si key1 existe"CCC"À lister, s'il n'existe pas"BBB"Ajouter une liste avec l'élément
map.merge("key1", new ArrayList<String>(Arrays.asList("BBB")),
		(v1, v2) -> {
	v1.add("CCC");
	return v1;
});

System.out.println(map);

Résultat d'exécution

{key1=[AAA]}
{key1=[AAA, CCC]}

Avant Java 7, cela ressemble à ce qui suit.

Jusqu'à Java 7

Map<String, List<String>> map = new HashMap<String, List<String>>();

map.put("key1", new ArrayList<String>(Arrays.asList("AAA")));
System.out.println(map);

if (map.containsKey("key1")) {
	//Si key1 existe"CCC"Lister
	map.get("key1").add("CCC");
} else {
	//Si key1 n'existe pas"BBB"Ajouter une liste avec l'élément
	map.put("key1", new ArrayList<String>(Arrays.asList("BBB")));
}

System.out.println(map);

Résultat d'exécution

{key1=[AAA]}
{key1=[AAA, CCC]}

Dans cet exemple, ni l'un ni l'autre n'est très différent (; ^ ω ^) Cependant, avec Java 8, je me suis senti rafraîchi car je pouvais éliminer l'instruction if-else.

Donc, Map # merge est-il utile lorsque vous souhaitez apporter des modifications à des valeurs qui existent déjà dans Map ou lorsque vous souhaitez rendre votre code plus propre? Ce dernier est également la raison d'utiliser des expressions lambda et des flux, pas seulement cette méthode.

prime

En passant, si vous retournez null dans la fonction de remappage, la clé sera supprimée.

Essayez d'effacer la clé

Map<String, String> map = new HashMap<String, String>();
map.put("key1", "AAA");

System.out.println(map);

map.merge("key1", "BBB", 
	(v1, v2) -> {
		return null;
	});

System.out.println(map);

Résultat d'exécution

{key1=AAA}
{}

Jouons un peu plus avec Java 8 ^^