Décryptage des structures de données Java : Maîtriser ces structures de données vous permettra de programmer avec deux fois plus de résultat avec moitié moins d'effort

Le secret des structures de données Java : Maîtriser ces structures de données rendra votre programmation plus efficace avec moins d'effort. Des exemples de code spécifiques sont nécessaires

Introduction :
Dans le domaine de la programmation, la structure des données est un sujet très important. La maîtrise des structures de données appropriées peut grandement améliorer l'efficacité et la qualité des programmes. Dans le langage de programmation Java, il existe également certaines structures de données couramment utilisées. Aujourd'hui, nous allons révéler ces structures de données ensemble et joindre des exemples de code spécifiques.

1. Array (Array) :
   Array est une structure de données linéaire qui peut stocker des éléments du même type et accessible par index. En Java, les tableaux constituent l’une des structures de données les plus basiques et les plus couramment utilisées. Voici un exemple de code qui montre comment créer, accéder et modifier un tableau :

// 创建一个数组
int[] nums = new int[5];

// 初始化数组
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;

// 访问数组元素
int firstNum = nums[0];
System.out.println("第一个元素是：" + firstNum);

// 修改数组元素
nums[0] = 10;
System.out.println("修改后的第一个元素是：" + nums[0]);

2. LinkedList :
   La liste chaînée est une autre structure de données linéaire courante qui consiste en une série de nœuds, chaque nœud contient des données et un pointeur vers le suivant. nœud. En Java, il existe deux types de listes chaînées, à savoir les listes chaînées simples et les listes chaînées doublement. Voici un exemple de code qui montre comment créer, insérer et supprimer des nœuds de liste chaînée :

Exemple de code de liste chaînée unidirectionnelle :

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

// 创建链表
ListNode head = new ListNode(1);
ListNode second = new ListNode(2);
ListNode third = new ListNode(3);

// 连接链表节点
head.next = second;
second.next = third;

// 插入节点
ListNode newNode = new ListNode(4);
second.next = newNode;
newNode.next = third;

// 删除节点
second.next = third;

3. Stack (Stack) :
   Stack est une structure de données linéaire avec un accès spécifique stratégie, elle suit le principe "Last In First Out (LIFO)", c'est-à-dire que le dernier élément poussé sur la pile est le premier à être retiré de la pile. En Java, vous pouvez utiliser la classe Stack pour implémenter une pile. Voici un exemple de code qui montre comment créer, pousser et pop des opérations :

import java.util.Stack;

// 创建栈
Stack<String> stack = new Stack<>();

// 入栈
stack.push("Java");
stack.push("C++");
stack.push("Python");

// 出栈
String top = stack.pop();
System.out.println("出栈的元素是：" + top);

4. Queue :
   Queue est une structure de données linéaire avec une stratégie d'accès spécifique, qui suit "premier entré, premier sorti" ( First In First Out , FIFO), c'est-à-dire que le premier élément à être mis en file d'attente est le premier à être retiré de la file d'attente. En Java, vous pouvez utiliser l'interface Queue pour implémenter une file d'attente. Voici un exemple de code qui montre comment créer, mettre en file d'attente et retirer des opérations :

import java.util.Queue;
import java.util.LinkedList;

// 创建队列
Queue<String> queue = new LinkedList<>();

// 入队
queue.add("Java");
queue.add("C++");
queue.add("Python");

// 出队
String front = queue.poll();
System.out.println("出队的元素是：" + front);

5. Table de hachage (HashMap) :
   La table de hachage est une structure de données très couramment utilisée basée sur le mappage de relations de paires clé-valeur. En Java, une table de hachage peut être implémentée à l'aide de la classe HashMap. Voici un exemple de code qui montre comment créer, insérer et rechercher des éléments :

import java.util.HashMap;

// 创建哈希表
HashMap<String, Integer> hashMap = new HashMap<>();

// 插入元素
hashMap.put("Java", 1);
hashMap.put("C++", 2);
hashMap.put("Python", 3);

// 查找元素
int value = hashMap.get("Java");
System.out.println("Java对应的值是：" + value);

Résumé :
Cet article présente plusieurs structures de données couramment utilisées en Java, notamment les tableaux, les listes chaînées, les piles, les files d'attente et les tables de hachage. Maîtriser l’utilisation de ces structures de données peut grandement améliorer l’efficacité et la qualité de la programmation. J'espère que cet article pourra être utile aux lecteurs en programmation Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!