Java >> Tutoriel Java >  >> Tag >> ArrayList

Comment trier ArrayList en Java

La collection est un framework Java qui fournit des interfaces (Set, List, Queue, etc.) et des classes (ArrayList, LinkedList, etc.) pour stocker une collection d'objets. Ces classes conservent les données dans un ordre aléatoire. Le tri est un terme utilisé pour décrire le processus d'organisation des données de manière ordonnée. Vous pouvez effectuer un tri de deux manières :par ordre croissant ou décroissant.

Cette section explorera comment trier une ArrayList par ordre croissant et décroissant.

Liste de tableaux

ArrayList est une classe de framework Collections en Java, définie dans le package Java.util. C'est un descendant de la classe AbstractList. De plus, il garde une trace des éléments en temps réel. ArrayList a l'avantage de n'avoir aucune limite de taille. Il est plus adaptable qu'un tableau standard. En outre, il peut contenir des éléments en double. Parce qu'il implémente l'interface List, nous pouvons utiliser toutes les méthodes de l'interface List. Une ArrayList peut être triée de deux manières :ascendante et descendante. En Java, la classe Collections a deux méthodes pour trier une ArrayList.

  • trier()
  • reverseOrder()

Collections.sort() comme méthode de tri des données dans une collection

La fonction sort() de la classe Collections en Java est utilisée pour trier une ArrayList. Il prend un objet ArrayList comme argument et renvoie un ArrayList qui a été trié par ordre croissant selon l'ordre naturel de ses éléments.

La syntaxe est la suivante :

public static <T extends Comparable<? super T>> void sort(List<T> list)  

N'oubliez pas que tous les éléments de ArrayList doivent être comparables les uns aux autres. Sinon, l'exception ClassCastException sera levée. Mutuellement similaire signifie que les éléments de la liste doivent être du même type. Prenons, par exemple, l'extrait de code suivant :

    //creating an instance of ArrayList that contains String type elements  
    ArrayList<String> list = new ArrayList<String>();   
    list.add("HP");  
    list.add(321);   
    list.add("IBM");  
    list.add("DELL");  

Dans l'exemple ci-dessus, une liste comprend quatre membres, dont trois sont de type String et un est de type Integer. Les trois éléments de la chaîne sont interchangeables, mais l'élément de l'entier ne l'est pas. Par conséquent, les éléments de la liste doivent tous être du même type.

Collections.reverseOrder() en tant que méthode qui inverse l'ordre des éléments dans une collection

Vous pouvez utiliser la méthode reverseOrder() de la classe Java Collections pour trier une ArrayList par ordre décroissant. Cela nous permet de trier de manière lexicographique inverse la ArrayList. La syntaxe de .reverseOrder() est la suivante :

 public static <T> Comparator<T> reverseOrder()  

Il renvoie un comparateur qui réorganise une collection d'objets qui implémentent l'interface Comparable dans le sens opposé à leur ordre naturel. Il est important de se rappeler que nous n'appelons pas directement la méthode reverseOrder(). Comme indiqué ci-dessous, nous l'utilisons en conjonction avec la méthode collection.sort().

Collections.sort(objectOfArrayList, Collections.reverseOrder());

Par conséquent, le tri d'une ArrayList dans l'ordre décroissant s'effectue en deux étapes :premièrement, ArrayList trie les données dans l'ordre croissant, puis la méthode reverseOrder() inverse les données triées. Écrivons quelques programmes pour trier la ArrayList par ordre croissant.

ArrayList trié par ordre croissant

Nous avons généré une ArrayList de type String et y avons ajouté des membres dans l'exemple suivant. Ensuite, nous avons passé l'objet de la classe ArrayList, qui est une liste qui trie les éléments par ordre croissant, à la méthode sort() de la classe Collections.

Exemple 1 :SortArrayList

import java.util.*;   
public class SortArrayList 
{   
  public static void main(String args[])   
  {   
    // creating object of ArrayList class  
    ArrayList<String> list = new ArrayList<String>();   
    // adding elements to the ArrayList   
    list.add("DELL");   
    list.add("HP");   
    list.add("Microsoft");   
    list.add("Apple");   
    list.add("Google ");   
    list.add("Air BnB");   
    list.add("Uber ");  
    list.add("Gitlab");  
    // printing the unsorted ArrayList   
    System.out.println("Before Sorting: "+ list);   
    // Sorting ArrayList in ascending Order   
    Collections.sort(list);   
    // printing the sorted ArrayList   
    System.out.println("After Sorting: "+ list);   
  }   
}  

Exemple 2 :SortArrayList

import java.util.*;  

public class SortArrayList 
{  
  public static void main(String args[])  
  {  
    //creating an object of ArrayList class  
    ArrayList<Integer> listNumbers = new ArrayList<Integer>();  
    listNumbers.add(75);  
    listNumbers.add(52);  
    listNumbers.add(69);  
    listNumbers.add(85);  
    listNumbers.add(45);  
    listNumbers.add(60);  
    listNumbers.add(80);  
    //printing ArrayList before sorting  
    System.out.println("ArrayList Before Sorting:");  
    for(int marks: listNumbers)  
    {  
      System.out.println(marks);  
    }  
    //sorting ArrayList in ascending order  
    Collections.sort(listNumbers);  
    //printing ArrayList after sorting  
    System.out.println("ArrayList After Sorting:");  
    for(int marks: listNumbers)  
    {  
      System.out.println(marks);  
    }  
  }  
} 

ArrayList trié par ordre décroissant

Nous avons généré une ArrayList de type String et y avons ajouté des membres dans l'exemple suivant. Ensuite, nous avons passé l'objet de la classe ArrayList, qui est une liste qui trie les éléments par ordre décroissant, aux méthodes reverseOrder() et sort() de la classe Collections.

Exemple :SortArrayList

import java.util.*;   
public class SortArrayListExample3  
{   
  public static void main(String args[])   
  {   
    // creating object of ArrayList class  
    ArrayList<String> languageList = new ArrayList<String>();   
    // adding elements to the ArrayList   
    languageList.add("HTML");   
    languageList.add("DotNet");   
    languageList.add("C");   
    languageList.add("Java");   
    languageList.add("Kotlin");   
    languageList.add("JavaScript ");   
    languageList.add("C++");  
    languageList.add("Python");  
    // printing the unsorted ArrayList   
    System.out.println("Before Sorting: "+ languageList);   
    // Sorting ArrayList in ascending Order   
    // using Collection.sort() method   
    Collections.sort(languageList, Collections.reverseOrder());   
    // Print the sorted ArrayList   
    System.out.println("After Sorting: "+ languageList);   
  }   
}  

Exemple :SortArrayList

import java.util.*;  
public class SortArrayListExample4   
{  
  public static void main(String args[])  
  {  
    //creating an object of ArrayList class  
    ArrayList<Integer> numList = new ArrayList<Integer>();  
    numList.add(123);  
    numList.add(562);  
    numList.add(251);  
    numList.add(356);  
    numList.add(410);  
    numList.add(124);  
    numList.add(368);  
    //printing ArrayList before sorting  
    System.out.println("ArrayList Before Sorting:");  
    for(int marks: numList)  
    {  
      System.out.println(marks);  
    }  
    //sorting ArrayList in descending order  
    Collections.sort(numList, Collections.reverseOrder());  
    //printing ArrayList after sorting  
    System.out.println("ArrayList After Sorting:");  
    for(int marks: numList)  
    {  
      System.out.println(marks);  
    }  
  }  
}  

Exemple :Trier une ArrayList par ordre croissant

La tâche consiste à trier une ArrayList par ordre croissant en Java, étant donné une ArrayList non triée. La fonction sort() de la classe Collections en Java est utilisée pour trier une ArrayList. Cette fonction sort() accepte une collection comme argument et produit une collection triée par défaut dans l'ordre croissant.

// Java program to demonstrate
// How to sort ArrayList in ascending order

import java.util.*;

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

		// Get the ArrayList
		ArrayList<String> carsList = new ArrayList<String>();

		// Populate the ArrayList
		carsList.add("Toyota");
		carsList.add("BMW");
		carsList.add("Merceds-Benz");
		carsList.add("Suzuki");
		carsList.add("Tesla");

		// Print the unsorted ArrayList
		System.out.println("Unsorted ArrayList: "+ carsList);

		// Sorting ArrayList in ascending Order
		// using Collection.sort() method
		Collections.sort(carsList);

		// Print the sorted ArrayList
		System.out.println("Sorted ArrayList "
						+ "in Ascending order : "
						+ carsList);
	}
}

Exemple :tri de ArrayList dans l'ordre naturel

import java.util.ArrayList;
import java.util.Comparator;

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

    // create an ArrayList
    ArrayList<String> compList = new ArrayList<>();

    // add elements to ArrayList
    compList.add("Software Engineer");
    compList.add("Backend Developer");
    compList.add("System Architect");
    compList.add("Mobile Engineer");
    System.out.println("Unsorted ArrayList: " + compList);

    // sort the ArrayList in ascending order
    compList.sort(Comparator.naturalOrder());

    System.out.println("Sorted ArrayList: " + compList);
  }
}

Dans l'exemple précédent, nous avons utilisé la méthode sort() pour trier les langues nommées ArrayList. Prenez note de la ligne,

compList.sort(Comparator.naturalOrder());

La fonction naturalOrder() de l'interface Java Comparator indique que les éléments sont triés dans l'ordre naturel (c'est-à-dire dans l'ordre croissant). De plus, l'interface Comparator dispose d'une méthode pour trier les composants par ordre décroissant. Par exemple,

import java.util.ArrayList;
import java.util.Comparator;

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

    // create an ArrayList
    ArrayList<String> compList = new ArrayList<>();

    // add elements to ArrayList
   compList.add("Software Engineer");
    compList.add("Backend Developer");
    compList.add("System Architect");
    compList.add("Mobile Engineer");
    System.out.println("Unsorted ArrayList: " + compList);

    // sort the ArrayList in ascending order
    compList.sort(Comparator.reverseOrder());

    System.out.println("Sorted ArrayList: " + compList);
  }
}

La fonction reverseOrder() de l'interface Comparator indique que les éléments sont triés dans l'ordre inverse (c'est-à-dire dans l'ordre décroissant). La méthode Collections.sort() est l'option la plus pratique pour trier une ArrayList.

Utiliser des comparables pour trier une ArrayList

La seule méthode importante dans l'interface Comparable est la méthode compareTo(). Un objet implémenté comparable peut se comparer à un autre objet implémenté comparable du même type. La méthode compareTo() de la classe Ccmparable doit être remplacée.

Cette méthode prend un objet du même type que compareTo() et implémente la logique pour le comparer à celui transmis. La méthode compareTo() renvoie le résultat de la comparaison sous la forme d'un entier. Cet objet est supérieur à l'objet fourni à compareTo() si la valeur est positive. Cet objet est inférieur à l'objet fourni à compareTo() avec une valeur négative. Le nombre zéro indique l'égalité entre les deux choses.

Regardons une classe CodingStudent avec des objets que nous voulons stocker dans une ArrayList, puis trions. La classe CodingStudent comprend trois champs :un nom et un sexe de chaîne et un âge entier. Nous voulons utiliser l'attribut age pour trier les objets CodingStudent dans ArrayList. Nous devrons implémenter Comparable dans la classe CodingStudent et remplacer la méthode compareTo().

Ceci est le code de la classe CodingStudent.

// CodingStudent.java

package guru.springframework.blog.sortarraylist.comparable;     
public class CodingStudent implements Comparable<CodingStudent> {     
  private String name;     
  private String gender;     
  private int age;       
  public CodingStudent(String name, String gender, int age) {         
    this.name = name;         
    this.gender = gender;         
    this.age = age;     
 }       

  public String getName() {         
    return name;     
  }       

  public String getGender() {         
    return gender;     
  }                      

  public int getAge() {         
    return age;     
  }       

  @Override     
  public int compareTo( CodingStudent cStudent) {          
    return (this.getAge() < cStudent.getAge() ? -1 : 
            (this.getAge() == cStudent.getAge() ? 0 : 1));     
  }       

  @Override     
  public String toString() {         
    return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age;     
  } 
}

Nous avons construit la logique de comparaison basée sur le champ age dans la méthode override compareTo() de la classe CodingStudent ci-dessus. De nombreux programmeurs, d'après notre expérience, sont revenus à l'ancienne méthode consistant à renvoyer le résultat de la comparaison comme :

 return (this.getAge() - cStudent.getAge());

Bien que l'utilisation de cette instruction de retour puisse sembler tentante et n'aura aucun effet sur notre exemple, nous vous recommandons de l'éviter. Considérez le résultat de la comparaison de valeurs entières dans lesquelles l'une ou les deux sont négatives.

Cela peut provoquer des défauts dans votre application qui la font se comporter de manière imprévisible, et comme ces bogues sont subtils, ils sont difficiles à repérer, en particulier dans les grands systèmes d'entreprise. Ensuite, nous développerons une classe d'assistance qui trie les objets ArrayList contenant des éléments CodingStudent pour les clients.

// CodingStudentSorter.java

package guru.springframework.blog.sortarraylist.comparable;     

import java.util.ArrayList; 
import java.util.Collections;   

public class CodingStudentSorter {     
  ArrayList<CodingStudent> codingStudent = new ArrayList<>();       

  public CodingStudentSorter(ArrayList<CodingStudent> codingStudent) {         
    this.codingStudent = codingStudent;     
  }       

  public ArrayList<CodingStudent> getSortedCodingStudentByAge() {         
    Collections.sort(codingStudent);         
    return codingStudent;     
  } 
}

Nous avons initialisé un objet ArrayList dans la classe CodingStudentSorter, que le client donnera via le constructeur lors de l'instanciation de CodingStudentSorter. La méthode getSortedCodingStudentByAge() a ensuite été créée. Nous avons passé la ArrayList initialisée à Collections.sort() dans cette méthode. Enfin, il renvoie la ArrayList triée. Après cela, nous créerons une classe de test pour tester notre code.

CodingStudentSorterTest.java

package guru.springframework.blog.sortarraylist.comparable;   

import org.junit.Test;   
import java.lang.reflect.Array; 
import java.util.ArrayList;   
import static org.junit.Assert.*;     

public class CodingStudentSorterTest {       

  @Test     
  public void testGetSortedJobCandidateByAge() throws Exception {         
    CodingStudent codingStudent1 = new CodingStudent("Jane Smith", "Male", 46);         
    CodingStudent codingStudent2 = new CodingStudent("Ann Hunt", "Female", 53);         
    CodingStudent codingStudent3 = new CodingStudent("Mac Clark", "Female", 10);         
    CodingStudent codingStudent4 = new CodingStudent("Saint Styne", "Male", 74);         
    ArrayList<CodingStudent> codingStudentList = new ArrayList<>();       
  
    codingStudentList.add(codingStudent1);         
    codingStudentList.add(codingStudent2);         
    codingStudentList.add(codingStudent3);         
    codingStudentList.add(codingStudent4);       
  
    CodingStudentSorter codingStudentSorter = new CodingStudentSorter(codingStudentList);         
    ArrayList<CodingStudent> sortedCodingStudent = codingStudentSorter.getSortedCodingStudentByAge();         
    System.out.println("-----Sorted CodingStudent by age: Ascending-----");         
    for ( CodingStudent codingStudent : sortedCodingStudent ) {             
      System.out.println(codingStudent);    

Nous avons créé quatre objets CodingStudent et les avons ajoutés à une ArrayList dans la classe de test ci-dessus. Nous avons ensuite passé notre ArrayList au constructeur de la classe CodingStudentSorter. Enfin, nous avons invoqué la méthode getSortedJobCandidateByAge() de CodingStudentSorter et imprimé la ArrayList triée que la méthode a renvoyée.

Comparable est une méthode typique pour trier une ArrayList. Cependant, vous devez être conscient de certaines limitations. Vous devez implémenter Comparable et remplacer la fonction compareTo() dans la classe dont vous souhaitez trier l'objet. Cela signifie effectivement que vous ne pouvez comparer que des éléments basés sur un champ (l'âge dans notre exemple). Que se passe-t-il si vos exigences spécifient que vous devez pouvoir trier les objets CodingStudent à la fois par nom et par âge ? Comparable n'est pas la réponse.

De plus, étant donné que la logique de comparaison fait partie de la classe dont les objets doivent être comparés, il n'y a aucun moyen de réutiliser la logique de comparaison. Java fournit l'interface Comparator dans le package Java.util pour répondre à ces exigences de comparaison de tri.

Utiliser un comparateur pour trier une ArrayList

L'interface Comparator n'a qu'une seule méthode de comparaison appelée compare() comme l'interface Comparable. La méthode compare(), contrairement à la méthode compareTo() de Comparable, compare deux objets distincts du même type.

Le comparateur sera utilisé pour classer les éléments de la même classe CodingStudent qu'auparavant, mais avec quelques variantes. En créant des classes internes anonymes Comparatoras, nous pourrons trier les objets CodingStudent par nom et âge.

Le code de la classe CodingStudent utilisant le comparateur est présenté ci-dessous.

CodingStudent.java
package guru.springframework.blog.sortarraylist.comparator;     

import java.util.Comparator;   

public class CodingStudent {     
  private String name;     
  private String gender;     
  private int age;       

  public CodingStudent(String name, String gender, int age) {         
    this.name = name;         
    this.gender = gender;         
    this.age = age;     
  }       

  public String getName() {         
    return name;     
  }       

  public String getGender() {         
    return gender;     
  }       

  public int getAge() {         
    return age;     
  }       

  public static Comparator<CodingStudent> ageComparator = new Comparator<CodingStudent>() {         
    @Override         
    public int compare( CodingStudent cs1, CodingStudent cs2) {             
      return (cs2.getAge() < cs1.getAge() ? -1 :                     
              (cs2.getAge() == cs1.getAge() ? 0 : 1));           
    }     
  };       

  public static Comparator<CodingStudent> nameComparator = new Comparator<CodingStudent>() {         
    @Override         
    public int compare( CodingStudent cs1, CodingStudent cs2) {             
      return (int) (cs1.getName().compareTo(cs2.getName()));         
    }     
  };         

  @Override     
  public String toString() {         
    return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age;     
  } 
}

De la ligne 29 à la ligne 35 de la classe ci-dessus, nous avons créé une classe anonyme et implémenté la méthode compare(), qui nous permet de classer les objets CodingStudent par âge dans l'ordre décroissant.

Nous avons créé une autre classe anonyme et implémenté la méthode compare() de la ligne 37 à la ligne 42, ce qui nous permet de classer les objets CodingStudent par nom dans l'ordre croissant. Nous allons maintenant créer une classe qui trie les éléments de ArrayList pour les clients.

// CodingStudentSorter.java

package guru.springframework.blog.sortarraylist.comparator;     

import java.util.ArrayList; 
import java.util.Collections;                  

public class CodingStudentSorter {     
  ArrayList<CodingStudent> codingStudent = new ArrayList<>();       

  public CodingStudentSorter(ArrayList<CodingStudent> codingStudent) {         
    this.codingStudent = codingStudent;     
  }       

  public ArrayList<CodingStudent> getSortedCodingStudentByAge() {         
    Collections.sort(codingStudent, CodingStudent.ageComparator);         
    return codingStudent;     
  }       

  public ArrayList<JobCandidate> getSortedCodingStudentByName() {         
    Collections.sort(codingStudent, CodingStudent.nameComparator);         
    return codingStudent;     
  } 
}

La méthode getSortedCodingStudentByAge() a été écrite dans la classe précédente. Nous avons utilisé la forme surchargée de Collections dans cette méthode. sort() prend deux arguments :un objet ArrayList pour trier et un objet Comparator pour comparer l'âge. Nous avons de nouveau utilisé la version surchargée de Collections dans la méthode getSortedCodingStudentByName(). sort() renvoie un objet ArrayList trié et un objet Comparator utilisé pour comparer les noms. Créons une classe de test pour tester notre code.

CodingStudentSorterTest.java

package guru.springframework.blog.sortarraylist.comparator;     

import guru.springframework.blog.sortarraylist.comparator.CodingStudent ; 
import guru.springframework.blog.sortarraylist.comparator.CodingStudentSorter; 

import org.junit.Before; 
import org.junit.Test;   
import java.util.ArrayList;   
import static org.junit.Assert.*;   

public class CodingStudentSorterTest {     
  CodingStudentSorter codingStudentSorter;       

  @Before     
  public void setUp() throws Exception {         
    CodingStudent codingStudent1 = new CodingStudent("Mark Smith", "Male", 26);         
    CodingStudent codingStudent2 = new CodingStudent("Sandy Hunt", "Female", 23);         
    CodingStudent codingStudent3 = new CodingStudent("Betty Clark", "Female", 20);         
    CodingStudent codingStudent4 = new CodingStudent("Andrew Styne", "Male", 24);         
    ArrayList<CodingStudent> codingStudentList = new ArrayList<>();         
    codingStudentList.add(codingStudent1);         
    codingStudentList.add(codingStudent2);         
    codingStudentList.add(codingStudent3);         
    codingStudentList.add(codingStudent4);         
    codingStudentSorter = new CodingStudentSorter(codingStudentList);     
  }       

  @Test     
  public void testGetSortedCodingStudentByAge() throws Exception {         
    System.out.println("-----Sorted CodingStudent by age: Descending-----");         
    ArrayList<CodingStudent> sortedCodingStudent = codingStudent Sorter.getSortedCodingStudentByAge();         
    for ( CodingStudent codingStudent : sortedCodingStudent ) {             
      System.out.println(codingStudent);         
    }     
  }       

  @Test     
  public void testGetSortedCodingStudentByName() throws Exception {         
    System.out.println("-----Sorted CodingStudent by name: Ascending-----");         
    ArrayList<CodingStudent> sortedCodingStudent = codingStudentSorter.getSortedCodingStudentByName();         
    for ( CodingStudent codingStudent : sortedCodingStudent) {             
      System.out.println(codingStudent);         
    }       
  } 
}

Dans la méthode JUnit setup() annotée avec @Before, nous avons rempli des objets CodingStudent dans une ArrayList et généré un objet CodingStudentSorter dans la classe de test.

Nous avons invoqué la méthode getSortedCodingStudentByAge() dans la méthode testGetSortedCodingStudentByAge() et écrit la ArrayList triée que la fonction renvoie dans la méthode testGetSortedCodingStudentByAge(). La fonction getSortedCodingStudentByName() a été appelée dans la méthode de test testGetSortedCodingStudentByName() et la ArrayList triée renvoyée par la méthode a été écrite.

Conclusion

En raison de sa fonctionnalité et de sa polyvalence, ArrayList est l'une des classes de collection les plus utilisées dans Java Collection Framework. ArrayList est une implémentation List qui utilise un tableau dynamique pour stocker des éléments en interne. Par conséquent, lorsque vous ajoutez et supprimez des éléments d'une ArrayList, celle-ci peut croître et diminuer de manière dynamique.

Nous avons parcouru l'une des opérations ArrayList essentielles que vous devrez certainement utiliser lors du développement d'applications d'entreprise. Il trie les éléments d'une ArrayList.

Nous avons examiné différentes méthodes de tri des membres ArrayList. L'un emploie Comparable, tandis que l'autre emploie un comparateur. Pour les programmeurs, l'approche du choix a toujours été une source de consternation. Essentiellement, un objet comparable peut dire « je peux me comparer à un autre objet », alors qu'un objet comparateur peut dire « je peux comparer deux objets différents ». Il est impossible de dire qu'une interface est supérieure à l'autre. L'interface que vous sélectionnez est déterminée par les fonctionnalités dont vous avez besoin.


Balise Java