Classer Java ArrayList avec des champs personnalisés par numéro et par ordre alphabétique
public class Product implements Serializable{
private String id;
private String name;
private double price ;
private int quantity;
public Product(String id, String name, double price, int quantity) {
this.id = id;
this.name = name;
this.price = price;
this.quantity = quantity;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
@Override
public String toString() {
return "Product{" + "id=" + id + ", name=" + name + ", price=" + price + ", quantity=" + quantity + '}';
}
Je veux trier ArrayList<Product> par prix et par nom. Je recherche Google depuis longtemps, mais je ne peux pas le résoudre. Si cela peut avoir un problème avec Serializable
Vous devez implémenter l'interface Comparable ou Comparator pour votre objectif. tri des objets définis par l'utilisateur avec Comparator et tri des objets définis par l'utilisateur avec comparable
Vous pouvez apprendre la différence entre ces deux en lisant ces tutoriels
Considérez que vous souhaitez que vos produits soient triés en fonction de leur prix, puis définissez votre Product implémenter Comparable comme suit
public class Product implements Comparable<Product>{
public int compareTo(Product other){
// your logic here
}
}
Mais attendez ... maintenant que nous avons déjà implémenté l'interface Comparable pour trier les objets en fonction de son prix, comment pouvons-nous les trier en utilisant une autre séquence de tri? Nous n'avons qu'une seule méthode compareTo() et nous ne pouvons pas écrire de séquence de tri séparée dans la même classe. Voici le rôle de Comparator. Avec Comparator, vous pouvez définir plusieurs séquences de tri.
Supposons que nous voulions trier en fonction de son prix, alors:
public class PriceSorter implements Comparator<Product>{
public int compare(Product one, Product another){
int returnVal = 0;
if(one.getPrice() < another.getPrice()){
returnVal = -1;
}else if(one.getPrice() > another.getPrice()){
returnVal = 1;
}else if(one.getPrice() == another.getPrice()){
returnVal = 0;
}
return returnVal;
}
}
et vous voulez une autre séquence de tri, maintenant son nom, alors:
public class NameSorter implements Comparator<Product>{
public int compare(Product one, Product another){
return one.getName().compareTo(another.getName());
}
}
Maintenant, quand vous voulez trier par prix, alors
Collections.sort(yourList,new PriceSorter());
Si vous voulez trier par nom, alors
Collections.sort(yourList, new NameSorter());
Le second argument prend l'instance Comparator qui permet à la méthode de tri de savoir quelle logique suivre lors du tri des objets
Demandez à la classe Product d'implémenter l'interface Comparable.
public class Product implements Serializable, Comparable<Product> {
//Ommitted constructors, fields and accessors
//This is an ascending sort order
@Override
public int compareTo(Product o) {
int result = this.name.compareToIgnoreCase(o.name);
if(result != 0){
return result;
}else{
return new Double(this.price).compareTo(new Double(o.price));
}
}
}
Ensuite, le tri est aussi simple que de passer la List à Collections.sort():
public static void main(String[] args) {
Product p1 = new Product("p1", "shoes", 30.33, 20);
Product p2 = new Product("p2", "shoes", 20.30, 20);
Product p3 = new Product("p3", "shoes", 50.33, 20);
Product p4 = new Product("p4", "socks", 10.50, 20);
Product p5 = new Product("p5", "socks", 5.40, 20);
Product p6 = new Product("p6", "socks", 2.34, 20);
List<Product> products = Arrays.asList(p1,p2,p3,p4,p5,p6);
System.out.println("Unsorted");
for(Product product:products){
System.out.println("Product: " + product.name + " Price: " + product.price);
}
Collections.sort(products);
System.out.println("sorted");
for(Product product:products){
System.out.println("Product: " + product.name + " Price: " + product.price);
}
}
Voici le code source complet pour Product qui implémente Comparable avec un exemple de tri dans la méthode main:
import Java.io.Serializable;
import Java.util.Arrays;
import Java.util.Collections;
import Java.util.List;
public class Product implements Serializable, Comparable<Product> {
private String id;
private String name;
private double price;
private int quantity;
public Product(String id, String name, double price, int quantity) {
this.id = id;
this.name = name;
this.price = price;
this.quantity = quantity;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
@Override
public String toString() {
return "Product{" + "id=" + id + ", name=" + name + ", price=" + price
+ ", quantity=" + quantity + '}';
}
@Override
public int compareTo(Product o) {
int result = this.name.compareToIgnoreCase(o.name);
if(result != 0){
return result;
}else{
return new Double(this.price).compareTo(new Double(o.price));
}
}
public static void main(String[] args) {
Product p1 = new Product("p1", "shoes", 30.33, 20);
Product p2 = new Product("p2", "shoes", 20.30, 20);
Product p3 = new Product("p3", "shoes", 50.33, 20);
Product p4 = new Product("p4", "socks", 10.50, 20);
Product p5 = new Product("p5", "socks", 5.40, 20);
Product p6 = new Product("p6", "socks", 2.34, 20);
List<Product> products = Arrays.asList(p1,p2,p3,p4,p5,p6);
System.out.println("Unsorted");
for(Product product:products){
System.out.println("Product: " + product.name + " Price: " + product.price);
}
Collections.sort(products);
System.out.println("sorted");
for(Product product:products){
System.out.println("Product: " + product.name + " Price: " + product.price);
}
}
}
Utilisez un Comparator<Product>, mis en œuvre ici anonymement (adapté à Java 7 et versions antérieures):
List<Product> list;
Collections.sort(list, new Comparator<Product>() {
public int compare(Product a, Product b) {
if (a.getPrice() == b.getPrice())
return a.getName().compareTo(b.getName());
return a.getPrice() > b.getPrice() ? 1 : a.getPrice() < b.getPrice() ? -1 : 0
}
});
Java 8 offre une méthode beaucoup plus simple pour atteindre les objectifs ci-dessus:
Collections.sort(list, Comparator.comparing(Product::getPrice).thenComparing(Product::getName));
Si cela définit "l'ordre naturel" de vos produits, envisagez de faire Product mettre en œuvre Comparable<Product> et l'implémenter dans la méthode compareTo() de Product.
Vous devez implémenter l'interface Comparable. L'interface nécessite que vous ajoutiez une fonction appelée compareTo(Product other) dans laquelle vous écrivez le code vérifiant les champs personnalisés avec lesquels vous souhaitez comparer les objets.
Sinon, vous pouvez faire ce que @Prasad Kharkar a suggéré et écrire une Comaparator qui fait essentiellement la même chose.
http://docs.Oracle.com/javase/7/docs/api/Java/lang/Comparable.html
http://www.mkyong.com/Java/java-object-sorting-example-comparable-and-comparator/
Autant que je sache, vous n’avez pas de telles méthodes, vous pouvez le faire; étendre une sous-classe de Collection et ajouter des méthodes de tri (recherche ou techniques comme le tri à bulles, etc.)
Si vous avez une installation pour une base de données (plus de temps système) *, Vous pouvez la mettre ici et utiliser order by * Si vous utilisez JPA.