Lors de l'utilisation de Comparables et Comparateur

Utilisation Comparable si vous souhaitez définir un par défaut (naturel) de la commande le comportement de l'objet en question, une pratique courante consiste à utiliser une technique ou naturel (base de données?) identifiant de l'objet pour cela.

Utilisation Comparateur si vous souhaitez définir un externe contrôlable de commande de comportement, cela peut remplacer la valeur par défaut de la commande de comportement.

Comparable - java.lang.Comparable: int compareTo(Object o1)

Comparable objet est capable de se comparer avec un autre objet. La classe elle-même doit implémente java.lang.Interface Comparable afin d'être en mesure de comparer ses instances.

• Capable de comparer objet en cours à la condition d'objet.
• En utilisant ce que nous pouvons mettre en œuvre only one sort sequence basé sur les instances de propriétés.
  EX: Person.id
• Certaines Classes Prédéfinies comme String, classes d'emballage, la Date, le Calendrier a mis en œuvre interface Comparable.

---

Comparateur - java.util.Comparator: int compare(Object o1, Object o2)

Un comparateur objet est capable de comparer deux objets différents. La classe n'est pas à comparer son cas, mais certains autres de la classe des instances. Ce comparateur de classe doit implémenter l'java.util.Comparateur interface.

• Capable de comparer deux Objets de Même Type.
• En utilisant ce que nous pouvons mettre en œuvre many sort sequence et le nom de chacun, basé sur les instances de propriétés.
  EX: Person.id, Person.name, Person.age
• Nous pouvons mettre en œuvre Comparateur interface de notre Pré-défini les classes Personnalisées de tri.

---

Exemple:

public class Employee implements Comparable<Employee> {
private int id;
private String name;
private int age;
private long salary;
//Many sort sequences can be created with different names.
public static Comparator<Employee> NameComparator = new Comparator<Employee>() {         
@Override
public int compare(Employee e1, Employee e2) {
return e1.getName().compareTo(e2.getName());
}
};
public static Comparator<Employee> idComparator = new Comparator<Employee>() {       
@Override
public int compare(Employee e1, Employee e2) {
return Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
}
};
public Employee() { }
public Employee(int id, String name, int age, long salary){
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
//setters and getters.
//Only one sort sequence can be created with in the class.
@Override
public int compareTo(Employee e) {
//return Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
//return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
if (this.id > e.id) {
return 1;
}else if(this.id < e.id){
return -1;
}else {
return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
}
}   
public static void main(String[] args) {
Employee e1 = new Employee(5, "Yash", 22, 1000);
Employee e2 = new Employee(8, "Tharun", 24, 25000);
List<Employee> list = new ArrayList<Employee>();
list.add(e1);
list.add(e2);
Collections.sort(list); //call @compareTo(o1)
Collections.sort(list, Employee.nameComparator); //call @compare (o1,o2)
Collections.sort(list, Employee.idComparator); //call @compare (o1,o2)
}
}

• Personnalisés tri-nous aller pour comparateur @comparer(o1, o2) pour les autres scénarios, nous faire de comparable @compareTo(o1), avec changement de code, si nous voulons trier plus d'un terrain, puis nous utilisons comparateur.

Pour Java 8 Lambda : Comparateur référer à mon post.

Comparateur de tout ce qui comparable ne, plus plus.

| | Comparable | Comparator
._______________________________________________________________________________
Is used to allow Collections.sort to work | yes | yes
Can compare multiple fields | yes | yes
Lives inside the class you’re comparing and serves | |
as a “default” way to compare | yes | yes
Can live outside the class you’re comparing | no | yes
Can have multiple instances with different method names | no | yes
Input arguments can be a list of | just Object| Any type
Can use enums | no | yes


J'ai trouvé la meilleure approche à utiliser les comparateurs en tant qu'anonyme classes comme suit:

private static void sortAccountsByPriority(List<AccountRecord> accounts) {
Collections.sort(accounts, new Comparator<AccountRecord>() {
@Override
public int compare(AccountRecord a1, AccountRecord a2) {
return a1.getRank().compareTo(a2.getRank());
}
});
}

Vous pouvez créer plusieurs versions de ces méthodes à l'intérieur de la classe, vous avez l'intention de tri. De sorte que vous pouvez avoir:

• sortAccountsByPriority
• sortAccountsByType

• sortAccountsByPriorityAndType

  etc...

Maintenant, vous pouvez utiliser ces méthodes de tri n'importe où et obtenir la réutilisation du code.
Cela me donne tout comparable serait, de plus en plus ... donc je ne vois pas de raison d'utiliser comparables.

Si le tri des objets doit être fondé sur l'ordre naturel, puis utilisez Comparables, alors que, si vous le tri doit être fait sur les attributs de différents objets, puis de les utiliser comme base de Comparaison dans Java.

Principale différence entre Comparables et Comparateur:

+------------------------------------------------------------------------------------+
¦               Comparable                ¦                Comparator                ¦
¦-----------------------------------------+------------------------------------------¦
¦ java.lang.Comparable                    ¦ java.util.Comparator                     ¦
¦-----------------------------------------+------------------------------------------¦
¦ int objOne.compareTo(objTwo)            ¦ int compareTo(objOne, objTwo)            ¦
¦-----------------------------------------+------------------------------------------¦
¦ Negative, if objOne < objTwo            ¦ Same as Comparable                       ¦
¦ Zero,  if objOne == objTwo              ¦                                          ¦
¦ Positive,  if objOne > objTwo           ¦                                          ¦
¦-----------------------------------------+------------------------------------------¦
¦ You must modify the clas whose          ¦ You build a class separate from to sort. ¦
¦ instances you want to sort.             ¦ the class whose instances you want       ¦
¦-----------------------------------------+------------------------------------------¦
¦ Only one sort sequemce can be created   ¦ Many sort sequences can be created       ¦
¦-----------------------------------------+------------------------------------------¦
¦ Implemented frequently in the API by:   ¦ Meant to be implemented to sort          ¦
¦ String, Wrapper classes, Date, Calandar ¦ instances of third-party classes.        ¦
+------------------------------------------------------------------------------------+

Les points suivants vous aider à décider dans quelles situations on devrait utiliser Comparables et dans lequel Comparateur:

1) Code De La Disponibilité De L'

2) Seul Contre Plusieurs Critères De Tri

3) Arays.sort() et de la Collection.sort()

4) Comme clés dans SortedMap et SortedSet

5) Plus le Nombre de classes Versus flexibilité

6) Interclasses comparisions

7) Ordre Naturel

Pour plus de détails sur l'article, vous pouvez vous référer Lors de l'utilisation de comparables et quand utiliser un comparateur

Si vous avez besoin naturel de l'ordre de tri -- Utilisateur Comparable
SI vous avez besoin de bon de Commande Tri - Utiliser le Comparateur de

Exemple:

Class Employee{
private int id;
private String name;
private String department;
}

Ordre naturel de Tri serait basée sur l'id parce qu'il serait unique et personnalisé afin sortin g serait le nom et le service.

Références:

Quand une classe Comparable et/ou de Comparaison?
http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html

Mon besoin était de tri basé sur la date.

J'ai utilisé Comparables et il a facilement pour moi.

public int compareTo(GoogleCalendarBean o) {
//TODO Auto-generated method stub
return eventdate.compareTo(o.getEventdate());
}

Une restriction Comparable, c'est qu'ils ne peuvent pas utilisés pour les Collections autres que de dresser la Liste.

Il m'a été demandé de tri d'une certaine gamme de nombres de mieux que nlogn temps dans l'une de interview. (N'utilisant pas de Comptage de tri)

La mise en œuvre interface Comparable sur un objet permet implicite algos de tri à utiliser substituée méthode compareTo à l'ordre de tri des éléments et qui serait en temps linéaire.

Approche très simple est de supposer que la classe d'entité en question être représentées dans la base de données, puis dans la table de base de données vous avez besoin de l'indice composé de champs de la classe d'entité? Si la réponse est oui, alors la mettre en œuvre comparable et l'utilisation de l'indice de champ(s) pour les ordre de tri. Dans tous les autres cas, utilisez le comparateur.