Trier ArrayList en Java
Trier ArrayList en Java | Le tri est une opération qui assemble tous les éléments du tableau dans l'ordre croissant ou décroissant. Il existe une méthode intégrée disponible dans la classe Java Collections pour trier les éléments du tableau appelé sort (). Il existe diverses opérations de tri comme le tri à bulles, le tri par sélection, le tri par fusion, le tri par tas, le tri par insertion.
Trier la liste des tableaux d'objets Java
Étape 1 :Définissez une classe personnalisée avec une propriété personnalisée qui prend et stocke des objets personnalisés. Ici, nous créons une classe Étudiant qui a des champs de numéro de matricule et de nom, tous deux privés. Pour accéder aux champs, nous allons définir des méthodes getters et setters. Et pour afficher l'objet étudiant, nous remplacerons la méthode toString().
class Student {
private int no;
private String name;
// constructor
public Student(int no, String name) {
this.no = no;
this.name = name;
}
// getters and setters method
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// toString to display the object
@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + "]";
}
}- Étape 2 :Créez une classe principale et importez la classe ArrayList à partir du package d'utilitaires.
- Étape 3 :Créez un objet ArrayList et ajoutez des objets étudiants.
- Étape 4 :Triez en fonction du nom de l'élève et affichez la ArrayList.
- Étape 5 :Triez en fonction du numéro de liste des élèves et affichez la ArrayList.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
// declare ArrayList with custom class
ArrayList<Student> list = new ArrayList<>();
// add custom objects in ArrayList
list.add(new Student(200, "Amelia"));
list.add(new Student(110, "John"));
list.add(new Student(105, "William"));
list.add(new Student(106, "Rocco"));
list.add(new Student(120, "Jerry"));
// display ArrayList
System.out.println("Before Sorting: ");
System.out.println(list);
// sort ArrayList based on name
list.sort((a1, a2) -> a1.getName().compareTo(a2.getName()));
// display ArrayList
System.out.println("Sorting based on name: ");
System.out.println(list);
// sort ArrayList based on roll number
list.sort((a1, a2) -> a1.getNo() - a2.getNo());
// display ArrayList
System.out.println("Sorting based on no: ");
System.out.println(list);
}
}
Sortie :-
Avant de trier :
[Étudiant [no=200, name=Amelia], Étudiant [no=110, name=John], Étudiant [no=105, name=William], Étudiant [no=106, name=Rocco ], Étudiant [no=120, name=Jerry]]
Tri basé sur le nom :
[Étudiant [no=200, name=Amelia], Étudiant [no=120, name=Jerry], Étudiant [no=110, name=John], Étudiant [no=106, name=Rocco], Étudiant [no=105, name=William]]
Tri basé sur no :
[Étudiant [no=105, name=William], Étudiant [no=106, name=Rocco], Étudiant [no=110, name=John], Étudiant [no=120, name=Jerry], Étudiant [ non=200, nom=Amelia]]
Lors du tri basé sur le nom, nous avons appelé la méthode compareTo() car la classe String remplace la méthode compareTo() pour comparer deux objets chaîne en fonction de leur contenu. Mais lors du tri basé sur un numéro de rouleau, nous avons écrit notre propre logique car c'est le type "int" qui est un type de données primitif.
Java Sort ArrayList Of Objects Using Collections.sort()
Si nous voulons trier des objets en utilisant la méthode Collections.sort (), la classe doit être de type Comparable, c'est-à-dire qu'elle doit implémenter l'interface Comparable. Comparable est une interface en Java qui fournit une seule séquence de tri.
Dans ce cas, nous trions le tableau en fonction des objets, nous avons deux classes User et Main où l'utilisateur implémente un comparable, et Main utilise l'utilisateur pour imprimer le tableau trié. Le tri est effectué en fonction de l'identifiant.
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class User implements Comparable<User> {
int id;
String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return id + ":" + name;
}
@Override
public int compareTo(User user) {
// sort based on id
return this.id - user.getId();
// sort based on name
// return this.name.compareTo(user.name);
}
}
public class Main {
public static void main(String[] args) {
List<User> users = new ArrayList<User>();
users.add(new User(2, "Robert"));
users.add(new User(1, "James"));
users.add(new User(3, "Harry"));
users.add(new User(4, "Amellia"));
System.out.println(users);
Collections.sort(users);
System.out.println(users);
}
}
Sortie sur le tri basé sur l'ID :-
[2 :Robert, 1 :James, 3 :Harry, 4 :Amelia]
[1 :James, 2 :Robert, 3 :Harry, 4 :Amelia]
Sortie sur le tri basé sur le nom :-
[2 :Robert, 1 :James, 3 :Harry, 4 :Amélie]
[4 :Amélie, 3 :Harry, 1 :James, 2 :Robert]
Java Sort ArrayList Of Integers
Dans cette section, nous allons trier ArrayList de valeurs entières. Pour cela, nous avons deux options :- trier par ordre croissant, ou trier par ordre décroissant. Pour trier par ordre croissant, nous pouvons simplement appeler Collections.sort(list) , mais pour trier par ordre décroissant, nous devons également passer le deuxième paramètre Collections.sort(list, Collections.reverseOrder());
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(430);
list.add(220);
list.add(112);
list.add(677);
list.add(439);
list.add(905);
System.out.println("Before Sorting : " + list);
// sorting in ascending order
Collections.sort(list);
System.out.println("Sorting in ascending order: " + list);
// sorting in descending order
Collections.sort(list, Collections.reverseOrder());
System.out.println("Sorting in descending order: " + list);
}
}Sortie :
Avant tri :[430, 220, 112, 677, 439, 905]
Tri par ordre croissant :[112, 220, 430, 439, 677, 905]
Tri par ordre décroissant :[905, 677, 439, 430, 220, 112]
Trier la liste Java Lambda
L'expression Lambda est une nouvelle fonctionnalité de Java qui fournit un moyen concis de représenter une méthode. C'est un court bloc de code qui prend des paramètres et renvoie une valeur. Ici, nous trions une ArrayList en utilisant l'expression lambda en définissant deux classes Employee et la classe principale.
class Employee {
private int id;
private String name;
private int age;
private long salary;
public Employee(int id, String name, int age, long salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public long getSalary() {
return salary;
}
public void setSalary(long salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name
+ ", age=" + age + ", salary=" + salary + "]";
}
}import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<Employee>();
employees.add(new Employee(115, "William", 30, 385));
employees.add(new Employee(110, "Amelia", 34, 400));
employees.add(new Employee(100, "John", 22, 350));
System.out.println("Before Sorting: " + employees);
// sorting in ascending order by name
Collections.sort(employees,
(e1, e2) -> (e1.getName().compareTo(e2.getName())));
System.out.println("Ascending order: " + employees);
// sorting in descending order by name
Collections.sort(employees,
(e1, e2) -> (e2.getName().compareTo(e1.getName())));
System.out.println("Descending order: " + employees);
}
}
Sortie :
Avant le tri :[Employé [id=115, nom=William, âge=30, salaire=385], Employé [id=110, nom=Amelia, âge=34, salaire=400], Employé [id=100, nom=John, âge=22, salaire=350]]
Ordre croissant :[Employé [id=110, nom=Amelia, âge=34, salaire=400], Employé [id=100, nom=John, âge=22, salaire=350], Employé [id=115, nom=William, âge=30, salaire=385]]
Ordre décroissant :[Employé [id=115, nom=William, âge=30, salaire=385], Employé [id=100, nom=John, âge=22, salaire=350], Employé [id=110, nom=Amelia, âge=34, salaire=400]]
Dans le code ci-dessus, nous avons utilisé l'expression Lambda pour trier les employés en fonction de leur nom. Le code ci-dessous produit également le même résultat.
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return (int) (e1.getName().compareTo(e2.getName()));
}
});
System.out.println("Ascending order: " + employees);Nous pouvons également utiliser la méthode de comparaison de la classe Comparator.
Collections.sort(employees, Comparator.comparing(Employee::getName));
System.out.println("Ascending order: " + employees);
