Java >> Tutoriel Java >  >> Java

Listes Java (avec exemples)

Java

La classe List en Java permet de conserver une collection ordonnée. Il dispose de techniques basées sur l'index pour insérer, mettre à jour, supprimer et rechercher des éléments. Il peut également contenir des éléments redondants. Les éléments nuls peuvent également être stockés dans la liste.

L'interface Collection est héritée par l'interface List, située dans le package java.util. C'est une usine d'interface ListIterator. Nous pouvons parcourir la liste en avant et en arrière à l'aide de ListIterator. ArrayList, LinkedList, Stack et Vector sont l'interface List, les classes d'implémentation. En programmation Java, ArrayList et LinkedList sont couramment utilisés. Depuis Java 5, la classe Vector est obsolète.

Déclarations d'interface dans une liste

public interface List extends Collection

Liste des méthodes en Java

  • void add(int index, E element) - aide à insérer l'élément spécifié à la position donnée dans une liste.
  • boolean add(E e)- Il est utilisé pour ajouter l'élément spécifié à la fin d'une liste.
  • boolean addAll(Collection c) - Il est utilisé pour ajouter tous les éléments de la collection donnée à la fin des listes.
  • boolean addAll(int idx, Collection c) - Il est utilisé pour ajouter tous les éléments de la collection spécifiée, en commençant à la position spécifiée de la liste.
  • void clear()- Il est utilisé pour supprimer tous les éléments de cette liste.
  • boolean equals(Object o)- Il est utilisé pour comparer l'objet spécifié avec les éléments d'une liste.
  • int hashcode() – Il renvoie la valeur du code de hachage pour une liste.
  • E get(int index)- Il est utilisé pour récupérer l'élément à partir de la position particulière de la liste.
  • boolean isEmpty()- Il renvoie true si la liste est vide, sinon false.
  • int lastIndexOf(Object o)- Il est utilisé pour retourner l'index dans cette liste de la dernière occurrence de l'élément spécifié, ou -1 si la liste ne contient pas cet élément.
  • Object[] toArray()- Il est utilisé pour renvoyer un tableau contenant tous les éléments de cette liste dans le bon ordre.
  • T[] toArray(T[] a)- Il est utilisé pour renvoyer un tableau contenant tous les éléments de cette liste dans le bon ordre.
  • boolean contains(Object o)- Il renvoie true si la liste contient l'élément spécifié.
  • boolean containsAll(Collection c)- Il renvoie true si la liste contient tous les éléments spécifiés.
  • int indexOf(Object o) – Il est utilisé pour retourner l'index dans cette liste de la première occurrence de l'élément spécifié, ou -1 si la liste ne contient pas cet élément.
  • E remove(int index)- Il supprime l'élément présent à la position spécifiée dans la liste.
  • boolean remove(Object o)- Il est utilisé pour supprimer la première occurrence de l'élément spécifié.
  • boolean removeAll(Collection c)- Il est utilisé pour supprimer tous les éléments de la liste.
  • void replaceAll(UnaryOperator operator)- Il remplace tous les éléments de la liste par l'élément spécifié.
  • void keepAll(Collection c)- Il est utilisé pour conserver tous les éléments de la liste présents dans la collection spécifiée.
  • E set(int index, E element) est utilisé pour remplacer l'élément spécifié dans la liste, présent à la position spécifiée.
  • void sort(Comparator c) - Il est utilisé pour trier les éléments de la liste en fonction d'un comparateur spécifié.
  • Spliterator spliterator() est utilisé pour créer un séparateur sur les éléments d'une liste.
  • List subList(int fromIndex, int toIndex) - Il est utilisé pour récupérer tous les éléments dans la plage donnée.
  • int size()- Il renvoie le nombre d'éléments présents dans la liste.

ArrayList contre liste Java

ArrayList est la classe d'implémentation de List, qui est une interface.

Comment faire une liste

Voyons comment créer des objets ou des instances dans une classe List. Les objets de type list ne peuvent pas être créés puisque List est une interface. Nous avons toujours besoin d'une classe qui implémente cette liste pour construire un objet. De plus, depuis l'introduction des Génériques dans Java 1.5, il est également possible de limiter l'objet mis dans une Liste. La liste est une "interface" implémentée par la classe ArrayList, prédéfinie dans le package java.util, tout comme plusieurs autres "interfaces" définies par l'utilisateur implémentées par des "classes" définies par l'utilisateur.

L'interface List est implémentée par les classes ArrayList et LinkedList. Examinons quelques exemples de création d'une liste :

// Making use of ArrayList to create a List of type String
List stringList=new ArrayList();

//using ArrayList in creation of a List of type Integer
List integerList=new ArrayList();

//Creating a List of type Employee using ArrayList
List employeeList=new ArrayList();

//Creation of String a List using LinkedList
List linkedList=new LinkedList();

En un mot, vous pouvez créer n'importe quelle liste. Les types sont spécifiés à l'aide des classes ArrayList et LinkedList. La lettre T signifie type.

Exemple de liste Java

Regardons un exemple simple de List qui utilise la classe ArrayList comme implémentation.

ublic static void main(String args[]){
  
//Creating a List
List programmingLanguages=new ArrayList();
  
//Adding elements in the List
programmingLanguages.add("Java");
programmingLanguages.add("Python");
programmingLanguages.add("JavaScript");
programmingLanguages.add("Angular");
  
//Iterating the List element using for-each loop
for(String languages:programmingLanguages)
System.out.println(languages);
  
}
}

Comment changer un tableau en liste ?

En parcourant le tableau et en ajoutant chaque élément à la liste un par un, nous pouvons transformer le tableau en liste.
add() est une méthode pour ajouter des éléments à une liste. Regardons un exemple de conversion d'éléments de tableau en liste.

import java.util.*;

public class exampleArrayToList{
  
  public static void main(String args[]){
    
    //Creating Array
  	String[] programmingLanguages={"Java","JavaScript","Kotlin","Scala"};
  	System.out.println("Printing Array: "+Arrays.toString(programmingLanguages));
    
    // Array to List Conversion
    List languagesList=new ArrayList();
    for(String lang:programmingLanguages){
    languagesList.add(lang);
}
System.out.println("Programming Languages List: "+languagesList);
    
}
}

Comment transformer une liste en tableau ?

La méthode list.toArray() convertit une List en Array. Examinons un exemple rapide de conversion d'éléments de liste en tableaux.

import java.util.*;

public class exampleListToArray{
  
  static void main(String args[]){
  List companiesList = new ArrayList<>();
  companiesList.add("Microsoft");
  companiesList.add("Google");
  companiesList.add("Apple");
  companiesList.add("HP");
    
  // ArrayList to Array Conversion
String[] companiesArray = companiesList.toArray(new String[companiesList .size()]);
System.out.println("Array of Companies: "+Arrays.toString(companiesArray));
System.out.println("List of Companies: "+companiesList);
}
}

Utilisons maintenant l'interface de liste pour exécuter diverses opérations afin de mieux la comprendre. Nous discuterons des opérations répertoriées ci-dessous, puis les implémenterons à l'aide d'un code Java propre.

Opérations sur une interface de liste

Comme List est une interface, elle est utilisée avec une classe qui l'implémente. Voyons comment utiliser la liste pour accomplir quelques opérations quotidiennes.

  • Opération 1 :Utiliser la fonction add() pour ajouter des entrées à la classe List
  • Opération 2 :Utiliser la fonction set() pour mettre à jour les membres dans la classe List
  • Opération 3 :Utiliser la fonction remove() pour supprimer des éléments

Maintenant, décomposons chaque opération et voyons comment nous pouvons l'implémenter dans le code pour mieux la comprendre.

Utiliser la fonction add() pour ajouter des entrées à la classe List

La méthode add() ajoute un nouvel élément à la liste. Cette dernière méthode est surchargée avec la capacité d'accomplir plusieurs opérations basées sur divers arguments.

Paramètres

Il nécessite deux paramètres comme suit :

  • add(Object) :cette méthode ajoute un nouvel élément à la fin de la liste.
  • add(int index, Object) :cette méthode ajoute un élément à la liste à un index donné.
// Java Program that Adds Elements to a List
// Importing all utility classes

import java.util.*;

// Main class
class listIntefaceClass {

public static void main(String args[])
{
    // Creation of an object of List interface, implemented by ArrayList class
    List<String> codeLanguages = new ArrayList<>();

    // Adding elements to object of List interface
    // Custom elements
    codeLanguages.add("Django");
    codeLanguages.add("Flask");
    codeLanguages.add(1, "Bottle");

    // Printing every elements inside the List interface object
    System.out.println(codeLanguages);
}
}

Mise à jour des éléments

Étant donné que List est indexé, l'élément que nous voulons modifier est référencé par l'index de l'élément. Par conséquent, il nécessite un index et l'élément modifié doit être inséré à cet index. Si nous voulons mettre à jour un élément après son ajout, nous pouvons utiliser la méthode set().

// Java Program for Updating List Elements

// Importing utility classes
import java.util.*;

// Main class
class listIntefaceClass {

	// Main driver method
	public static void main(String args[])
	{
		// Creating an object of List interface
		List<String> codeLanguages = new ArrayList<>();

		// Adding elements to object of List class
		codeLanguages.add("Django");
		codeLanguages.add("Flask");
		codeLanguages.add(1, "Bottle");

		// Display theinitial elements in List
		System.out.println("Initial ArrayList " + al);

		//  use set() to update element at 1st index
		codeLanguages.set(1, "Python");

		// finally Print and display the new updated List
		System.out.println("Updated ArrayList is : " + codeLanguages);
	}
}

Supprimer des éléments

La fonction remove() est responsable de la suppression d'un élément d'une liste. Cette méthode est surchargée avec la possibilité d'effectuer plusieurs opérations basées sur divers arguments. Ils sont les suivants :

Paramètres :

remove(Object) :la méthode remove(Object) est utilisée pour supprimer un objet d'une liste. S'il existe plusieurs instances du même élément, la première est éliminée.

Comme une liste est indexée, remove(int index) prend une valeur entière qui élimine l'élément à cet index précis dans la liste. Après avoir supprimé un élément, tous les autres éléments sont déplacés vers la gauche pour couvrir l'espace et les indices d'objet sont mis à jour.

// Java Program for Removing Items from a List

// Importing List and ArrayList classes
// from java.util package
import java.util.ArrayList;
import java.util.List;

// Main class
class listIntefaceClass {

	public static void main(String args[])
	{

		// Creating List class object
		List<String> codeLanguages = new ArrayList<>();

		// Adding elements to the object
		// Custom inputs
		codeLanguages.add("Django");
		codeLanguages.add("Django");
		codeLanguages.add(1, "Bottle");

		// Adding For at 1st indexes
		codeLanguages.add(1, "Python");

		// Printing the initial ArrayList
		System.out.println("The Initial ArrayList is: " + codeLanguages);

		// remove  theelement from the above list that is present at 1st index
		codeLanguages.remove(1);

		// Print the List after removal of the element
		System.out.println("After the Index Removal: " + codeLanguages);

		// Now remove the current object from the updated
		// List
		codeLanguages.remove("Django");

		// Finally, print the updated List now
		System.out.println("After the Object Removal "+ codeLanguages);
	}
}

Obtenir et définir un élément de liste

La méthode get() récupère l'élément à l'index spécifié, tandis que la méthode set() le modifie ou le remplace.

import java.util.*;
 
public class exampleGetSetList{  
 public static void main(String args[]){  
 // List  Creation
 List<String> subjectList=new ArrayList<String>();  

 //Addition of elements to the List  
 subjectList.add("Databases");  
 subjectList.add("Machine Learning");  
 subjectList.add("Data Structures & Algorithms");  
 subjectList.add("Operating Systems");  

 //illustrating how to access an element    
 System.out.println("Returning element: "+subjectList .get(1));//it will return the 2nd element, because index starts from 0  

 //illustrating how to change the element  
 subjectList.set(1,"Dates");  

 //Iterating the Subject List elements using for-each loop  
 for(String subjects:subjectList)  
  System.out.println(subjects);  
  
 }  
}

Trier une liste

Il existe différentes méthodes pour trier une liste ; dans ce cas, nous utiliserons la méthode Collections.sort() pour trier l'élément de la liste. Collections est une classe utilitaire dans le package java.util qui a la méthode statique sort(). Nous pouvons rapidement trier n'importe quelle liste avec la fonction Collections.sort().

import java.util.*;  
class exampleSortingArrayList{  
 public static void main(String args[]){  

  //Creation of a list containing subjects for students to choose from  
  List<String> subjectList=new ArrayList<String>();  
  subjectList.add("Data Structures & Algorithms");  
  subjectList.add("Databases");  
  subjectList.add("Machine Learning");  
  subjectList.add("Introduction to computers");  

  // illustrating sorting the subjects list  
  Collections.sort(subjectList);  

   //illustrating traversing the subject list using for-each loop  
  for(String subj:subjectList)  
    System.out.println(subj);  
      
 System.out.println("Demonstrating how to sorting numbers");  

  //Creating a list of numbers  
  List<Integer> numberList=new ArrayList<Integer>();  
  numberList.add(59);  
  numberList.add(12);  
  numberList.add(98);  
  numberList.add(33);  

  //illustrating sorting the number list  
  Collections.sort(numberList);  

   // illustrating subject traversal using the for-each loop  
  for(Integer num:numberList)  
    System.out.println(num);  
 }  
   
}

Interface pour un ListIterator Java

L'interface ListIterator est utilisée pour parcourir l'élément en avant et en arrière.

Déclaration de l'interface ListIterator

public interface ListIterator extends Iterator

Méthodes d'interface ListIterator en Java

  • void add(E e) – Cette méthode insère l'élément spécifié dans la liste.
  • booléen hasNext() - Il renvoie vrai si l'itérateur de liste a plus d'éléments tout en parcourant la liste dans le sens avant.
  • E next() – Cette méthode renvoie l'élément suivant dans la liste et fait avancer la position du curseur.
  • int nextIndex()- Cette méthode renvoie l'index de l'élément qui serait renvoyé par un appel ultérieur à next()
  • boolean hasPrevious() - Cette méthode renvoie true si l'itérateur a plus d'éléments tout en parcourant la liste dans le sens inverse.
  • E precedent()- Cette méthode renvoie le dernier élément de la liste et déplace la position du curseur vers l'arrière.
  • E previousIndex()- Cette méthode renvoie l'index de l'élément renvoyé par un appel ultérieur à previous().
  • void remove() – Cette méthode supprime le dernier élément de la liste renvoyé par les méthodes next() ou previous()
  • void set(E e) – Cette méthode remplace le dernier élément renvoyé par les méthodes next() ou previous() par l'élément spécifié.

Exemple d'interface ListIterator 

import java.util.*;  

public class exampleListIterator{  
public static void main(String args[]){  

List<String> citiesList =new ArrayList<String>();    
        citiesList.add("New York");    
        citiesList.add("London");    
        citiesList.add("Los Angeles");    
        citiesList.add("Daka");    

        ListIterator<String> listIterator=al.listIterator();    
        System.out.println("Elements Traversal in forward direction");    
        while(listIterator .hasNext()){    
              
        System.out.println("index is:"+listIterator .nextIndex()+" value is:"+listIterator .next());    
        }    
        System.out.println("Elements Traversal in backward direction");    
        while(listIterator .hasPrevious()){    
          
        System.out.println("index is:"+listIterator .previousIndex()+" value:"+listIterator .previous());    
        }    
}  
}

Employé comme exemple de liste

Regardons un exemple de liste dans laquelle nous ajoutons des employés.

import java.util.*;  
class Employee {  
int id;  
String firstname,lastname,gender;  
int age;  
public Employee(int id, String firstname, String lastname, String gender, int age) {  
    this.id = id;  
    this. firstname = firstname;  
    this. lastname = lastname;  
    this. gender = gender;  
    this. age = age;  
}  
}  
public class exampleLis {  
public static void main(String[] args) {  
    //Creating list of Employees  
    List<Employee> employeesList=new ArrayList<Employee>();  

    //Creating Employees  
    Employee empOne=new Employee(10,"Thompson","Yale","Male",18);  
    Employee empTwo=new Employee(20,"Ann","Forouz","Female",14);  
    Employee empThree=new Employee(30,"Jerry ","Tom","Male",16);  

    //Adding Employee to list  

    employeesList.add(empOne);  
    employeesList.add(empTwo);  
    employeesList.add(empThree);  

    //Employee List Traversal  
    for(Employee emp:employeesList){  
    System.out.println(emp.id+" "+emp.name+" "+emp.author+" "+emp.publisher+" "+emp.quantity);  
    }  
}  
}

Conclusion

L'interface Liste est utilisée pour garder une trace de la commande de la collection. Il s'agit de l'interface enfant d'une collection. De plus, il s'agit d'une collection triée d'objets pouvant stocker des valeurs en double. La liste prend en charge l'accès positionnel et l'insertion de membres car l'ordre d'insertion est préservé.


Balise Java