Supprimer les doublons de ArrayList Java
Supprimer les doublons de ArrayList Java | Dans cet article, nous verrons comment supprimer les doublons de ArrayList en Java. Nous verrons également comment supprimer les objets en double de ArrayList en Java.
Pour supprimer les doublons de la liste Java,
1) Stockez les valeurs d'entrée dans la liste.
2) Copiez la liste dans l'ensemble. L'ensemble n'autorisera que les éléments uniques.
En Java, Set(I) stocke des éléments uniques. Si nous essayons de stocker des éléments en double, la méthode add() de Set(I) renvoie false comme résultat. Il existe trois classes qui implémentent Set(I).
1) HashSet :- Il stocke les éléments en fonction de la valeur de code de hachage des éléments. La valeur du hashcode est calculée sur la base de la méthode hashcode().
2) LinkedHashSet :- Il stocke les éléments dans l'ordre d'insertion (dans l'ordre dans lequel nous les insérons).
3) TreeSet :- Il stocke les éléments basé sur un ordre de tri comme l'ordre croissant/décroissant.
Étant donné que notre tâche principale est de supprimer les doublons de la ArrayList, et non dans l'ordre dans lequel ils seront insérés, nous choisirons donc LinkedHashSet qui stocke les éléments en fonction de l'ordre d'insertion.
Programme Java pour supprimer les doublons de ArrayList of String
Nous avons une liste de String [Java, C++, Python, Java, C++, Java] et nous voulons supprimer tous les doublons de cette liste. Après avoir supprimé les doublons de la liste, le résultat attendu est :- [Java, C++, Python]
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class ArrayListTest {
public static void main(String[] args) {
// ArrayList to store elements
List<String> al = new ArrayList<String>();
// store elements
al.add("Java");
al.add("C++");
al.add("Python");
al.add("Java");
al.add("C++");
al.add("Java");
System.out.println("With Duplicates: " + al);
// Convert ArrayList to LinkedHashSet
Set<String> lhs = new LinkedHashSet<String>(al);
// display LinkedHashSet
System.out.println("After Removing Duplicates: " + lhs);
}
}
Sortie :-
Avec doublons :[Java, C++, Python, Java, C++, Java]
Après suppression des doublons :[Java, C++, Python]
Après avoir supprimé les doublons, si nécessaire, nous pouvons convertir LinkedHashSet en ArrayList et effectuer les opérations restantes sur l'objet ArrayList.
// Convert LinkedHashSet to ArrayList
ArrayList<String> al1 = new ArrayList<String>(lhs);
System.out.println(al1); // [Java, C++, Python]
Programme Java pour supprimer les doublons de ArrayList of Integer values
Ici, nous avons une liste de valeurs entières [100, 10, 50, 100, 50, 50] et nous voulons supprimer les valeurs en double de cette liste. Le résultat attendu après la suppression des éléments en double est :- [100, 10, 50]
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class ArrayListTest {
public static void main(String[] args) {
// ArrayList to store elements
List<Integer> al = new ArrayList<Integer>();
// store elements
al.add(100);
al.add(10);
al.add(50);
al.add(100);
al.add(50);
al.add(50);
System.out.println("With Duplicates: " + al);
// Convert ArrayList to LinkedHashSet
Set<Integer> lhs = new LinkedHashSet<Integer>(al);
// display LinkedHashSet
System.out.println("After Removing Duplicates: " + lhs);
}
}
Sortie :-
Avec doublons :[100, 10, 50, 100, 50, 50]
Après suppression des doublons :[100, 10, 50]
Comment la classe LinkedHashSet est-elle capable de supprimer les doublons ? Avant d'insérer les éléments HashSet et les classes LinkedHashSet, utilisez la méthode equals() pour comparer avec tous les éléments existants. Si la méthode equals() renvoie true, l'élément est unique, il sera donc inséré dans l'ensemble, mais lorsque la méthode equals() renvoie false, l'élément est dupliqué et cet élément ne sera donc pas inséré dans l'ensemble.
Dans String et toutes les classes wrapper (Integer, Double, Float, Long et e.t.c.), la méthode equals() est remplacée pour la comparaison de contenu. Par conséquent, lors de l'insertion de l'élément String, la chaîne donnée sera comparée à toutes les chaînes existantes. Si toutes les comparaisons renvoient true, l'élément est unique et sera inséré, mais si au moins une comparaison renvoie false, la chaîne ne sera pas insérée.
Java supprimer les doublons de la liste des objets
Nous avons une liste d'objets comme indiqué dans le tableau ci-dessous. La liste contient différents produits, parmi lesquels nous devons supprimer les produits en double. Chaque produit a son PID (identifiant du produit), son nom (nom du produit), sa quantité (quantité) et son prix.
Liste des produits
| Pid | Nom | Quantité | Prix |
| 123 | Ordinateur portable | 15 | 2000.0 |
| 154 | Mobile | 30 | 200.0 |
| 543 | Clavier | 20 | 30.0 |
| 123 | Ordinateur portable | 15 | 2000.0 |
| 154 | Mobile | 50 | 500.0 |
| 543 | Clavier | 20 | 30.0 |
Un produit sera appelé doublon si toutes les propriétés correspondent à un autre produit. Cela signifie que les produits en double auront le même PID, le même nom, la même quantité et le même prix. Nous devons écrire un programme Java pour supprimer les doublons de la liste de produits.
Pour cela, nous devons remplacer la méthode equals () dans la classe Product et comparer le PID, le nom, la quantité et le prix. Chaque fois que nous redéfinissons la méthode equals(), nous devons également remplacer la méthode hashCode(). En savoir plus :- méthode equals() en Java, hashCode() en Java.
import java.util.Objects;
class Product {
private int pid;
private String name;
private int qty; // quantity
private double price;
public Product(int pid, String name,
int qty, double price) {
this.pid = pid;
this.name = name;
this.qty = qty;
this.price = price;
}
@Override
public String toString() {
return "{" + pid + ", " + name + ", "
+ qty + ", " + price + "}\n";
}
@Override
public int hashCode() {
return Objects.hash(name, pid, price, qty);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Product other = (Product) obj;
return name.equals(other.name)
&& pid == other.pid
&& price == other.price
&& qty == other.qty;
}
}
Dans la classe Product, nous avons remplacé la méthode toString() pour afficher les produits. La méthode hashCode() utilise en interne la méthode hash() de la classe java.util.Objects qui génère un code de hachage pour une séquence de valeurs d'entrée.
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class Shop {
public static void main(String[] args) {
// list to store products
List<Product> al = new ArrayList<Product>();
// adding products to set
al.add(new Product(123, "Laptop", 15, 2000.0));
al.add(new Product(154, "Mobile", 30, 200.0));
al.add(new Product(543, "Keyboard", 20, 30.0));
al.add(new Product(123, "Laptop", 15, 2000.0));
al.add(new Product(154, "Mobile", 50, 500.0));
al.add(new Product(543, "Keyboard", 20, 30.0));
System.out.println("With Duplicates:\n" + al);
// LinkedHashSet
Set<Product> lhs = new LinkedHashSet<Product>(al);
System.out.println("After Removing Duplicates:\n"
+ lhs);
}
}
Sortie :-
Avec doublons :
[{123, Laptop, 15, 2000.0}
, {154, Mobile, 30, 200.0}
, {543, Keyboard, 20, 30.0}
, {123, Ordinateur portable, 15, 2000.0}
, {154, Mobile, 50, 500.0}
, {543, Clavier, 20, 30.0}
]
Après avoir supprimé les doublons :
[{123, Ordinateur portable, 15, 2000.0}
, {154, Mobile, 30, 200.0}
, {543, Clavier, 20, 30.0}
, {154, Mobile, 50, 500.0}
]
Supprimer les doublons de la liste Java 8
Nous pouvons utiliser Java 8 Stream pour supprimer les doublons de la liste. Ici, nous pouvons utiliser la méthode Stream().distinct() qui renvoie un flux d'objets distinct. Après cela, convertissez ce flux d'objets en une liste.
La méthode distinct() renvoie un nouveau Stream sans éléments en double en fonction du résultat renvoyé par la méthode equals(), qui peut être utilisé pour un traitement ultérieur. Le traitement réel du pipeline Stream ne démarre qu'après avoir appelé des méthodes de terminal telles que forEach() ou collect().
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ArrayListTest {
public static void main(String[] args) {
// ArrayList to store elements
List<Integer> al = new ArrayList<Integer>();
// store elements
al.add(100);
al.add(10);
al.add(50);
al.add(100);
al.add(50);
al.add(50);
System.out.println("With Duplicates: " + al);
List<Integer> newList =
al.stream().distinct().collect(Collectors.toList());
System.out.println("After Removing Duplicates: "
+ newList);
}
}
Sortie :-
Avec doublons :[100, 10, 50, 100, 50, 50]
Après suppression des doublons :[100, 10, 50]
