Pause café #132. Jetons un coup d'œil à ZGC, le dernier garbage collector du JDK. Quelle est la différence entre HashMap, LinkedHashMap et TreeMap en Java

Présentation de ZGC, le dernier garbage collector du JDK

Source : Inside Java ZGC ou Z Garbage Collector est le garbage collector le plus moderne du JDK. Il est apparu à l'origine dans le JDK 11 en tant que fonctionnalité expérimentale. ZGC est devenu une fonctionnalité de production dans JDK 15 après l'approbation de l'amélioration JEP 377. Dans cet article, nous examinerons les objectifs et l'avenir de ZGC.

Examen du ZGC

ZGC est conçu pour être un garbage collector évolutif et à faible latence. Le temps de pause maximum pendant le fonctionnement du ZGC dépasse rarement les microsecondes 250. Oui, exactement des microsecondes, avec un temps de pause moyen de plusieurs dizaines de microsecondes. ZGC est hautement évolutif, avec des tailles de tas minimales allant de 8 Mo à 16 To. Il est important de noter que le temps de pause n’augmente pas avec la taille du tas. Ainsi, même avec un tas de plusieurs téraoctets, le temps de pause sera toujours mesuré en microsecondes. Bien que ZGC offre une faible latence et une évolutivité élevée, son coût est d'environ 10 % inférieur à celui du G1. La réduction exacte du débit dépend de la conception de l'application, de l'architecture du système et des besoins de l'entreprise.

Utiliser ZGC

Étant donné que G1 est le garbage collector par défaut à partir du JDK 9, vous devrez définir l'indicateur VM -XX:+UseZGC pour utiliser ZGC. Lors de l'utilisation de ZGC, la configuration la plus importante consiste à définir la taille maximale du tas, -Xmx. La taille du tas doit être suffisamment grande pour gérer le live-set de votre application. Il doit également disposer d'une réserve supplémentaire pour effectuer le ramassage des ordures. Plus il y a d’espace disponible sur le tas, moins le garbage collection sera nécessaire. Mais notez que cela doit être équilibré avec l'utilisation de la mémoire.

Développement ultérieur de ZGC

Depuis sa sortie en tant que fonctionnalité de production dans JDK 15, ZGC a continué à être activement développé. Avec la sortie du JDK 16, il a introduit le traitement parallèle de la pile de threads (JEP 376) et le JDK 18 a ajouté la déduplication des lignes en tant que fonctionnalité supplémentaire. À l'avenir, il est prévu que ZGC devienne multigénérationnelle, même si le calendrier précis pour la mise en œuvre de cette amélioration n'a pas encore été établi.

Plus d'informations sur ZDC

• JEP 377
• JEP 376
• ZGC - L'avenir du garbage collection à faible latence est là
• Documentation officielle ZGC

Quelle est la différence entre HashMap, LinkedHashMap et TreeMap en Java

Source : Rrtutors Si vous souhaitez stocker des paires clé-valeur dans un programme Java, les collections Java offrent de nombreuses options pour cela en fonction de vos besoins. Ceux-ci incluent LinkedHashmap , HashMap et TreeMap . Les principales différences entre ces trois classes résident dans leur implémentation interne et leur application spécifique dans certains cas.

Différences entre HashMap, LinkedHashMap et TreeMap en Java

Voici les principales différences entre les trois classes mentionnées en fonction de l'implémentation, du classement, du tri et de la prise en charge des clés et valeurs nulles.

Mise en œuvre

HashMap et LinkedHashMap implémentent l' interface Map , tandis que TreeMap implémente les interfaces Map , NavigableMap et vSortedMap. LinkedHashMap est implémenté sous forme de compartiment de liste à double lien, HashMap est implémenté sous forme de table de hachage et TreeMap est implémenté sous forme d'arborescence.

Commande et tri

• HashMap ne donne aucune garantie concernant l'ordre des itérations. Cependant, cela peut changer complètement lorsque de nouveaux éléments sont ajoutés.

• LinkedHashMap itérera dans l'ordre dans lequel les entrées ont été placées dans la carte.

• TreeMap itère selon « l'ordre naturel » des clés selon leur méthode compareTo() (ou Comparator externe). Il implémente également l' interface SortedMap , qui contient des méthodes qui dépendent de l'ordre de tri.

Clés et valeurs nulles

HashMaps et LinkedHashMap prennent en charge les valeurs nulles ainsi que les valeurs clés, tandis que TreeMaps ne prend pas en charge les valeurs nulles car ils prennent en charge les types d'éléments naturels. Pour un exemple visuel, créons un HashMap , LinkedHashMap et TreeMap .

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.TreeMap;

public class HashMap_LinkedHashMap_TreeMap {

            public static void main(String[] args) {

                  Map Treemapu = new TreeMap();

                  Treemapu.put("First", "Java");

                  Treemapu.put("Second", "Python");

                  System.out.println("TreeMap values are: \n" + Treemapu);

                  Map Hashimapu = new HashMap();

                  Hashimapu.put("First", "Java");

                  Hashimapu.put("Second", "Python");

                  System.out.println("HashMap Values are: \n" + Hashimapu);

                  Map LinkedHashiMapu = new LinkedHashMap();

                  LinkedHashiMapu.put("First", "Java");

                  LinkedHashiMapu.put("Second", "Python");

                  System.out.println("LinkedHashMap values are: \n" + LinkedHashiMapu);

            }

}

En sortie on obtient : Ainsi, les trois classes représentent un mappage de clés uniques vers des valeurs et implémentent donc l' interface Map .

• HashMap est une carte basée sur le hachage de clés. Il prend en charge les opérations get/put O(1). Les clés doivent avoir des implémentations hashCode() et equals() cohérentes .

• Un LinkedHashMap est très similaire à un HashMap , mais il a un ordre dans lequel les éléments sont ajoutés (ou accessibles), donc l'ordre d'itération est le même que l'ordre de placement (ou l'ordre d'accès, en fonction des paramètres de conception).

• TreeMap est un mappage arborescent. Ses opérations put/get prennent un temps O(log n). Cela nécessite que les éléments disposent d'une sorte de mécanisme de comparaison, soit avec une comparaison, soit avec un comparateur. L'ordre des itérations est déterminé par ce mécanisme.