java list methods sort list
Ce didacticiel explique diverses méthodes de liste Java telles que la liste de tri, la liste contient, l'ajout de liste, la suppression de liste, la taille de la liste, AddAll, RemoveAll, la liste inversée, etc.
Nous avons déjà discuté de l'interface de liste en général dans notre précédent tutoriel. L'interface de liste a diverses méthodes qui sont utilisées pour manipuler le contenu de la liste. En utilisant ces méthodes, vous pouvez insérer / supprimer, trier et rechercher des éléments dans la liste.
Dans ce tutoriel, nous aborderons toutes les méthodes fournies par l'interface de liste.
=> Cliquez ici pour voir de A à Z des didacticiels de formation Java ici.
Pour parcourir la liste, l'interface de liste utilise l'itérateur de liste. Cet itérateur de liste s'étend de l'interface de l'itérateur. Dans notre prochain tutoriel, nous explorerons plus en détail l'itérateur de liste.
Ce que vous apprendrez:
- Liste des méthodes en Java
- Supprimer les doublons d'une liste en Java
- Questions fréquemment posées
- Conclusion
- lecture recommandée
Liste des méthodes en Java
Le tableau suivant présente diverses fonctions fournies par l'interface de liste en Java.
| Méthode de liste | Prototype de méthode | Description |
|---|---|---|
| contient | boolean contient (Object o) | Vérifie si l'élément spécifié est présent dans la liste et renvoie true s'il est présent |
| Taille | taille int () | Renvoie la taille de la liste, c'est-à-dire le nombre d'éléments dans la liste ou la longueur de la liste. |
| dégager | vide clair () | Efface la liste en supprimant tous les éléments de la liste |
| ajouter | void add (index int, élément Object) | Ajoute l'élément donné à la liste à l'index donné |
| boolean add (objet o) | Ajoute l'élément donné à la fin de la liste | |
| tout ajouter | booléen addAll (Collection c) | Ajoute toute la collection donnée à la fin de la liste |
| booléen addAll (index int, Collection c) | Insère la collection donnée (tous les éléments) dans la liste à l'index spécifié | |
| contientTout | booléen contientAll (Collection c) | Vérifie si la collection spécifiée (tous les éléments) fait partie de la liste. Renvoie vrai de yes. |
| équivaut à | booléen est égal à (objet o) | Compare l'objet spécifié pour l'égalité avec les éléments de la liste |
| Obtenir | Objet get (index int) | Renvoie l'élément de la liste spécifié par index |
| hashCode | int hashCode () | Renvoie la valeur de code de hachage de la liste. |
| indexOf` | int indexOf (objet o) | Recherche la première occurrence de l'élément d'entrée et renvoie son index |
| est vide | booléen isEmpty () | Vérifie si la liste est vide |
| lastIndexOf | int lastIndexOf (objet o) | Recherche la dernière occurrence de l'élément d'entrée dans la liste et renvoie son index |
| supprimer | Suppression d'objet (index int) | Supprime l'élément à l'index spécifié |
| boolean remove (objet o) | Supprime l'élément à sa première occurrence dans la liste | |
| Enlever tout | booléen removeAll (Collection c) | Supprime tous les éléments contenus dans la collection spécifiée de la liste |
| retenirTout | booléen retentionAll (Collection c) | À l'opposé de removeAll. Conserve l'élément spécifié dans la collection d'entrée dans la liste. |
| Ensemble | Ensemble d'objets (index int, élément Object) | Modifie l'élément à l'index spécifié en le définissant sur la valeur spécifiée |
| sous-liste | Liste des sous-listes (int fromIndex, int toIndex) | Renvoie la sous-liste d'éléments entre fromIndex (inclus) et toIndex (exclusif). |
| Trier | tri vide (comparateur c) | Trie l'élément de liste selon le comparateur spécifié pour donner une liste ordonnée |
| toArray | Object () toArray () | Renvoie une représentation sous forme de tableau de la liste |
| Object () toArray (Object () a) | Renvoie la représentation de tableau dont le type d'exécution est le même qu'un argument de tableau spécifié | |
| itérateur | Itérateur itérateur () | Renvoie un itérateur pour la liste |
| listIterator | ListIterator listIterator () | Renvoie un ListIterator pour la liste |
| ListIterator listIterator (index int) | Renvoie un ListIterator commençant à l'index spécifié dans la liste |
Ensuite, nous discuterons de ces fonctions avec leurs exemples.
Taille
Prototype: taille int ()
Paramètres: NÉANT
Valeur de retour: int => Nombre d'éléments dans la liste ou en d'autres termes la longueur de la liste.
Description: La taille () renvoie le nombre d'éléments ou la taille de la liste. Il peut également être appelé longueur en termes simples.
dégager
Prototype: vide clair ()
Paramètres: NÉANT
Valeur de retour: Aucune valeur de retour
Description: Efface la liste en supprimant tous les éléments de la liste. Lance «UnSupportedException» si l'opération n'est pas prise en charge par la liste.
L'exemple ci-dessous montre les méthodes size () et clear ().
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list //add items to list strList.add('Java'); strList.add('C++'); //print the size of list System.out.println('Size of list:' + strList.size()); //add more items to list strList.add('Ruby'); strList.add('Python'); strList.add('C#'); //print the size of list again System.out.println('Size of list after adding more elements:' + strList.size()); //clear method strList.clear(); System.out.println('List after calling clear() method:' + strList); } } Production:
ajouter
Prototype: void add (index int, élément Object)
Paramètres: index - une position à laquelle l'élément doit être ajouté.
Élément - l'élément à ajouter
Valeur de retour: annuler
Description: Ajoute l'élément donné à la liste à l'index donné. Les éléments suivants sont décalés vers la droite.
Les exceptions suivantes sont levées:
IndexOutOfBoundsException: L'index de la liste est hors limites
UnsupportedOperationException: L'opération d'ajout n'est pas prise en charge par la liste.
ClassCastException: L'élément ne peut pas être ajouté à la liste en raison de la classe des éléments spécifiés.
Exception d'argument illégal: L'élément spécifié ou un aspect n'est pas correct.
Ajouter
Prototype: boolean add (objet o)
Paramètres: o => Élément à ajouter à la liste
Valeur de retour: true => Élément ajouté avec succès
False => Ajout échoué
Description: Cette méthode ajoute l'élément donné à la fin de la liste.
Cette opération peut lever les exceptions suivantes.
UnsupportedOperationException: Ajouter une opération non prise en charge par cette liste.
ClassCastException: L'élément spécifié ne peut pas être ajouté en raison de sa classe
Exception d'argument illégal: L'élément spécifié ou un aspect n'est pas correct.
avantages et inconvénients de Linux vs Windows
tout ajouter
Prototype: booléen addAll (Collection c)
Paramètres: c => Collection dont les éléments doivent être ajoutés à la liste
Valeur de retour: true => Exécution de la méthode réussie
Description: La méthode addAll prend tous les éléments de la collection c et les ajoute à la fin de la liste en conservant l'ordre qui a été défini.
Cette méthode présente un comportement non spécifié si la collection est modifiée lorsque l'opération est en cours.
La méthode lève les exceptions suivantes:
UnsupportedOperationException: Ajouter une opération non prise en charge par cette liste.
ClassCastException: L'élément spécifié ne peut pas être ajouté en raison de sa classe.
Exception d'argument illégal: L'élément spécifié ou un aspect n'est pas correct.
tout ajouter
Prototype: booléen addAll (index int, Collection c)
Paramètres: index => Position à laquelle la collection doit être insérée.
C => Collection à insérer dans la liste.
Valeur de retour: true => Si les éléments de collection sont ajoutés avec succès à la liste.
Description: La méthode addAll insère tous les éléments de la collection spécifiée dans la liste à l'index spécifié. Les éléments suivants sont ensuite décalés vers la droite. Comme dans le cas de la surcharge précédente de addAll, le comportement n'est pas spécifié si la collection est modifiée lorsque l'opération est en cours.
Les exceptions levées par cette méthode sont:
UnsupportedOperationException: Ajouter une opération non prise en charge par cette liste.
ClassCastException: L'élément spécifié ne peut pas être ajouté en raison de sa classe.
Exception d'argument illégal: L'élément spécifié ou un aspect n'est pas correct.
IndexOutOfBoundsException: Index hors de portée.
Le programme ci-dessous montre la démonstration des méthodes add et addAll de la liste.
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list strList.add('Java'); strList.add('C++'); //print the list System.out.println('List after adding two elements:' + strList); List llist = new ArrayList(); // Create another list llist.add('Ruby'); llist.add('Python'); llist.add('C#'); // addAll method - add llist to strList strList.addAll(llist); System.out.println('List after addAll:'+ strList); } } Production:
contient
Prototype: boolean contient (Object o)
Paramètres: o => Élément à rechercher dans la liste.
Valeur de retour: true => Si la liste contient l'élément spécifié.
Description: La méthode 'contient' vérifie si l'élément spécifié est présent dans la liste et renvoie une valeur booléenne true si l'élément est présent. Sinon, il renvoie false.
contientTout
Prototype: booléen contientAll (Collection c)
Paramètres: c => Collection à rechercher dans la liste.
Valeur de retour: true => Si tous les éléments de la collection spécifiée sont présents dans la liste.
Description: La méthode «containsAll» vérifie si tous les éléments présents dans la collection spécifiée sont présents dans la liste. S'il est présent, il renvoie une valeur vraie et false dans le cas contraire.
Le programme Java suivant illustre l’utilisation des méthodes ‘contains’ et ‘containsAll’ de la liste.
import java.util.*; public class Main { public static void main(String() args) { //define list of strings List list = new ArrayList(); //initialize list to strings list.add('Java'); list.add('Xml'); list.add('Python'); list.add('Ruby'); list.add('JavaScript'); //contains method demo if(list.contains('C')==true) System.out.println('Given list contains string 'C''); else if(list.contains('Java')==true) System.out.println('Given list contains string 'Java' but not string 'C''); //containsAll method demo List myList = new ArrayList(); myList.add('Ruby'); myList.add('Python'); if(list.containsAll(myList)==true) System.out.println('List contains strings 'Ruby' and 'Python''); } }Production:
La liste donnée contient la chaîne «Java» mais pas la chaîne «C»
La liste contient les chaînes 'Ruby' et 'Python'
équivaut à
Prototype: booléen est égal à (objet o)
Paramètres: o => L'objet dont l'égalité doit être testée.
Valeur de retour: true => Si l'objet donné est égal à la liste.
Description: Cette méthode est utilisée pour comparer l'objet donné avec la liste d'égalité. Si l'objet spécifié est une liste, la méthode renvoie true. Les deux listes sont dites égales si et seulement si elles sont de même taille et que les éléments correspondants dans les deux listes sont égaux et dans le même ordre.
Une démonstration de la méthode égale est donnée ci-dessous:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //define lists List first_list= new LinkedList(); List second_list = new LinkedList(); List third_list = new LinkedList(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println('First list: ' + first_list); System.out.println('Second list: ' + second_list); System.out.println('Third list: ' + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println('
first_list and second_list are equal.
'); else System.out.println('first_list and second_list are not equal.
'); if(first_list.equals(third_list)) System.out.println('first_list and third_list are equal.
'); else System.out.println('first_list and third_list are not equal.
'); if(second_list.equals(third_list)) System.out.println('second_list and third_list are equal.
'); else System.out.println('second_list and third_list are not equal.
'); } } Production:
Obtenir
Prototype: Objet get (index int)
Paramètres: index => Position à laquelle l'élément doit être renvoyé.
Valeur de retour: object => Élément à la position spécifiée.
Description: La méthode get () retourne l'élément à la position donnée.
Cette méthode lève «indexOutOfBoundsException» si l'index spécifié est hors de la plage de la liste.
Ensemble
Prototype: Ensemble d'objets (index int, élément Object)
Paramètres: index => Position à laquelle le nouvel élément doit être défini.
element => Nouvel élément à placer à la position donnée par index.
Valeur de retour: Object => Élément qui a été remplacé
Description: La méthode set () remplace l'élément à l'index donné par une autre valeur donnée par element.
La méthode peut lever les exceptions suivantes:
quelle est votre clé de sécurité réseau
UnsupportedOperationException: L'opération Set n'est pas prise en charge par la liste.
ClassCastException: L'opération ne peut pas être effectuée en raison de la classe de l'élément
Exception d'argument illégal: Un argument ou un aspect de celui-ci est illégal
IndexOutOfBoundsException: Index hors de portée.
Le programme suivant montre un exemple de méthode get () et set ().
import java.util.*; public class Main { public static void main(String() args) { //define list List listA = new ArrayList(); listA.add('Java'); listA.add('C++'); listA.add('Python'); //access list elements using index with get () method System.out.println('Element at index 0:' + listA.get(0)); System.out.println('Element at index 1:' + listA.get(1)); System.out.println('Element at index 2:' + listA.get(2)); //set element at index 1 to Ruby listA.set(1,'Ruby'); System.out.println('Element at index 1 changed to :' + listA.get(1) ); } } Production:
hashCode
Prototype: int hashCode ()
Paramètres: NÉANT
Valeur de retour: int => hashCode de la liste
Description: La méthode «hashCode ()» renvoie le hashCode de la liste qui est une valeur entière.
Exemple:
import java.util.*; public class Main { public static void main(String() args) { // Initializing a list of type Linkedlist List mylist = new LinkedList(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println('The list:' + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println('Hashcode for list:' + hash); } } Production:
est vide
Prototype: booléen isEmpty ()
Paramètres: NÉANT
Valeur de retour: true => La liste est vide
Description: La méthode ‘isEmpty ()’ vérifie si la liste est vide. La méthode IsEmpty est utilisée pour vérifier si la liste contient des éléments avant de commencer à traiter ces éléments.
Indice de
Prototype: int indexOf (objet o)
Paramètres: o => élément à rechercher dans la liste
Valeur de retour: int => l'index ou la position de la première occurrence de l'élément donné dans la liste. Renvoie -1 si l'élément n'est pas présent.
Description: La méthode «indexOf ()» renvoie l’index de la première occurrence de l’élément o donné dans la liste. Si l'élément n'est pas trouvé, il renvoie -1.
lastIndexOf
Prototype: int lastIndexOf (objet o)
Paramètres: o => Objet dont l'index doit être recherché
Valeur de retour: int => Index de la dernière occurrence de l'élément donné dans la liste, -1 sinon.
Description: La méthode ‘lastIndexOf ()’ renvoie l’index de la dernière occurrence de l’élément o dans la liste. Si l'élément n'est pas trouvé, la méthode renvoie -1.
Le programme Java ci-dessous illustre l'utilisation des méthodes indexOf et lastIndexOf de la liste.
import java.util.*; public class Main { public static void main(String() args) { // define an integer array List intList = new ArrayList(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println('The list of integers:' + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println('first index of 20:' + intList.indexOf(20)); System.out.println('last index of 10:' + intList.lastIndexOf(10)); } } Production:
supprimer
Prototype: Suppression d'objet (index int)
Paramètres: index => Index ou position dans la liste à laquelle l'élément doit être supprimé
Valeur de retour: Object => Élément supprimé
Description: La méthode ‘remove ()’ supprime l’élément à la position donnée de la liste. Après la suppression, les éléments à côté de l'élément supprimé sont décalés vers la gauche.
Cette méthode peut lever les exceptions suivantes:
UnsupportedOperationException: La suppression n'est pas prise en charge par la liste.
IndexOutOfBoundsException: L'index spécifié est hors limites
supprimer
Prototype: boolean remove (objet o)
Paramètres: o => Élément à supprimer de la liste
Valeur de retour: true => L'élément a été supprimé avec succès.
Description: Cette version surchargée de la méthode remove () supprime la première occurrence d'un élément donné o de la liste. Si l'élément donné n'est pas présent dans la liste, il reste inchangé.
Cette méthode peut lever l'exception suivante:
UnsupportedOperationException: La suppression n'est pas prise en charge par la liste.
Enlever tout
Prototype: booléen removeAll (Collection c)
Paramètres: c => Une collection qui contient des éléments supprimés de la liste.
Valeur de retour: true => Si l'appel de méthode réussit et que tous les éléments spécifiés dans la collection c sont supprimés de la liste.
Description: La méthode ‘removeAll ()’ est utilisée pour supprimer tous les éléments de la liste qui sont spécifiés dans la collection c qui est passée en argument.
Cette méthode peut lever l'exception suivante:
UnsupportedOperationException: removeAll n'est pas pris en charge par la liste.
Voyons un exemple de méthodes remove et removeAll.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); // Removes element from index 1 oddList.remove(1); System.out.println('Oddlist after removing element at index 1:' + oddList); //removeAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println('Oddlist after removing elements {1,5,11}}:' + oddList); } } Production:
retenirTout
Prototype: booléen retentionAll (Collection c)
Paramètres: c => Collection contenant les éléments à conserver dans la liste.
Valeur de retour: true => Si l'appel de méthode a changé la liste.
Description: Cette méthode supprime tous les éléments de la liste à l'exception de ceux qui sont présents dans la collection c. En d'autres termes, cette méthode conserve tous les éléments de la liste qui sont présents dans la collection c et supprime les autres éléments.
Cette méthode peut lever l'exception suivante:
UnsupportedOperationException: keepAll n'est pas pris en charge par la liste.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); //retainAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println('Oddlist after call to retainAll (1,5,11):' + oddList); } } Production:
sous-liste
Prototype: Liste des sous-listes (int fromIndex, int toIndex)
Paramètres: fromIndex => Index inférieur de la liste (inclus)
toIndex => Index supérieur de la liste (exclusif)
Valeur de retour: List => Une sous-liste de la liste donnée
Description: La méthode sublist () renvoie la vue partielle de la liste, également appelée sous-liste de «fromIndex» à «toIndex». La sous-liste renvoyée est juste une vue de la liste parente et donc toutes les modifications apportées à l'une ou l'autre des listes se reflètent partout.
De même, toutes les opérations de la liste fonctionnent également sur une sous-liste.
La méthode peut lever l'exception suivante:
IndexOutOfBoundsException: Valeur toIndex illégale.
Un exemple de programme pour la méthode de sous-liste est donné ci-dessous.
import java.util.*; public class Main { public static void main(String() args) { // define a string list List strList = new ArrayList(5); //add elements to the list strList.add('Java'); strList.add('Tutorials'); strList.add('Collection'); strList.add('Framework'); strList.add('Series'); //print the original list System.out.println('The original list=>strList: ' + strList); //define another list List subList = new ArrayList(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println('The sublist of strList:' + subList); } } Production:
liste de tri
Prototype: tri vide (comparateur c)
Paramètres: c => Comparateur sur la base duquel la liste est triée.
Valeur de retour: NÉANT
Description: La méthode «sort ()» est utilisée pour trier la liste. La méthode utilise le comparateur spécifié pour trier la liste.
Voyons un exemple de la méthode de tri . Nous l'avons comparé à la méthode Collections.sort qui trie les éléments dans une séquence naturelle. La sortie du programme est une liste ordonnée.
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String() args) { //define list List intArray = new ArrayList(); Random random = new Random(); //populate the list with random numbers <20 for (int i = 0; i {return (o2-o1);}); //comparator to sort in reverse System.out.println('Reverse List sorted using comparator:
'+intArray); } }Production:
toArray
Prototype: Object () toArray ()
Paramètres: NÉANT
Valeur de retour: Object () => Représentation tableau de la liste
Description: La méthode toArray () renvoie la représentation sous forme de tableau de la liste dans un ordre approprié.
toArray
Prototype: Object () toArray (Object () a)
Paramètres: a => Type de tableau qui doit être mis en correspondance avec les types d'éléments de liste lors de la conversion de la liste en tableau.
Valeur de retour: Object () => Représentation tableau de la liste.
Description: Cette surcharge de la méthode toArray () retourne le tableau contenant les éléments de la liste qui ont le même type d'exécution que celui du tableau a.
Cette méthode peut lever l'exception suivante:
ArrayStoreException: Le type d'exécution de chaque élément de la liste n'est pas un sous-type du type d'exécution de chaque élément de cette liste.
Voici un exemple de l'implémentation de la méthode toArray.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('Size of the colorsList: ' + colorsList.size()); // Print the colors in the list System.out.println('Contents of colorsList:'); for (String value : colorsList){ System.out.print(value + ' '); } // Create an array from the list using toArray method String colorsArray() = new String(colorsList.size()); colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println('
Printing elements of colorsArray:' + Arrays.toString(colorsArray)); } }Production:
Itérateur
Prototype: Itérateur itérateur ()
Paramètres: NÉANT
Valeur de retour: Iterator => Itérateur pour itérer sur les éléments de la liste
Description: Cette méthode retourne l'itérateur qui itère sur les éléments de la liste.
Programme Java pour illustrer l'utilisation de l'itérateur.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('ColorList using iterator:'); //define iterator for colorsList Iterator iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } } Production:
listIterator
Prototype: ListIterator listIterator ()
Paramètres: NÉANT
Valeur de retour: ListIterator => Listiterator des éléments de la liste.
Description: La méthode listIterator () retourne l'objet ListIterator des éléments de la liste. Cet itérateur commence au début de la liste, c'est-à-dire l'index 0.
listIterator
Prototype: ListIterator listIterator (index int)
Paramètres: index => Position à laquelle commence listIterator.
Valeur de retour: ListIterator => Objet ListIterator à l'index spécifié dans la liste.
Description: La surcharge de la méthode listIterator () renvoie un listIterator qui commence à la position donnée dans la liste. L'index donné indique que ce sera le premier élément qui sera retourné par le premier appel à la méthode nextElement () de ListIterator.
La méthode peut lever IndexOutOfBoundsException pour la valeur non valide de l'index.
L'exemple suivant illustre l'utilisation de listIterator.
import java.util.*; public class Main { public static void main(String() args) { //define list & add items to list List nameList = new LinkedList(); nameList.add('Java'); nameList.add('C++'); nameList.add('Python'); // get listIterator for the list ListIterator namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println('Contents of list using listIterator:'); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + ' '); } } } Production:
Nous discuterons de ListIterator en détail plus tard.
Voyons maintenant quelques-unes des opérations diverses qui peuvent être effectuées sur des listes mais des méthodes pour lesquelles ne sont pas fournies dans l'interface de liste.
Copier la liste en Java
Pour copier des éléments d'une liste dans une autre liste, vous devez utiliser la méthode copy () fournie par le framework Collections.
La méthode Collections.copy () copie tous les éléments de la liste fournie comme deuxième argument, dans la liste fournie comme premier argument. Notez que la liste dans laquelle le contenu d'une autre liste est en cours de copie doit être suffisamment grande pour contenir les éléments copiés.
Si la liste n'est pas assez grande, la méthode de copie lève «indexOutOfBoundsEexception».
Le programme suivant copie le contenu d'une liste dans une autre.
import java.util.*; public class Main { public static void main(String() args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add('R'); aList_1.add('G'); aList_1.add('B'); //print the List System.out.println('The first list:' + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add('Red'); aList_2.add('Green'); aList_2.add('Blue'); aList_2.add('Yellow'); aList_2.add('Brown'); System.out.println('The second list: ' + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println('
The second list after copying first list to second list: ' + aList_2); } } Production:
Supprimer les doublons d'une liste en Java
Une liste donnée peut ou non contenir des éléments répétitifs ou des doublons. Si la liste avec laquelle vous travaillez contient des éléments en double et que vous souhaitez que tous les éléments distincts figurent dans la liste, il existe deux méthodes pour supprimer les doublons de la liste prise en charge par Java.
Utilisation du flux Java 8
La première méthode pour supprimer les doublons de la liste consiste à utiliser la méthode distinct () fournie par Java 8 stream. Ici, la liste contenant les doublons appelle la méthode stream () .distinct puis la valeur de retour est convertie en une nouvelle liste qui n'aura que les éléments distincts.
Le programme suivant illustre l'utilisation de la méthode distinct ().
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String() args) { // original list List intlist = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println('Original ArrayList: ' + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println('ArrayList after removing duplicates: ' + distinct_list); } } Production:
Utilisation de l'approche Iterator
La suppression des doublons de la liste à l'aide de l'itérateur est une approche longue et primitive. Dans cette approche, vous devez parcourir la liste et placer la première occurrence de chaque élément dans une nouvelle liste. Chaque élément suivant est vérifié s'il s'agit d'un doublon.
Le programme ci-dessous y parvient.
import java.util.*; public class Main { public static void main(String args()) { // create original list ArrayList aList = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println('Original List: '+ aList); // Create a new list ArrayList new_List = new ArrayList(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println('List after removing duplicates: '+ new_List); } } Production:
Questions fréquemment posées
Q # 1) Quelle est la méthode get dans la liste en Java?
Répondre: La méthode Get de la liste est utilisée pour récupérer un élément particulier de la liste en fonction de l'index. Vous transmettez l'index requis à la méthode get et la méthode get renverra la valeur de l'élément à cet index.
Q # 2) Quelle est la méthode toArray en Java?
Répondre: La méthode toArray () est utilisée pour obtenir la représentation tableau de la liste.
Q # 3) Comment trier une liste en Java?
Répondre: En Java, une liste peut être triée en utilisant la méthode de tri de la liste. Vous pouvez transmettre vos propres critères de tri à l'aide de l'interface de comparaison qui est transmise à la méthode de tri en tant que paramètre.
Vous pouvez également utiliser des collections. Méthode de tri pour trier la liste. Cette méthode trie la liste selon l'ordre naturel.
Q # 4) Qu'est-ce que Arrays.asList () en Java?
Répondre: La méthode «asList» du tableau renvoie la liste des éléments soutenus par un tableau.
qa ou ba qui est mieux
Conclusion
Dans ce tutoriel, nous avons appris toutes les méthodes fournies par une liste. La liste Java fournit diverses méthodes à l'aide desquelles vous pouvez manipuler et traiter des listes, y compris la recherche, le tri, etc. Nous avons expliqué chaque méthode avec des exemples de programmation appropriés ici.
Dans notre prochain didacticiel, nous aborderons en détail ListIterator.
=> Découvrez la série de formations Java simples ici.
lecture recommandée
- Liste Java - Comment créer, initialiser et utiliser une liste en Java
- Liste secrète pour tableau et autres collections en Java
- Didacticiel Python Advanced List (tri de liste, inverse, index, copie, jointure, somme)
- Liste Python - Créer, accéder, découper, ajouter ou supprimer des éléments
- Threads Java avec méthodes et cycle de vie
- Supprimer / Supprimer un élément d'un tableau en Java
- Tutoriel Java String | Méthodes de chaîne Java avec exemples
- Liste d'adresses IP de routeur par défaut pour les marques de routeurs sans fil courantes