Liste Java – Liste en Java

Tutoriels

La liste Java est une collection ordonnée. La liste Java est une interface qui étend l’interface Collection. La liste Java permet de contrôler la position où vous pouvez insérer un élément. Vous pouvez accéder aux éléments par leur index et également rechercher des éléments dans la liste.

Liste Java

Voici quelques points importants sur la liste Java ;

  • L’interface List Java est un membre du Framework Collections Java.
  • La liste permet d’ajouter des éléments en double.
  • La liste permet d’avoir des éléments « null ».
  • L’interface List a reçu de nombreuses méthodes par défaut dans Java 8, par exemple replaceAll, sort et spliterator.
  • Les indices de la liste commencent à 0, tout comme les tableaux.
  • La liste prend en charge les génériques et nous devrions les utiliser chaque fois que possible. L’utilisation de génériques avec une liste évitera les ClassCastException à l’exécution.

Diagramme de classe de la liste Java

L’interface Java List étend l’interface Collection. L’interface Collection étend l’interface Iterable. Certaines des classes d’implémentation de List les plus utilisées sont ArrayList, LinkedList, Vector, Stack, CopyOnWriteArrayList. AbstractList fournit une implémentation squelettique de l’interface List pour réduire l’effort dans l’implémentation de List.

Méthodes de List Java

Certaines des méthodes utiles de List Java sont ;

  1. int size(): pour obtenir le nombre d’éléments dans la liste.
  2. boolean isEmpty(): pour vérifier si la liste est vide ou non.
  3. boolean contains(Object o): Renvoie true si cette liste contient l’élément spécifié.
  4. Iterator<E> iterator(): Renvoie un itérateur sur les éléments de cette liste dans la séquence appropriée.
  5. Object[] toArray(): Renvoie un tableau contenant tous les éléments de cette liste dans la séquence appropriée
  6. boolean add(E e): Ajoute l’élément spécifié à la fin de cette liste.
  7. boolean remove(Object o): Supprime la première occurrence de l’élément spécifié de cette liste.
  8. boolean retainAll(Collection<?> c): Conserve uniquement les éléments de cette liste qui sont contenus dans la collection spécifiée.
  9. void clear(): Supprime tous les éléments de la liste.
  10. E get(int index): Returns the element at the specified position in the list.
  11. E set(int index, E element): Replaces the element at the specified position in the list with the specified element.
  12. ListIterator<E> listIterator(): Retourne un itérateur de liste sur les éléments de la liste.
  13. List<E> subList(int fromIndex, int toIndex): Retourne une vue de la partie de cette liste entre l’indice fromIndex spécifié, inclusivement, et toIndex, exclusivement. La liste retournée est soutenue par cette liste, donc les modifications non structurales dans la liste retournée sont reflétées dans cette liste, et vice-versa.

Quelques-unes des méthodes par défaut ajoutées à List en Java 8 sont;

  1. default void replaceAll(UnaryOperator<E> operator): Remplace chaque élément de cette liste par le résultat de l’application de l’opérateur à cet élément.
  2. default void sort(Comparator<super E> c): Trie cette liste selon l’ordre induit par le comparateur spécifié.
  3. default Spliterator<E> spliterator(): Crée un séparateur sur les éléments de cette liste.

Tableau Java en Liste

Nous pouvons utiliser la classe Arrays pour obtenir la vue du tableau sous forme de liste. Cependant, nous ne pourrons pas effectuer de modification structurelle de la liste, cela générera une java.lang.UnsupportedOperationException. Ainsi, la meilleure façon est d’utiliser une boucle for pour créer une liste en itérant sur le tableau. Voici un exemple simple montrant comment convertir un tableau Java en liste correctement.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayToList {

	public static void main(String[] args) {
		
		String[] vowels = {"a","e","i","o","u"};
		
		List vowelsList = Arrays.asList(vowels);
		System.out.println(vowelsList);
		
		/**
		 * List is backed by array, we can't do structural modification
		 * Both of the below statements will throw java.lang.UnsupportedOperationException
		 */
		//vowelsList.remove("e");
		//vowelsList.clear();
				
		//utilisation d'une boucle for pour copier les éléments du tableau vers la liste, sûr pour la modification de la liste
		List myList = new ArrayList<>();
		for(String s : vowels){
			myList.add(s);
		}
		System.out.println(myList);
		myList.clear();
	}

}

Choisissez l’une des méthodes ci-dessus en fonction des besoins de votre projet.

Java Liste vers Tableau

A simple example showing the correct way to convert a list to array.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListToArray {

	public static void main(String[] args) {

		List letters = new ArrayList();

		// exemple d'ajout
		letters.add("A");
		letters.add("B");
		letters.add("C");
		
		//convertir liste en tableau
		String[] strArray = new String[letters.size()];
		strArray = letters.toArray(strArray);
		System.out.println(Arrays.toString(strArray)); //will print "[A, B, C]"
	}

}

Tri de Liste Java

Il existe deux façons de trier une liste. Nous pouvons utiliser la classe Collections pour un tri naturel ou nous pouvons utiliser la méthode List sort() et utiliser notre propre Comparateur pour le tri. Voici un exemple simple de tri de liste Java.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class ListSortExample {

	public static void main(String[] args) {
		
		List ints = new ArrayList<>();
		Random random = new Random();
		for (int i = 0; i < 10; i++) ints.add(random.nextInt(1000));
		
		//tri naturel en utilisant la classe Collections
		Collections.sort(ints);
		System.out.println("Natural Sorting: "+ints);
		
		//Mon tri personnalisé, ordre inverse
		ints.sort((o1,o2) -> {return (o2-o1);});
		System.out.println("Reverse Sorting: "+ints);
	}
}

A sample output is given below. Since I am using Random for generating list elements, it will be different every time.

Natural Sorting: [119, 273, 388, 450, 519, 672, 687, 801, 812, 939]
Reverse Sorting: [939, 812, 801, 687, 672, 519, 450, 388, 273, 119]

Opérations Courantes sur les Listes Java

Les opérations les plus courantes effectuées sur une liste Java sont l’ajout, la suppression, le réglage, le vidage, la taille, etc. Ci-dessous se trouve un exemple simple de liste Java montrant l’utilisation des méthodes courantes. 

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListExample {

	public static void main(String args[]) {
		List vowels= new ArrayList();
		
		//exemple d'ajout
		vowels.add("A");
		vowels.add("I");
		
		//insérons E entre A et I
		vowels.add(1,"E");
		System.out.println(vowels);
		
		List list = new ArrayList();
		list.add("O");list.add("U");
		
		//ajout des éléments de la liste à la variable "letters"
		vowels.addAll(list);
		System.out.println(vowels);
		
		//exemple de vidage pour vider la liste
		list.clear();
		
		//exemple de taille
		System.out.println("letters list size = "+vowels.size());
		
		//exemple de réglage
		vowels.set(2, "E");
		System.out.println(vowels);
		
		//exemple de sous-liste
		vowels.clear();vowels.add("E"); vowels.add("E");vowels.add("I"); vowels.add("O");
		list = vowels.subList(0, 2);
		System.out.println("letters = "+vowels+", list = "+list);
		vowels.set(0, "A");
		System.out.println("letters = "+vowels+", list = "+list);
		list.add("U");
		System.out.println("letters = "+vowels+", list = "+list);
		
		
	}

}

La sortie du programme d’exemple de liste Java ci-dessus est ;

[A, E, I]
[A, E, I, O, U]
letters list size = 5
[A, E, E, O, U]
letters = [E, E, I, O], list = [E, E]
letters = [A, E, I, O], list = [A, E]
letters = [A, E, U, I, O], list = [A, E, U]

Itérateur de liste Java

Voici un exemple simple montrant comment itérer sur une liste en Java. 

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListIteratorExample {

	public static void main(String[] args) {

		List list = new ArrayList<>();
		for(int i=0; i<5; i++) list.add(i);
		
		Iterator iterator = list.iterator();
		
		//itération simple
		while(iterator.hasNext()){
			int i = (int) iterator.next();
			System.out.print(i + ", ");
		}
		System.out.println("\n"+list);
		
		//modification de la liste en utilisant l'itérateur
		iterator = list.iterator();
		while(iterator.hasNext()){
			int x = (int) iterator.next();
			if(x%2 ==0) iterator.remove();
		}
		System.out.println(list);
		
		//modification de la structure de la liste tout en itérant
		iterator = list.iterator();
		while(iterator.hasNext()){
			int x = (int) iterator.next(); //ConcurrentModificationException here
			if(x==1) list.add(10);
		}
	}

}

La sortie du programme itérateur de liste Java ci-dessus est ;

0, 1, 2, 3, 4, 
[0, 1, 2, 3, 4]
[1, 3]
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.journaldev.examples.ListIteratorExample.main(ListIteratorExample.java:34)

C’est tout pour un bref aperçu des Listes en Java. J’espère que ces exemples de listes Java vous aideront à démarrer avec la programmation de collections de listes.

Source:
https://www.digitalocean.com/community/tutorials/java-list