Liste Java

Le Java Collection Framework contient des interfaces et des classes très utiles qui les implémentent pour travailler avec des structures de données. On peut dire que c'est l'un des frameworks JDK les plus importants. L'interface Liste est très populaire. car sans toutes sortes de listes en programmation c'est indispensable. Dans cet article, nous aborderons cette interface, les méthodes et les implémentations de Java List.

Interface de liste Java

La chose la plus importante à propos d'une liste est qu'il s'agit d'une collection ordonnée . Vous pouvez également appeler cela une séquence. En Java, les listes sont homogènes, c'est-à-dire que les éléments de la liste sont du même type de données. L'interface Java List hérite de Collection, elle hérite de toutes ses opérations. En plus de celles-ci, les opérations suivantes sont également possibles dans List :

• Accès positionnel. Chaque élément a un index et peut être manipulé en fonction de sa position. dans la liste. Autrement dit, vous pouvez ajouter, exclure et modifier des éléments.
• Recherche. Vous pouvez trouver un élément dans une liste par son contenu et renvoyer son index.
• Itération. La nature séquentielle de List permet l'utilisation de méthodes d'itération (listIterator).
• Gamme-vue. La méthode de sous-liste effectue des opérations de plage arbitraires sur la liste.

Méthodes de liste Java

Les opérations ci-dessus sont exposées dans les méthodes de l'interface Java List. En voici quelques-uns:

Implémentation de la liste

Comme List est une interface, les programmes doivent en créer une implémentation concrète. Vous pouvez choisir entre les implémentations List suivantes dans l'API Java Collections :

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

L'implémentation la plus populaire de l'interface List s'appelle ArrayList. Beaucoup moins souvent, mais vous pouvez toujours voir l'utilisation de LinkedList dans des tâches réelles, mais Vector et Stack sont devenus moralement obsolètes depuis longtemps, vous ne les trouverez donc probablement que dans des projets avec un ancien code hérité.

Déclaration d'interface de liste

Vous pouvez déclarer un programme List en Java de l'une des manières suivantes :

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

Il est préférable de déclarer une nouvelle liste via une interface. De même, vous pouvez déclarer d'autres implémentations de List. Le chemin le plus court :

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

Avec une telle déclaration, le type de données des éléments de telles listes est déterminé lors de l'initialisation de la liste, c'est-à-dire lorsque des éléments y sont ajoutés.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Désormais, seules des chaînes peuvent être ajoutées à notre pile, des entiers à linkedList , des flottants à myVector et myList est une liste de caractères.

Comment fonctionne ArrayList

Si vous êtes déjà familiarisé avec les tableaux classiques, vous êtes également un peu familier avec ArrayList. En fait, ArrayList est un tableau dynamique, et à l'intérieur se trouve un tableau ordinaire. Ce tableau agit comme un magasin de données. ArrayList stocke uniquement les types de référence, tous les objets, y compris les classes tierces, les chaînes, les flux de sortie et d'autres collections. Les classes wrapper sont utilisées pour stocker des types de données primitifs dans ArrayList. Lors de la création d'une liste, nous pouvons immédiatement définir sa taille, mais dans la plupart des cas, nous ne le faisons pas. Par défaut, ArrayList size = 10. À quoi ressemble l'ajout d'un nouvel élément à une ArrayList ? Tout d'abord, une vérification est lancée pour voir s'il y a suffisamment d'espace dans le tableau interne et si un élément supplémentaire conviendra. S'il y a de l'espace, le nouvel élément est ajouté à la fin de la liste, c'est-à-dire à la cellule qui suit le dernier élément. Son index sera arraylist.size(). Si nous venons de créer notre liste et qu'elle est vide, cela signifie que arrayList.size() = 0. En conséquence, un nouvel élément sera ajouté à la cellule avec l'index 0. S'il s'avère qu'il n'y a pas assez d'espace, un nouveau array est créé à l'intérieur de la ArrayList avec la taille (la taille de OldArray * 1.5) + 1. Par le même principe, une insertion se produit au milieu de la liste, mais en même temps, tous les éléments qui suivent l'élément inséré sont déplacé vers la droite. Donc, si nous avons 5 éléments dans le tableau et que nous devons insérer un élément dans la cellule numéro 2 (c'est-à-dire la troisième), les éléments 0 et 1 du tableau restent en place, un nouvel élément apparaît dans la cellule 2, et son prédécesseur va à la troisième cellule et ainsi de suite.

Exemple de liste Java (réalisation d'Arraylist)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Voici la sortie de ce programme:

Comment fonctionne LinkedList

Dans une LinkedList, les éléments sont en fait des liens dans la même chaîne. Chaque élément, en plus des données qu'il stocke, a un lien vers l'élément précédent et suivant. Ces liens permettent de naviguer d'un élément à l'autre. L'itérateur prend en charge la traversée dans les deux sens. Implémente des méthodes pour obtenir, supprimer et insérer au début, au milieu et à la fin d'une liste. Vous permet d'ajouter n'importe quel élément, y compris null. LinkedList implémente deux interfaces - non seulement List, mais aussi Deque. Cela offre la possibilité de créer une file d'attente bidirectionnelle à partir de n'importe quel élément, même nul. Chaque objet placé dans la liste chaînée est un nœud (nœud). Chaque nœud contient un élément, un lien vers le nœud précédent et suivant. En fait, la liste chaînée est constituée d'une suite de nœuds dont chacun est destiné à stocker un objet du type défini lors de sa création.

Exemple de code

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

La sortie est ici :

Exemple de code vectoriel

Vector est également une réalisation de tableau dynamique et est très similaire à ArrayList, mais synchronisé et possède certaines méthodes héritées que le framework de collecte ne contient pas. Voici un exemple simple d'utilisation de cette classe.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

La sortie est :

Exemple de code de classe Java Stack

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Stack a non seulement les méthodes add() et remove() mais aussi push et pop, elles sont classiques pour une telle structure de données. La pile obéit à la règle "premier entré, dernier sorti" - c'est une telle anti-file d'attente. Par conséquent, l'opération pop fait apparaître l'élément qui a été placé en dernier sur la pile. Voici la sortie de notre exemple: