Structures de données courantes en Java

Java fournit un riche ensemble de structures de données pour gérer diverses tâches de programmation, notamment les types de données de base, les cadres de collecte et les structures de données personnalisées. Voici quelques structures de données Java courantes :

Types de données de base : les types de données de base de Java incluent des entiers (int, byte, short, long), des nombres à virgule flottante (float, double), des caractères (char), des booléens (booléen), etc.
Tableau : Un tableau est une collection d’éléments du même type qui a une taille fixe. En Java, la taille d'un tableau est déterminée lors de sa création et ne peut pas être modifiée.
Framework de collection : Java fournit un ensemble de frameworks de collection pour stocker et manipuler des objets. Ces cadres de collecte comprennent :
- Interface de liste : une collection ordonnée pouvant contenir des éléments répétés. Les classes d'implémentation courantes incluent ArrayList et LinkedList.
- Définir l’interface : une collection qui n’autorise pas les éléments en double. Les classes d'implémentation courantes incluent HashSet, LinkedHashSet et TreeSet.
- Interface cartographique : une collection de paires clé-valeur, chaque clé correspond à une valeur unique. Les classes d'implémentation courantes incluent HashMap, LinkedHashMap et TreeMap.
- Interface de file d'attente : file d'attente, prend en charge l'insertion d'éléments à une extrémité de la file d'attente et la suppression d'éléments à l'autre extrémité. Les classes d'implémentation courantes incluent LinkedList et PriorityQueue.
Stack : Stack est une structure de données spéciale qui suit le principe du dernier entré, premier sorti (LIFO). Une pile peut être implémentée à l'aide de la classe Stack de Java.
LinkedList : une liste chaînée est une structure de données linéaire contenant des nœuds, chaque nœud pointant vers le nœud suivant. La classe LinkedList de Java implémente une liste doublement chaînée.
Arbre : un arbre est une structure de données hiérarchique comprenant des nœuds racine, des nœuds enfants et des nœuds feuilles. Java fournit TreeSet et TreeMap pour implémenter des structures arborescentes.
Graphique : un graphique est une structure de données complexe composée de nœuds et d'arêtes utilisées pour représenter les relations entre les entités. En Java, vous pouvez utiliser des structures de données personnalisées pour représenter des graphiques, ou vous pouvez utiliser des bibliothèques d'algorithmes graphiques.
Heap : Heap est une structure arborescente spéciale généralement utilisée pour implémenter des files d'attente prioritaires. La classe PriorityQueue de Java utilise un tas pour maintenir l'ordre des éléments.
HashTable : une table de hachage est une structure de données qui utilise une fonction de hachage pour mapper les clés aux valeurs. Les classes HashMap et Hashtable de Java sont toutes deux des implémentations de tables de hachage.
Structure de données personnalisée : en fonction de besoins spécifiques, vous pouvez également créer des structures de données personnalisées, telles que des piles, des files d'attente, des listes chaînées, des arborescences, etc.

Ces structures de données fournissent un large éventail d'applications en Java, et des structures de données appropriées peuvent être sélectionnées pour mettre en œuvre des algorithmes et des tâches de traitement de données en fonction de la nature du problème. Le framework de collecte de Java est particulièrement puissant et permet la mise en œuvre de diverses structures de données pour répondre aux besoins de différents scénarios.

introduire

1、Tableau

En Java, un tableau est une structure de données utilisée pour stocker des éléments du même type de données. Les tableaux ont une taille fixe et une fois créés, leur taille ne peut pas être modifiée. Chaque élément du tableau est accessible par index, en commençant par 0 et en augmentant dans l'ordre.

Exemple

Déclarez et créez des tableaux :

dataType[] arrayName; // 声明数组
arrayName = new dataType[arraySize]; // 创建数组

// 或者
int[] numbers; // 声明整数数组
numbers = new int[5]; // 创建包含5个整数元素的数组

// 或者
int[] numbers = new int[5]; // 声明并创建整数数组

Initialisez le tableau :

int[] numbers = {1, 2, 3, 4, 5}; // 初始化整数数组
String[] names = {"Alice", "Bob", "Charlie"}; // 初始化字符串数组

Accès aux éléments du tableau : utilisez l'indexation pour accéder aux éléments du tableau. L'indice commence à 0 et augmente séquentiellement.

int firstNumber = numbers[0]; // 获取第一个元素（索引为0）
String secondName = names[1]; // 获取第二个元素（索引为1）

Longueur du tableau : utilisez lengthla propriété pour obtenir la longueur d'un tableau.

int length = numbers.length; // 获取整数数组的长度（包含5个元素）

Tableaux multidimensionnels : Java prend en charge les tableaux multidimensionnels tels que les tableaux bidimensionnels (tableaux de tableaux).

int[][] matrix = {
   
   {1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 二维整数数组
int element = matrix[1][2]; // 访问二维数组中的元素

Traversée de tableau : vous pouvez utiliser des boucles pour parcourir les éléments d'un tableau.

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

Ou utilisez une forboucle améliorée (pour chaque boucle) :

for (int number : numbers) {
    System.out.println(number);
}

Un tableau est une structure de données courante en Java, utilisée pour stocker et manipuler un ensemble de données. Veuillez choisir d'utiliser des tableaux en fonction de besoins et de scénarios spécifiques. Si vous avez besoin d'une structure de données plus flexible, vous pouvez envisager d'utiliser des classes de collection (telles que ArrayList, LinkedList, etc.) au lieu de tableaux.

2、ArrayList

ArrayListIl s'agit d'une classe de collection couramment utilisée en Java. Elle fait partie du framework de collection Java et se trouve dans java.utille package. ArrayListFournit une implémentation de tableaux dynamiques, permettant le stockage et la gestion d'un ensemble d'objets. Contrairement aux tableaux ordinaires, ArrayListla taille d’un tableau peut être ajustée dynamiquement et s’étendre automatiquement pour accueillir davantage d’éléments.

Exemple

Déclarez et créez ArrayList :

import java.util.ArrayList;

// 声明一个整数类型的 ArrayList
ArrayList<Integer> numbers = new ArrayList<Integer>();

// 声明一个字符串类型的 ArrayList
ArrayList<String> names = new ArrayList<String>();

Ajouter des éléments :

addDes éléments peuvent être ajoutés à l'aide de la méthodeArrayList :

numbers.add(10);
numbers.add(20);
names.add("Alice");
names.add("Bob");

Obtenir des éléments :

Utilisez la méthode pour obtenir des éléments en getfonction de l'index :ArrayList

int firstNumber = numbers.get(0); // 获取第一个元素
String secondName = names.get(1); // 获取第二个元素

Modifier des éléments :

Utilisez setla méthode pour modifier ArrayListun élément en fonction de son index :

numbers.set(0, 30); // 将第一个元素修改为30
names.set(1, "Charlie"); // 将第二个元素修改为"Charlie"

Supprimer des éléments :

Utilisez la méthode pour supprimer des éléments en removefonction de l'index ou de l'objet :ArrayList

numbers.remove(0); // 删除第一个元素
names.remove("Alice"); // 删除指定元素

Obtenez la taille :

Utilisez sizela méthode pour obtenir ArrayListla taille (nombre d'éléments) de :

int size = numbers.size(); // 获取整数 ArrayList 的大小

Itérer sur les éléments :

Vous pouvez utiliser une boucle pour parcourir ArrayListles éléments de :

for (int i = 0; i < numbers.size(); i++) {
    int number = numbers.get(i);
    System.out.println(number);
}

for (String name : names) {
    System.out.println(name);
}

Jugement court :

Vous pouvez utiliser isEmptyla méthode pour vérifier ArrayListsi est vide :

boolean isEmpty = numbers.isEmpty(); // 检查整数 ArrayList 是否为空

ArrayListIl s'agit d'une structure de données flexible et couramment utilisée, adaptée aux situations où un ensemble d'éléments doit être géré de manière dynamique. Il convient de noter que comme ArrayListil est implémenté sur la base d'un tableau, l'insertion et la suppression d'éléments coûtent cher. Si vous devez effectuer des opérations d'insertion et de suppression fréquentes, vous devrez peut-être envisager d'autres classes de collection, telles que LinkedList.

3、LinkedList

LinkedListIl s'agit d'une structure de données de liste doublement chaînée en Java. Elle implémente Listles Dequeinterfaces et et fait partie du cadre de collection Java, situé dans java.utille package. Contrairement à ArrayList, LinkedListil n'est pas implémenté sur la base d'un tableau, mais organise les éléments via des liens entre les nœuds.

Structure de liste chaînée : LinkedList utilisez une structure de liste chaînée pour stocker des éléments. Chaque élément (nœud) contient un élément de données et deux pointeurs, pointant respectivement vers le nœud précédent et le nœud suivant, ce qui rend l'insertion et la suppression d'éléments dans la liste chaînée relativement faciles.

Liste doublement chaînée : LinkedList il s'agit d'une liste doublement chaînée, ce qui signifie que vous pouvez partir de n'importe quel nœud et parcourir la liste chaînée vers l'avant ou vers l'arrière, ce qui facilite l'exécution d'opérations avant et arrière dans la liste chaînée.

L'accès aléatoire est plus lent : contrairement à ArrayList, LinkedListl'accès aléatoire rapide n'est pas pris en charge. Pour accéder aux éléments d'une liste chaînée, vous devez généralement partir du nœud de tête (ou du nœud de queue) et parcourir la liste chaînée un par un, de sorte que la complexité temporelle de l'accès aléatoire est O(n).

Opérations d'insertion et de suppression : En raison de la structure de la liste chaînée, les opérations d'insertion et de suppression d'éléments LinkedListsont relativement efficaces dans . La complexité temporelle de l'insertion ou de la suppression d'un nœud dans une liste chaînée est O(1).

Exemple

import java.util.LinkedList;

// 创建一个 LinkedList
LinkedList<String> linkedList = new LinkedList<>();

// 向链表添加元素
linkedList.add("Alice");
linkedList.add("Bob");
linkedList.add("Charlie");

// 在指定位置插入元素
linkedList.add(1, "David");

// 访问元素
String first = linkedList.getFirst();
String last = linkedList.getLast();

// 删除元素
linkedList.remove(2); // 删除索引为2的元素

// 遍历链表
for (String name : linkedList) {
    System.out.println(name);
}

// 获取链表的大小
int size = linkedList.size();

En bref, LinkedListil s'agit d'une structure de données flexible, particulièrement adaptée aux scénarios nécessitant des opérations d'insertion et de suppression fréquentes. Cependant, si un grand nombre d'éléments à accès aléatoire sont requis, ArrayListcela peut être plus approprié en raison de LinkedListmauvaises performances d'accès aléatoire. En fonction du scénario d'application spécifique, il est important de choisir la structure de données appropriée.

4、HashSet

HashSetIl s'agit d'une classe de collection en Java, qui implémente Setl'interface, fait partie du framework de collection et se trouve java.utildans le package. HashSetIl est principalement utilisé pour stocker un ensemble d'éléments non répétitifs.Il ne garantit pas l'ordre des éléments et n'autorise pas les éléments répétés.

Éléments non répétitifs : HashSet les éléments stockés ne sont pas répétitifs. Si vous essayez d' HashSetajouter un élément existant à , l'opération d'ajout sera ignorée et ne provoquera pas d'éléments répétés.

Collection non ordonnée : HashSet l'ordre des éléments n'est pas garanti. L'ordre dans lequel les éléments HashSetsont stockés peut différer de l'ordre dans lequel ils ont été ajoutés.

Basé sur une table de hachage : HashSet une table de hachage est utilisée en interne pour stocker des éléments. Cela fait que les opérations d'ajout, de suppression et de recherche d'éléments ont généralement une complexité temporelle constante, c'est-à-dire O(1).

Prend en charge les éléments nuls : HashSet permet le stockage d'un nullélément, mais d'un seul, car les éléments en double ne sont pas autorisés dans la collection.

Exemple

import java.util.HashSet;
import java.util.Set;

// 创建一个 HashSet
Set<String> hashSet = new HashSet<>();

// 向 HashSet 添加元素
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Cherry");

// 判断元素是否存在
boolean containsBanana = hashSet.contains("Banana"); // 返回 true

// 删除元素
hashSet.remove("Cherry");

// 遍历 HashSet
for (String fruit : hashSet) {
    System.out.println(fruit);
}

// 获取 HashSet 的大小
int size = hashSet.size();

En bref, HashSetil s'agit d'une classe de collection couramment utilisée, adaptée aux situations où un ensemble d'éléments uniques doit être stocké. Il s’agit souvent du type de collection préféré en raison de ses opérations efficaces d’ajout, de suppression et de recherche. Si vous devez conserver l'ordre des éléments ou autoriser les éléments en double, envisagez d'utiliser d'autres types de collections tels que LinkedHashSetou TreeSet.

5、LinkedHashSet

LinkedHashSetIl s'agit d'une classe de collection en Java. C'est HashSetune variante et implémente Setl'interface et se trouve java.utildans le package. Contrairement à normal HashSet, LinkedHashSetune liste chaînée est utilisée en interne pour maintenir l'ordre des éléments, elle préserve donc l'ordre d'insertion des éléments.

Ensemble ordonné : LinkedHashSet L'ordre d'insertion des éléments est conservé, il s'agit donc d'un ensemble ordonné. Lorsque vous parcourez LinkedHashSet, les éléments sont dans le même ordre dans lequel ils ont été ajoutés à la collection.
Éléments non répétitifs : LinkedHashSet les éléments stockés ne sont pas répétitifs et les éléments répétés ne sont pas autorisés.
Basé sur des tables de hachage et des listes chaînées : LinkedHashSet en interne, une table de hachage est utilisée pour trouver rapidement des éléments et une liste chaînée est utilisée pour maintenir l'ordre des éléments. Cela fait que les opérations d'ajout, de suppression et de recherche d'éléments ont généralement une complexité temporelle constante, c'est-à-dire O(1).
Prend en charge les éléments nuls : LinkedHashSet permet le stockage d'un nullélément, mais d'un seul, car les éléments en double ne sont pas autorisés dans la collection.

Exemple

import java.util.LinkedHashSet;
import java.util.Set;

// 创建一个 LinkedHashSet
Set<String> linkedHashSet = new LinkedHashSet<>();

// 向 LinkedHashSet 添加元素
linkedHashSet.add("Apple");
linkedHashSet.add("Banana");
linkedHashSet.add("Cherry");

// 保留元素的插入顺序
// 遍历 LinkedHashSet 时，元素的顺序与添加顺序相同
for (String fruit : linkedHashSet) {
    System.out.println(fruit);
}

// 判断元素是否存在
boolean containsBanana = linkedHashSet.contains("Banana"); // 返回 true

// 删除元素
linkedHashSet.remove("Cherry");

// 获取 LinkedHashSet 的大小
int size = linkedHashSet.size();

En bref, LinkedHashSetc'est un ensemble ordonné qui préserve l'ordre d'insertion des éléments. LinkedHashSetUn bon choix si vous devez conserver l'ordre des éléments dans une collection et ne pas autoriser les éléments en double . Ses caractéristiques de performance HashSetsont similaires à celles des modèles ordinaires, mais sa nature ordonnée le rend adapté à des scénarios d'application spécifiques.

6、TreeSet

TreeSetIl s'agit d'une classe de collection en Java. Elle implémente NavigableSetl'interface et est SortedSetune implémentation de l'interface. Elle se trouve java.utildans le package. TreeSetIl s'agit d'un ensemble ordonné qui utilise la structure de données Red-Black Tree pour maintenir l'ordre des éléments et présente les caractéristiques suivantes :

Ensemble trié : TreeSet est un ensemble ordonné qui trie les éléments selon leur ordre naturel ou un comparateur spécifié. Par défaut, TreeSetl'ordre naturel des éléments est utilisé pour le tri.

Éléments non répétitifs : TreeSet les éléments stockés ne sont pas répétitifs et les éléments répétés ne sont pas autorisés.

Basé sur une arborescence rouge-noir : TreeSet utilise en interne la structure de données de l'arborescence rouge-noir pour stocker les éléments. Cette structure de données garantit une recherche, une insertion et une suppression rapides d'éléments, avec une complexité temporelle de O (log n).

Tri naturel ou personnalisé : les éléments peuvent être triés selon leur ordre naturel (si l'élément implémente Comparablel'interface) ou en fournissant un comparateur personnalisé ( ).Comparator

Ordre de parcours : lorsque vous parcourez TreeSet, les éléments seront itérés dans un ordre trié.

Les éléments nuls ne sont pas pris en charge : TreeSet le stockage des nulléléments n'est pas autorisé.

Exemple

import java.util.TreeSet;
import java.util.Set;

// 创建一个 TreeSet
Set<String> treeSet = new TreeSet<>();

// 向 TreeSet 添加元素
treeSet.add("Banana");
treeSet.add("Apple");
treeSet.add("Cherry");

// 遍历 TreeSet，按照排序顺序输出
for (String fruit : treeSet) {
    System.out.println(fruit);
}

// 判断元素是否存在
boolean containsBanana = treeSet.contains("Banana"); // 返回 true

// 删除元素
treeSet.remove("Cherry");

// 获取 TreeSet 的大小
int size = treeSet.size();

En bref, TreeSetc'est une collection ordonnée, adaptée aux situations où des éléments doivent être triés. Il dispose d'opérations d'insertion, de suppression et de recherche efficaces, mais équilibre l'arborescence rouge-noir pendant les opérations d'insertion et de suppression, de sorte que les performances des opérations d'insertion et de suppression sont légèrement inférieures HashSet. En fonction de vos exigences de tri et de vos besoins en performances, il est important de choisir le type de collecte approprié.

7、HashMap

HashMapIl s'agit d'une classe de collection en Java qui implémente Mapl'interface et est utilisée pour stocker des paires clé-valeur. HashMapUtiliser une clé comme index vous permet de rechercher et de récupérer rapidement la valeur associée à la clé. Voici HashMapquelques fonctionnalités et utilisations importantes de :

Stockage de paires clé-valeur : HashMap les données stockées sont une collection de paires clé-valeur. Chaque clé est unique et chaque clé est associée à une valeur.

Clés uniques : HashMap les clés sont uniques. Si vous essayez d'ajouter une clé existante, la nouvelle valeur écrasera la valeur d'origine.

Basé sur une table de hachage : HashMap implémenté en interne à l'aide d'une structure de données de table de hachage, ce qui fait que les opérations de recherche, d'insertion et de suppression ont généralement une complexité temporelle constante, c'est-à-dire O(1). Mais dans certains cas, les collisions de hachage peuvent entraîner une dégradation des performances.

Collection non ordonnée : HashMap l'ordre des éléments n'est pas garanti, c'est-à-dire que l'ordre dans lequel les éléments sont stockés peut être différent de l'ordre dans lequel ils ont été ajoutés. Pensez à l'utiliser si vous avez besoin de paires clé-valeur ordonnées LinkedHashMap.

Autoriser les clés et valeurs nulles : HashMap permet de stocker une nullclé et plusieurs nullvaleurs.

Thread-unsafe : HashMap il n'est pas thread-safe. Si plusieurs threads accèdent et modifient la même HashMapinstance en même temps, cela peut entraîner des problèmes d'incohérence des données et de concurrence. Vous pouvez utiliser Collections.synchronizedMap()la méthode ou ConcurrentHashMappour obtenir une version thread-safe.

Exemple

import java.util.HashMap;
import java.util.Map;

// 创建一个 HashMap
Map<String, Integer> hashMap = new HashMap<>();

// 向 HashMap 添加键值对
hashMap.put("Alice", 25);
hashMap.put("Bob", 30);
hashMap.put("Charlie", 28);

// 获取键对应的值
int age = hashMap.get("Bob"); // 返回 30

// 判断是否包含键
boolean containsAlice = hashMap.containsKey("Alice"); // 返回 true

// 删除键值对
hashMap.remove("Charlie");

// 遍历 HashMap
for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
    String name = entry.getKey();
    int value = entry.getValue();
    System.out.println(name + ": " + value);
}

// 获取 HashMap 的大小
int size = hashMap.size();

8、LinkedHashMap

LinkedHashMapIl s'agit d'une classe de collection en Java. C'est HashMapune variante et implémente Mapl'interface et se trouve java.utildans le package. Différent de l'ordinaire HashMap, LinkedHashMapune table de hachage et une liste doublement chaînée sont utilisées en interne pour maintenir l'ordre des éléments, elles ont donc les caractéristiques suivantes :

Ensemble ordonné : LinkedHashMap L'ordre d'insertion des éléments est conservé, il s'agit donc d'un ensemble ordonné. Lorsque vous parcourez LinkedHashMap, les éléments sont dans le même ordre dans lequel ils ont été ajoutés à la collection.
Clés non en double : LinkedHashMap les clés ne sont pas en double et les clés en double ne sont pas autorisées.
Basé sur une table de hachage et une liste doublement chaînée : LinkedHashMap en interne, une table de hachage est utilisée pour trouver rapidement des éléments, et une liste doublement chaînée est utilisée pour maintenir l'ordre d'insertion des éléments. Cette structure de données permet LinkedHashMapune recherche et un parcours rapides des éléments.
Le tri peut être spécifié : LinkedHashMap permet de trier les éléments selon l'ordre d'insertion ou l'ordre d'accès. Vous pouvez LinkedHashMapchoisir la méthode de tri en passant des paramètres lors de la construction.
Les clés et valeurs nulles ne sont pas prises en charge : LinkedHashMap le stockage nulldes clés et des valeurs n'est pas autorisé.

Exemple

import java.util.LinkedHashMap;
import java.util.Map;

// 创建一个 LinkedHashMap
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();

// 向 LinkedHashMap 添加键值对
linkedHashMap.put("Alice", 25);
linkedHashMap.put("Bob", 30);
linkedHashMap.put("Charlie", 28);

// 保留元素的插入顺序
// 遍历 LinkedHashMap 时，元素的顺序与添加顺序相同
for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
    String name = entry.getKey();
    int value = entry.getValue();
    System.out.println(name + ": " + value);
}

// 判断是否包含键
boolean containsBob = linkedHashMap.containsKey("Bob"); // 返回 true

// 删除键值对
linkedHashMap.remove("Charlie");

// 获取 LinkedHashMap 的大小
int size = linkedHashMap.size();

En bref, LinkedHashMapil s'agit d'une collection ordonnée, adaptée aux situations où l'ordre d'insertion des éléments doit être maintenu. Il a la capacité de rechercher et de parcourir rapidement des éléments et constitue un choix courant pour les collections ordonnées. Vous pouvez l'utiliser si vous devez trier des éléments selon leurs règles de tri TreeMap.

9、TreeMap

TreeMapIl s'agit d'une classe de collection en Java. Elle implémente NavigableMapl'interface et est SortedMapune implémentation de l'interface. Elle se trouve java.utildans le package. TreeMapIl s'agit d'un mappage ordonné basé sur la structure de données arborescente rouge-noir et présente les caractéristiques suivantes :

Carte ordonnée : TreeMap est une carte ordonnée qui trie les clés selon leur ordre naturel ou un comparateur spécifié. Par défaut, TreeMapl'ordre naturel des clés est utilisé pour le tri.
Clés non en double : TreeMap les clés ne sont pas en double et les clés en double ne sont pas autorisées. Si vous essayez d'ajouter une clé existante, la nouvelle valeur écrasera la valeur d'origine.
Basé sur l'arbre rouge-noir : TreeMap utilise en interne la structure de données de l'arbre rouge-noir (Arbre rouge-noir) pour stocker les paires clé-valeur. Cette structure de données garantit une recherche, une insertion et une suppression rapides de clés avec une complexité temporelle de O (log n).
Tri naturel ou personnalisé : les clés peuvent être triées selon leur ordre naturel (si la clé implémente Comparablel'interface) ou en fournissant un comparateur personnalisé ( ).Comparator
Ordre de parcours : lorsque vous parcourez TreeMap, les paires clé-valeur seront itérées dans un ordre trié.
Les clés nulles ne sont pas prises en charge : TreeMap le stockage nulldes clés n'est pas autorisé, mais nullles valeurs peuvent être stockées.

Exemple

import java.util.TreeMap;
import java.util.Map;

// 创建一个 TreeMap
Map<String, Integer> treeMap = new TreeMap<>();

// 向 TreeMap 添加键值对
treeMap.put("Alice", 25);
treeMap.put("Bob", 30);
treeMap.put("Charlie", 28);

// 遍历 TreeMap，按照排序顺序输出
for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
    String name = entry.getKey();
    int value = entry.getValue();
    System.out.println(name + ": " + value);
}

// 获取键对应的值
int age = treeMap.get("Bob"); // 返回 30

// 判断是否包含键
boolean containsAlice = treeMap.containsKey("Alice"); // 返回 true

// 删除键值对
treeMap.remove("Charlie");

// 获取 TreeMap 的大小
int size = treeMap.size();

En bref, TreeMapil s'agit d'un mappage ordonné, adapté aux situations où les données doivent être stockées et accessibles selon les règles de tri des clés. Il dispose d'opérations d'insertion, de suppression et de recherche efficaces, mais équilibre l'arborescence rouge-noir pendant les opérations d'insertion et de suppression, de sorte que les performances des opérations d'insertion et de suppression sont légèrement inférieures HashMap. En fonction de vos exigences de tri et de vos besoins en performances, il est important de choisir le type de collecte approprié.

10、HashTable

HashtableIl s'agit d'une classe de collection en Java, qui implémente Mapl'interface et se trouve java.utildans le package. HashtableIl s'agit d'une collection basée sur la structure de données d'une table de hachage et présente les caractéristiques suivantes :

Stockage de paires clé-valeur : Hashtable les données stockées sont une collection de paires clé-valeur. Chaque clé est unique et chaque clé est associée à une valeur.
Clés uniques : Hashtable les clés sont uniques. Si vous essayez d'ajouter une clé existante, la nouvelle valeur écrasera la valeur d'origine.
Basé sur une table de hachage : Hashtable implémenté en interne à l'aide d'une structure de données de table de hachage, ce qui fait que les opérations de recherche, d'insertion et de suppression ont généralement une complexité temporelle constante, c'est-à-dire O(1).
Sécurité des threads : Hashtable il est thread-safe. Plusieurs threads peuvent accéder et modifier la même Hashtableinstance en même temps sans provoquer d'incohérence des données. Mais cela signifie également que dans un environnement multithread, Hashtableles performances seront relativement faibles. Pensez à l'utiliser si la sécurité des threads n'est pas requise HashMap.
Les clés et valeurs nulles ne sont pas prises en charge : Hashtable le stockage nulldes clés et des valeurs n'est pas autorisé.
Parcours non ordonné : Hashtable l'ordre des éléments n'est pas garanti, c'est-à-dire que l'ordre de stockage des éléments peut être différent de l'ordre dans lequel ils ont été ajoutés.

Exemple

import java.util.Hashtable;
import java.util.Map;

// 创建一个 Hashtable
Map<String, Integer> hashtable = new Hashtable<>();

// 向 Hashtable 添加键值对
hashtable.put("Alice", 25);
hashtable.put("Bob", 30);
hashtable.put("Charlie", 28);

// 获取键对应的值
int age = hashtable.get("Bob"); // 返回 30

// 判断是否包含键
boolean containsAlice = hashtable.containsKey("Alice"); // 返回 true

// 删除键值对
hashtable.remove("Charlie");

// 遍历 Hashtable
for (Map.Entry<String, Integer> entry : hashtable.entrySet()) {
    String name = entry.getKey();
    int value = entry.getValue();
    System.out.println(name + ": " + value);
}

// 获取 Hashtable 的大小
int size = hashtable.size();

En bref, Hashtableil s'agit d'une collection de tables de hachage thread-safe, adaptée aux situations qui doivent être utilisées dans un environnement multithread. Il permet des opérations de recherche, d'insertion et de suppression rapides, mais ses performances sont relativement faibles dans un environnement multithread. Pensez à l'utiliser si la sécurité des threads n'est pas requise HashMap.

11、ConcurrentHashMap

ConcurrentHashMapIl s'agit d'une implémentation de table de hachage thread-safe dans le framework de collection Java. Elle a été introduite dans Java 5 pour résoudre le problème de l'accès simultané à HashMap dans un environnement multithread. ConcurrentHashMapPrend en charge les opérations de lecture et d'écriture hautement simultanées sans verrouillage explicite, ce qui lui permet de fonctionner correctement dans les environnements multithread.

Sécurité des threads : ConcurrentHashMap il est thread-safe, plusieurs threads peuvent lire et écrire des données en même temps sans provoquer d'incohérence des données ou de problèmes de concurrence.

Verrouillage de segment : ConcurrentHashMap le concept de verrouillage de segment est utilisé pour diviser en interne les données en plusieurs segments (segments), et chaque segment est verrouillé indépendamment. Cela signifie que les opérations dans différents segments peuvent être exécutées simultanément, améliorant ainsi les performances de concurrence.

Lecture simultanée élevée : dans ConcurrentHashMap, plusieurs threads peuvent lire des données en même temps sans blocage. Cela rend les performances très élevées dans les scénarios où il y a beaucoup de lecture et beaucoup d’écriture.

Convient aux écritures simultanées élevées : bien que les opérations de lecture puissent être hautement concurrentes, les opérations d'écriture peuvent également être effectuées simultanément sur différents segments, de sorte qu'elles ConcurrentHashMapfonctionnent toujours bien dans le cas d'écritures simultanées élevées.

Lecture sans verrouillage : dans les opérations de lecture, ConcurrentHashMaple verrouillage n'est généralement pas requis, il est donc sans verrouillage pour les opérations de lecture.

Autoriser les valeurs de clé nulles : contrairement à HashMap, ConcurrentHashMaples clés et les valeurs peuvent être nulles.

Optimisation des performances : Java 8 et les versions ultérieures disposent ConcurrentHashMapd'optimisations de performances pour améliorer encore les performances de concurrence.

Exemple d'utilisation

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

// 添加元素
concurrentMap.put("key1", 1);
concurrentMap.put("key2", 2);

// 获取元素
int value = concurrentMap.get("key1");

// 删除元素
concurrentMap.remove("key2");

// 遍历元素
concurrentMap.forEach((key, val) -> {
    System.out.println(key + ": " + val);
});

En bref, ConcurrentHashMapil s'agit d'un outil puissant pour gérer l'accès simultané aux tables de hachage dans un environnement multithread. Il convient aux scénarios de lecture et d'écriture simultanées élevées et peut offrir de bonnes performances et une bonne sécurité des threads.

12、Pile

StackIl s'agit d'une classe de collection en Java qui implémente la structure de données de la pile. Une pile est une structure de données Last-In-First-Out (LIFO) qui est généralement utilisée pour ajouter ou supprimer des éléments par le haut. StackLes classes héritent de Vectorla classe et se trouvent java.utildans le package.

Dernier entré, premier sorti : la pile est une structure de données dernier entré, premier sorti, et le dernier élément ajouté sera le premier à être supprimé.
Basé sur un tableau : Stack les tableaux sont utilisés en interne pour stocker des éléments, ils ont donc la capacité de se développer dynamiquement.
Opérations principales :
push(E item) Pousser l'élément en haut de la pile.
pop(): Supprime et renvoie l'élément supérieur de la pile.
peek(): Renvoie l'élément supérieur de la pile, mais ne le supprime pas.
empty(): Vérifiez si la pile est vide.
search(Object o): Trouvez la position de l'élément dans la pile et renvoyez la distance depuis le haut de la pile.

Exemple

import java.util.Stack;

// 创建一个 Stack
Stack<Integer> stack = new Stack<>();

// 压入元素
stack.push(1);
stack.push(2);
stack.push(3);

// 弹出元素
int popped = stack.pop(); // 弹出并返回 3

// 查看栈顶元素
int top = stack.peek(); // 返回 2，但不移除

// 检查栈是否为空
boolean isEmpty = stack.isEmpty(); // 返回 false

// 查找元素在栈中的位置
int index = stack.search(1); // 返回 2，表示距离栈顶的第 2 个元素是 1

En bref, Stackil s'agit d'une structure de données dernier entré, premier sorti qui est souvent utilisée pour stocker et gérer temporairement des données, comme dans les algorithmes, la récursivité et l'évaluation d'expressions. Dans le développement réel, puisqu'il Stacks'agit Vectord'une sous-classe de , il est généralement recommandé d'utiliser Dequela classe d'implémentation de l'interface (file d'attente à double extrémité) LinkedListcomme alternative à la pile, car LinkedListelle prend en charge à la fois les opérations de pile et les opérations de file d'attente et offre de meilleures performances.

13、PriorityQueue

PriorityQueueIl s'agit d'une classe de collection en Java. Elle implémente l'interface Queue et est une file d'attente spéciale utilisée pour stocker les éléments en priorité. Les éléments sont stockés dans la file d'attente et retirés de la file d'attente en fonction de leur priorité. PriorityQueueEst une implémentation d'un Min-Heap, où l'élément supérieur est l'élément ayant la priorité la plus élevée. Situé java.utildans le colis.

File d'attente prioritaire : PriorityQueue est une file d'attente prioritaire dans laquelle les éléments sont classés selon leur priorité. Par défaut, les éléments sont considérés comme triés dans l'ordre naturel, ou vous pouvez fournir un comparateur personnalisé pour spécifier l'ordre.
Opérations d'insertion et de suppression : PriorityQueue prend en charge les opérations d'insertion ( offer()ou add()méthode) et de suppression ( poll()méthode). Les opérations d'insertion ajoutent des éléments à la file d'attente, et les opérations de suppression suppriment et renvoient l'élément ayant la priorité la plus élevée dans la file d'attente.
Éléments nuls non autorisés : PriorityQueue les éléments nuls ne peuvent pas être stockés.
Basé sur le tas : PriorityQueue implémenté en interne à l'aide de la structure de données du tas binaire, qui est un arbre binaire complet qui garantit que l'efficacité de l'insertion et de la suppression est O (log n), où n est la taille de la file d'attente.
Tri personnalisé :Comparator vous pouvez spécifier la manière dont les éléments sont triés en fournissant un comparateur personnalisé ( ). Cela vous permet de définir tout type de relation de préséance entre les éléments.

Exemple

import java.util.PriorityQueue;
import java.util.Queue;

// 创建一个 PriorityQueue，默认按自然顺序排序
Queue<Integer> priorityQueue = new PriorityQueue<>();

// 插入元素
priorityQueue.offer(5);
priorityQueue.offer(3);
priorityQueue.offer(8);

// 删除并返回最高优先级元素
int highestPriority = priorityQueue.poll(); // 返回 3

// 创建一个自定义排序的 PriorityQueue
Queue<String> customPriorityQueue = new PriorityQueue<>((a, b) -> b.length() - a.length());

// 插入元素，根据长度倒序排序
customPriorityQueue.offer("apple");
customPriorityQueue.offer("banana");
customPriorityQueue.offer("cherry");

// 删除并返回最高优先级元素
String highestLength = customPriorityQueue.poll(); // 返回 "banana"

En bref, PriorityQueueil s'agit d'une collection ordonnée utilisée pour implémenter une file d'attente prioritaire. Il est très utile dans de nombreuses applications, telles que la planification des tâches, l'équilibrage de charge, etc., et peut être trié et traité selon la priorité des éléments. Un tri flexible peut être obtenu en fournissant des comparateurs personnalisés.

14、Arbre

En Java, « Tree » est généralement utilisé pour décrire une structure de données arborescente ou une collection d'arbres, plutôt que de faire spécifiquement référence à une classe nommée « Tree ». L'arborescence est une structure de données importante qui organise et stocke les données dans une structure hiérarchique et est souvent utilisée pour mettre en œuvre la recherche, le tri, les structures hiérarchiques, etc.

TreeNodeInterface : Généralement, les nœuds de l'arborescence implémentent TreeNodeune interface ou ses sous-interfaces MutableTreeNode. Ces interfaces fournissent des opérations de base pour les nœuds de l'arborescence, telles que l'obtention de nœuds parents, l'obtention de nœuds enfants, l'ajout de nœuds enfants, etc.
TreeModelInterface : TreeModel une interface est utilisée pour représenter un modèle de données arborescent, souvent JTreeutilisé en conjonction avec un contrôle d'arborescence d'interface utilisateur graphique (GUI) tel que GUI. Il définit la manière dont les données sont organisées et accessibles dans une structure arborescente.
DefaultMutableTreeNodeClasse : Il s'agit d'une classe d'implémentation de nœud d'arbre couramment utilisée, généralement utilisée pour créer des arbres mutables (Mutable Tree).
JTreeClasse : JTree est un composant d'interface utilisateur graphique dans Java Swing utilisé pour afficher et interagir avec des structures de données arborescentes. Il est généralement TreeModelutilisé avec les classes de nœuds et .
Algorithme de traversée d'arbre : Java peut utiliser des méthodes récursives ou itératives pour implémenter la traversée d'arbre, y compris la traversée en pré-ordre, la traversée dans l'ordre, la traversée après-ordre et la traversée par ordre de niveau. Ces algorithmes de parcours sont utilisés pour accéder aux nœuds d'un arbre.
Classe d'arbre binaire : en Java, vous pouvez personnaliser les nœuds et les structures de données d'arbre binaire des arbres binaires, qui sont utilisés pour implémenter des opérations d'arbre binaire, telles que les arbres de recherche binaire (BST), etc.

Exemple

Créez un arbre mutable simple en utilisant DefaultMutableTreeNodeetJTree

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;

public class SimpleTreeExample {
    public static void main(String[] args) {
        // 创建根节点
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");

        // 创建子节点
        DefaultMutableTreeNode node1 = new DefaultMutableTreeNode("Node 1");
        DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("Node 2");

        // 添加子节点到根节点
        root.add(node1);
        root.add(node2);

        // 创建树模型
        DefaultTreeModel treeModel = new DefaultTreeModel(root);

        // 创建树控件
        JTree tree = new JTree(treeModel);

        // 创建窗口并添加树控件
        JFrame frame = new JFrame("Simple Tree Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new JScrollPane(tree));
        frame.pack();
        frame.setVisible(true);
    }
}

Cet exemple crée un arbre mutable simple avec un nœud racine et deux nœuds enfants, puis JTreel'affiche via .

En résumé, les arbres en Java peuvent être implémentés de différentes manières et classes pour représenter et traiter des données avec des structures hiérarchiques. Dans le développement d'interfaces utilisateur graphiques, JTreeil s'agit d'un contrôle d'arborescence couramment utilisé pour afficher et exploiter les données d'arborescence. Parmi les algorithmes et les structures de données, les structures arborescentes sont également largement utilisées pour résoudre des problèmes tels que la recherche, le tri et les structures hiérarchiques.

15、Graphique

En Java, la structure de données représentant le graphique (Graph) doit généralement être implémentée par vous-même, car la bibliothèque standard Java ne fournit pas de Graphclasse spécialisée. Le graphique est une structure de données très importante utilisée pour représenter les relations entre plusieurs objets. Il comprend des nœuds (sommets) et des arêtes (connexions). Voici une manière courante de représenter et de manipuler des graphiques :

Classe de nœuds (Vertex) : généralement, vous devez créer une classe de nœuds pour représenter chaque nœud du graphique. Une classe de nœud comprend généralement un identifiant unique qui identifie le nœud, ainsi que d'autres informations relatives au nœud.
Edge : Edge est utilisé pour connecter deux nœuds et inclut généralement des informations supplémentaires, telles que le poids.
Graphique : la classe graph est utilisée pour représenter l'intégralité du graphique, qui comprend un ensemble de nœuds et un ensemble d'arêtes. Vous pouvez choisir d'implémenter le graphique à l'aide d'une matrice de contiguïté, d'une liste chaînée de contiguïté ou d'une autre structure de données.

Exemple

Voici un exemple simple montrant comment représenter un graphe orienté (Directed Graph) en Java :

import java.util.ArrayList;
import java.util.List;

class Vertex {
    private int id;
    private List<Edge> edges;

    public Vertex(int id) {
        this.id = id;
        this.edges = new ArrayList<>();
    }

    public int getId() {
        return id;
    }

    public List<Edge> getEdges() {
        return edges;
    }

    public void addEdge(Vertex destination, int weight) {
        edges.add(new Edge(this, destination, weight));
    }
}

class Edge {
    private Vertex source;
    private Vertex destination;
    private int weight;

    public Edge(Vertex source, Vertex destination, int weight) {
        this.source = source;
        this.destination = destination;
        this.weight = weight;
    }

    public Vertex getSource() {
        return source;
    }

    public Vertex getDestination() {
        return destination;
    }

    public int getWeight() {
        return weight;
    }
}

public class DirectedGraph {
    private List<Vertex> vertices;

    public DirectedGraph() {
        this.vertices = new ArrayList<>();
    }

    public void addVertex(Vertex vertex) {
        vertices.add(vertex);
    }

    public List<Vertex> getVertices() {
        return vertices;
    }
}

Dans cet exemple, nous définissons Vertexla classe pour représenter les nœuds du graphe, Edgela classe pour représenter les arêtes et DirectedGraphla classe pour représenter le graphe orienté. Vous pouvez créer des nœuds, ajouter des arêtes et créer un graphique orienté.

Il convient de noter que l'exemple ci-dessus est une démonstration simple et que les applications réelles peuvent nécessiter des structures de données et des algorithmes plus complexes pour représenter et exploiter des graphiques. De plus, certaines bibliothèques Java tierces, telles que JGraphT et JUNG, fournissent des fonctions de traitement graphique plus avancées et peuvent être sélectionnées et utilisées en fonction de besoins spécifiques.

16、Tas

En Java, « tas » fait généralement référence à la mémoire tas, et non au tas dans la structure de données. La mémoire de tas fait partie de la mémoire utilisée pour stocker des objets dans la machine virtuelle Java (JVM), par opposition à la mémoire de pile. Voici quelques informations importantes sur la mémoire tas Java :

Mémoire de tas Java : la mémoire de tas est la zone de mémoire utilisée pour stocker les instances d'objet dans un programme Java. Il s'agit de l'élément central de la gestion de la mémoire Java et est utilisé pour allouer et désallouer dynamiquement la mémoire objet. La taille de la mémoire tas peut être configurée via les paramètres de démarrage de la JVM.
Allocation d'objet : lorsque vous créez un nouvel objet, il alloue généralement de l'espace mémoire dans la mémoire tas. Le cycle de vie des objets dans la mémoire tas n'est pas limité par les méthodes, mais est géré par le mécanisme de référence et de garbage collection de l'objet.
Garbage collection : les objets dans la mémoire tas n'existeront pas éternellement. Le mécanisme de récupération de place Java analysera régulièrement la mémoire tas, marquera et recyclera les objets qui ne sont plus référencés et libérera la mémoire qu'ils occupent. Cela permet d'éviter les fuites de mémoire et de gérer la mémoire.
Zone de mémoire tas : la mémoire tas est généralement divisée en différentes zones, telles que Young Generation, Old Generation et PermGen. La nouvelle génération est principalement utilisée pour stocker des objets nouvellement créés, tandis que l'ancienne génération est principalement utilisée pour stocker des objets ayant une longue durée de vie. La génération persistante (dans Java 8 et versions précédentes, remplacée par métaespace après Java 8) est utilisée pour stocker les informations et méthodes de classe, etc.
Gestion de la mémoire : Java assure une gestion automatique de la mémoire, de sorte que les développeurs n'ont pas besoin d'allouer ou de libérer manuellement de la mémoire. Le garbage collector Java est responsable de la gestion de l'allocation et du recyclage de la mémoire pour garantir l'utilisation correcte de la mémoire.
Fuites de mémoire : bien que Java dispose d'une gestion automatique de la mémoire, des fuites de mémoire peuvent toujours se produire, lorsque les objets sont continuellement référencés et ne peuvent pas être recyclés. Les développeurs doivent veiller à publier rapidement les références d'objets qui ne sont plus utilisées pour éviter les fuites de mémoire.

Exemple

Voici un exemple simple qui montre comment créer un objet en Java et l'allouer dans la mémoire tas :

public class HeapExample {
    public static void main(String[] args) {
        // 创建对象并分配到堆内存
        String str = new String("Hello, World!");

        // 在不再使用对象时，不要忘记将引用设为 null，以便垃圾回收
        str = null;
    }
}

Dans cet exemple, nous créons un objet chaîne stret l'attribuons dans la mémoire tas. Lorsque nous n'avons plus besoin de l'objet, définir la référence nullsur aide le ramasse-miettes à identifier et à récupérer les objets qui ne sont plus référencés. C'est un moyen d'éviter les fuites de mémoire.