Méthode Java LinkedList size()

Java LinkedList Java LinkedList

size()La méthode est dans JavaLinkedListune méthode couramment utilisée fournie par la classe, qui appartient àjava.utille package. Le but principal de cette méthode est de renvoyer le nombre d'éléments dans la liste chaînée actuelle.

Syntaxe de la méthode：

public int size()

Valeur de retour：

  • Renvoieintune valeur de type, représentant le nombre d'éléments dans la liste chaînée
  • Si la liste chaînée est vide, elle renvoie 0

Caractéristiques de la méthode

Complexité temporelle

size()La complexité temporelle de la méthode est O(1), ce qui signifie que quel que soit le nombre d'éléments que contient la liste chaînée, le temps pour obtenir la taille est constant.

C'est parce queLinkedListla classe maintient en interne unesizevariable, qui est automatiquement mise à jour lorsque des éléments sont ajoutés ou supprimés. Appelersize()la méthode renvoie simplement la valeur de cette variable.

Différence avec la longueur d'un tableau

Les débutants confondent parfoissize()la méthode avec la propriété du tableaulengthpropriété :

  • La propriété du tableaulengthest une propriété qui représente la capacité du tableau
  • LinkedListdesize()est une méthode qui renvoie le nombre d'éléments réellement stockés

Sécurité des threads

size()La méthode elle-même n'est pas thread-safe. Si elle est utilisée dans un environnement multithread, des mesures de synchronisation supplémentaires sont nécessaires.

Exemples d'utilisation

Utilisation de base

Exemple

import java.util.LinkedList;

public class LinkedListSizeDemo {
    public static void main(String[] args) {
        // Créer une LinkedList
        LinkedList<String> fruits = new LinkedList<>();
       
        // Ajouter des éléments
        fruits.add("Pomme");
        fruits.add("Banane");
        fruits.add("Orange");
       
        // Utilisez la méthode size() pour obtenir le nombre d'éléments
        int size = fruits.size();
        System.out.println("Nombre d'éléments dans LinkedList : " + size); // Sortie : 3
    }
}

Cas de liste chaînée vide

Exemple

import java.util.LinkedList;

public class EmptyLinkedListDemo {
    public static void main(String[] args) {
        LinkedList<Integer> numbers = new LinkedList<>();
        System.out.println("Taille de la liste chaînée vide : " + numbers.size()); // Sortie : 0
    }
}

Démonstration de changement dynamique

Exemple

import java.util.LinkedList;

public class DynamicSizeDemo {
    public static void main(String[] args) {
        LinkedList<Character> letters = new LinkedList<>();
        System.out.println("Taille initiale : " + letters.size()); // 0
       
        letters.add('A');
        letters.add('B');
        System.out.println("Après avoir ajouté deux éléments : " + letters.size()); // 2
       
        letters.removeFirst();
        System.out.println("Après avoir retiré un élément : " + letters.size()); // 1
       
        letters.clear();
        System.out.println("Après avoir vidé : " + letters.size()); // 0
    }
}

Questions courantes

La méthode size() lève-t-elle une exception ?

size()La méthode ne lève généralement pas d'exception. Même si la liste chaînée est null (remarque : pas une liste chaînée vide), appelersize()la méthode ne lèvera pas d'exception, mais lèveraNullPointerException。

Exemple

LinkedList<String> list = null;
// La ligne suivante lèvera une NullPointerException
System.out.println(list.size());

Relation entre size() et isEmpty()

isEmpty()La méthode est basée sursize()l'implémentation de la méthode :

Exemple

public boolean isEmpty() {
    return size() == 0;
}

Par conséquent,list.isEmpty()est équivalent àlist.size() == 0, mais le premier a une meilleure lisibilité.

Scénarios d'application pratiques

Parcours en boucle

Exemple

LinkedList<String> colors = new LinkedList<>();
colors.add("Red");
colors.add("Green");
colors.add("Blue");

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

Vérification de la capacité

Exemple

LinkedList<Integer> queue = new LinkedList<>();
// ...ajouter des éléments...

if (queue.size() > 10) {
    System.out.println("La file est pleine, impossible d'ajouter plus d'éléments");
}

Comparaison avec d'autres collections

Exemple

LinkedList<String> list1 = new LinkedList<>();
LinkedList<String> list2 = new LinkedList<>();

// ...remplir deux listes chaînées...

if (list1.size() == list2.size()) {
    System.out.println("Les deux listes chaînées ont la même taille");
}

Considérations de performance

Bien quesize()la méthode elle-même a une complexité temporelle en O(1), dans certains cas, appeler fréquemmentsize()peut avoir un impact sur les performances :

  1. Environnement multithread: chaque appel àsize()doit lire les données en mémoiresizevariable
  2. Conditions de boucle complexes: telles quefor (int i = 0; i < list.size(); i++), en l'appelant à chaque itération de la bouclesize()

Pour le second cas, il peut être optimisé comme suit :

Exemple

int size = list.size();
for (int i = 0; i < size; i++) {
    // Corps de la boucle
}

Résumé

LinkedListdesize()La méthode est une méthode simple mais très importante qui permet d'obtenir rapidement le nombre actuel d'éléments dans une liste chaînée. Comprendre le principe de fonctionnement et les caractéristiques de cette méthode aide à écrire du code Java plus efficace et plus fiable.

À retenir :

  • size()Elle renvoie le nombre d'éléments, et non la capacité
  • D'une liste chaînée videsize()renvoie 0
  • Lorsque vous l'utilisez dans un environnement multithread, vous devez prêter attention aux problèmes de synchronisation
  • Elle peut être combinée avecisEmpty()méthode pour rendre le code plus clair

Java LinkedList Java LinkedList

Autres extensions