[Bases de Java] Guide d'utilisation des listes Java : analyse approfondie des opérations de liste

Java est un langage de programmation puissant doté d'un riche ensemble de structures de données et de classes de collection, dont Listla liste. ListIl s'agit d'une interface importante dans le framework de collection Java, qui nous permet de stocker un ensemble d'éléments de manière ordonnée et reproductible. ListCe blog passera du basique au avancé, présentant en détail les interfaces et Listles classes d'implémentation courantes en Java pour aider les débutants à comprendre en profondeur le concept, l'utilisation et les scénarios d'application des listes.

Qu'est-ce qu'une liste ?

En Java, Listest une interface qui hérite de Collectionl'interface. ListL'interface représente une séquence ordonnée d'éléments, permettant la duplication d'éléments. Cela signifie que vous pouvez stocker un ensemble d'éléments dans l'ordre dans lequel ils ont été ajoutés et permettre au même élément d'apparaître plusieurs fois. ListL'interface fournit de nombreuses méthodes pour utiliser les éléments de la liste, notamment l'ajout, la suppression, l'obtention, la recherche, etc.

Méthodes de base de l'interface List

Commençons par comprendre Listquelques méthodes de base dans l'interface :

1. Ajout d'éléments : Vous pouvez add()ajouter des éléments à la fin de la liste en utilisant la méthode. Par exemple:

   List<String> fruits = new ArrayList<>();
   fruits.add("苹果");
   fruits.add("香蕉");
   fruits.add("橙子");
   

2. Obtenir des éléments : utilisez get()la méthode pour obtenir des éléments de la liste en fonction de l'index. Les index commencent à compter à partir de 0, indiquant le premier élément. Par exemple:

   String firstFruit = fruits.get(0); // 获取第一个元素（苹果）
   

3. Supprimer des éléments : utilisez remove()la méthode pour supprimer des éléments d'une liste en fonction de l'index ou de la valeur de l'élément. Par exemple:

   fruits.remove(1); // 删除索引为 1 的元素（香蕉）
   fruits.remove("橙子"); // 删除值为 "橙子" 的元素
   

4. Obtenir la taille de la liste : Utilisez size()la méthode pour obtenir le nombre d'éléments dans la liste. Par exemple:

   int size = fruits.size(); // 获取列表大小，此时 size 为 2
   

5. Parcours d'une liste : vous pouvez utiliser une boucle ou un itérateur pour parcourir les éléments d'une liste. Par exemple:

   for (String fruit : fruits) {
         
         
       System.out.println(fruit);
   }
   

Classes d'implémentation courantes de List

Java fournit plusieurs classes qui implémentent Listdes interfaces, chacune avec ses propres caractéristiques et utilisations. Voici quelques Listclasses d’implémentation courantes :

1. ArrayList : ArrayListest un tableau dynamique basé sur l'implémentation d'un tableau, qui prend en charge un accès aléatoire rapide aux éléments. Si vous devez insérer et supprimer des éléments fréquemment, vous pouvez choisir une autre implémentation.

2. LinkedList : LinkedListIl s'agit d'une liste basée sur une liste doublement chaînée, adaptée aux situations où des opérations fréquentes d'insertion et de suppression sont nécessaires. Ses opérations d'insertion et de suppression sont ArrayListplus rapides que .

3. Vecteur : Vectorsimilaire ArrayList, mais thread-safe. Pensez à utiliser des listes si vous les utilisez dans un environnement multithread Vector.

4. Stack : StackIl s'agit d'une classe héritée Vectoret représentant la structure de données de la pile, prenant en charge les opérations push et pop.

ArrayList vs LinkedList

ArrayListet LinkedListsont deux implémentations de liste courantes, elles ont des caractéristiques et des scénarios applicables différents :

• ArrayList convient aux situations où un accès aléatoire fréquent aux éléments est requis. Puisqu’il est implémenté sur un tableau, n’importe quel élément de la liste est accessible rapidement. Cependant, les opérations d'insertion et de suppression peuvent être LinkedListplus lentes que .

• LinkedList convient aux situations où des opérations d'insertion et de suppression fréquentes sont nécessaires. Puisqu'il est implémenté sur la base d'une liste chaînée, les opérations d'insertion et de suppression sont généralement ArrayListplus rapides que . Cependant, l'accès aléatoire aux éléments peut être plus lent car la liste chaînée doit être parcourue pour trouver l'élément.

Ci-dessous, nous examinerons les différences et les scénarios applicables de ces deux implémentations de liste.

Liste des tableaux

• Avantages :

  • Accès aléatoire rapide : étant basé sur des tableaux, ArrayListil prend en charge un accès rapide aux éléments par index. Cela rend les opérations de lecture très efficaces.

• Scénarios applicables :

  • ArrayListUn meilleur choix lorsque des opérations de lecture fréquentes (accès aux éléments via des index) sont requises .
  • ArrayListCela fonctionne mieux lorsque la taille de la liste est relativement stable ou fixe .

• Exemple :

  List<String> arrayList = new ArrayList<>();
  arrayList.add("苹果");
  arrayList.add("香蕉");
  arrayList.add("橙子");
  
  String fruit = arrayList.get(1); // 快速访问第二个元素
  

Liste liée

• Avantages :

  • Insertion et suppression rapides : parce qu'il est basé sur une liste chaînée, LinkedListil prend en charge l'insertion et la suppression rapides d'éléments à n'importe quelle position. Cela rend les opérations d’édition très efficaces.

• Scénarios applicables :

  • LinkedListC'est un meilleur choix lorsque des opérations d'insertion et de suppression fréquentes sont nécessaires .
  • Cela fonctionne mieux lorsque la taille de la liste peut changer dynamiquement LinkedList.

• Exemple :

  List<String> linkedList = new LinkedList<>();
  linkedList.add("苹果");
  linkedList.add("香蕉");
  linkedList.add("橙子");
  
  linkedList.add(1, "葡萄"); // 在第二个位置插入元素
  linkedList.remove(0); // 移除第一个元素
  

Liste des parcours

Itérer Listsur les éléments est une opération courante. Vous pouvez utiliser différentes méthodes pour implémenter le parcours, en voici quelques-unes courantes :

1. Utiliser pour chaque boucle

Utilisez la boucle for-each améliorée pour parcourir facilement Listles éléments dans :

List<String> fruits = new ArrayList<>();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("橙子");

for (String fruit : fruits) {
    
    
    System.out.println(fruit);
}

2. Utilisez la boucle for classique

Vous pouvez utiliser une boucle for traditionnelle pour itérer par indexList :

for (int i = 0; i < fruits.size(); i++) {
    
    
    String fruit = fruits.get(i);
    System.out.println(fruit);
}

3. Utilisez des itérateurs

Les itérateurs constituent un moyen de parcours plus général et sont applicables à toutes Listles implémentations. Voici un exemple de parcours à l'aide d'un itérateur :

Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
    
    
    String fruit = iterator.next();
    System.out.println(fruit);
}

Autres opérations courantes sur la liste

En plus des opérations de base d'ajout, de suppression, d'obtention et de traversée, il Listprend également en charge de nombreuses autres opérations courantes, telles que déterminer si la liste est vide, rechercher des éléments, inverser la liste, etc. Voici quelques méthodes couramment utilisées :

• Déterminez si la liste est vide :

  boolean isEmpty = fruits.isEmpty(); // 返回 true，如果列表为空
  

• Trouver l'index d'un élément :

  int index = fruits.indexOf("香蕉"); // 返回元素 "香蕉" 的索引，如果不存在则返回 -1
  

• Inversez la liste :

  Collections.reverse(fruits); // 反转列表中的元素顺序
  

• Obtenir la sous-liste :

  List<String> subList = fruits.subList(1, 3); // 获取索引 1 到 2 之间的子列表
  

• Remplacer les éléments :

  fruits.set(0, "葡萄"); // 将第一个元素替换为 "葡萄"
  

Ces méthodes peuvent vous aider à manipuler les éléments de la liste de manière plus flexible.

Notes sur l'utilisation de List

Lors de l'utilisation en Java List, certaines considérations et bonnes pratiques doivent être prises en compte pour garantir que votre code est efficace, lisible et exempt de problèmes potentiels. Voici quelques Listnotes d'utilisation :

1. Choisissez la Listclasse d'implémentation appropriée : Choisissez la classe d'implémentation appropriée en fonction de vos besoins List. Si vous avez besoin d'un accès aléatoire fréquent aux éléments, choisissez ArrayList; si vous avez besoin d'opérations d'insertion et de suppression fréquentes, choisissez LinkedList.

2. Utiliser des génériques : déclarez toujours l'utilisation de génériques Listpour garantir la sécurité des types. Par exemple, List<String>représentez une liste qui ne peut stocker que des chaînes.

3. Évitez de modifier la liste dans une boucle : Lorsque vous utilisez for-eachune boucle pour parcourir une liste, ne modifiez pas le contenu de la liste dans la boucle, ce qui pourrait provoquer un comportement imprévisible. Si une modification est nécessaire, utilisez un itérateur.

   // 不推荐的做法，可能会导致 ConcurrentModificationException
   for (String fruit : fruits) {
         
         
       if (fruit.equals("橙子")) {
         
         
           fruits.remove(fruit);
       }
   }
   
   // 推荐的做法，使用迭代器
   Iterator<String> iterator = fruits.iterator();
   while (iterator.hasNext()) {
         
         
       String fruit = iterator.next();
       if (fruit.equals("橙子")) {
         
         
           iterator.remove();
       }
   }
   

4. Remarque sur les valeurs nulles : Listles valeurs nulles peuvent être stockées, mais elles doivent être manipulées avec précaution pour éviter de générer une exception de pointeur nul lors des opérations ultérieures.

5. Tenez compte de la concurrence : si votre liste doit être utilisée dans un environnement multithread, envisagez d'utiliser une Listclasse d'implémentation thread-safe telle que Vectorou Collections.synchronizedList()d'envelopper votre liste avec .

6. Optimisation des performances : Si vous devez insérer et supprimer fréquemment un grand nombre d'éléments, pensez à l'utiliser LinkedList, il offre de meilleures performances à cet égard. Et pour un grand nombre d’opérations de lecture, ArrayListc’est plus efficace.

7. Évitez le boxing et le unboxing inutiles : lorsque vous utilisez des types de données de base (tels que int), évitez de les regrouper dans des classes wrapper (telles que Integer) afin de réduire la consommation de mémoire et les pénalités de performances.

8. Définir la capacité de manière appropriée : Si vous connaissez la taille approximative de la liste, vous pouvez ArrayListspécifier la capacité initiale lors de sa création pour réduire l'expansion dynamique ultérieure.

   List<String> fruits = new ArrayList<>(100); // 指定初始容量为 100
   

9. Utiliser Collections.unmodifiableList()des listes protégées : Si vous devez transmettre une liste à un autre code, mais que vous ne souhaitez pas qu'elle soit modifiée, vous pouvez utiliser pour Collections.unmodifiableList()créer une liste non modifiable.

   List<String> readOnlyList = Collections.unmodifiableList(fruits);
   

10. Documentation et commentaires : ajoutez des commentaires de documentation à votre code qui décrivent l'objectif, les caractéristiques et le comportement attendu de la liste afin que les autres développeurs puissent l'utiliser correctement.

Suivre ces considérations vous aidera à mieux le gérer et à l'utiliser List, améliorant ainsi la qualité et la maintenabilité de votre code. N'oubliez pas qu'il est important de comprendre les bases et les meilleures pratiques des listes pour écrire du code Java efficace.

Résumer

L'interface de Java Listest un outil puissant pour travailler avec des collections d'éléments ordonnées et reproductibles. Différentes Listimplémentations conviennent à différents scénarios et vous pouvez choisir la classe d'implémentation appropriée en fonction de vos besoins. Comprendre Listles méthodes de base, les méthodes de parcours et les opérations courantes de l'interface vous aidera à mieux utiliser les listes pour résoudre les problèmes. Avec de la pratique et de la pratique, vous maîtriserez l'utilisation des listes et acquerrez progressivement une compréhension plus approfondie des opérations plus avancées et des meilleures pratiques. J'espère que ce blog pourra vous aider à maîtriser Listles connaissances de base en Java et à devenir plus à l'aise en programmation.