Bonjour,  
 
je voudrais savoir comment modifier ce code pour qu'il m'affiche la même chose mais ordonné suivant le nom .  
 
Merci  
 
list est de type List<Person>  
 
 

 
 
j'ai pas le courage de tester

Collections#sort(List, Comparator)

public String affiche(){
    StringBuilder sb  = new StringBuilder();
    
    Collections.sort (list)
    for(Person p : list) {
        sb.append( "Nom : " ).append(p.getName());
        sb.append( ", type : " ).append(p.getClass()).append( "\n" );
    }
    return sb.toString();
    }

Fonctionne si Person implémente Comparable (en comparant sur le nom bien sûr), mais ça va faire gueuler moinmoin
(accessoirement t'aurais pu utiliser code=java au lieu de cpp, feignasse )

Ah oui merde, je croyais qu'il triait des strings
 
et pour la balise, c'est lui qui a commencé

La vieille excuse
 
Faut faire gaffe aussi sur le fait que Collections#sort effectue un sort in-place, donc faut faire une shallow copy de la liste avant le sort si on ne veut pas qu'elle soit stockée triée

Collections#sort(List, Comparator)

La classe qui doit implémenter Comparable est abstraite, cela ne fonctionne pas .
Il n'y a pas d'autres méthodes ?

Comparator, qu'on te dit.

Heuu, et alors?
 
Je sais pas ce que t'as fumé, mais chez moi ça fonctionne très bien:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public abstract class Person implements Comparable<Person> {
    private String name;
    private String surname;
    private String title;
 
    public static void main(String[] args) {
        Manager manager = new Manager( "Doe", "John" );
        CodeMonkey monkey = new CodeMonkey( "Monkey", "Code" );
        
        List<Person> employees = new ArrayList<Person>();
        
        employees.add(monkey);
        employees.add(manager);
        
        System.out.println( "Pre-sort employees" );
        for(Person p: employees) {
            System.out.println(p);
        }
        System.out.println( "" );
        Collections.sort(employees);
        System.out.println( "Post-sort employees" );
        for(Person p: employees) {
            System.out.println(p);
        }
    }
    
    public Person(String name, String surname) {
        this.name = name;
        this.surname = surname;
        this.title = getTitle();
    }
    public abstract String getTitle();
 
    public int compareTo(Person elm) {
        return name.compareTo(elm.name);
    }
 
    @Override
    public String toString() {
        StringBuffer out = new StringBuffer();
        out.append(title);
        out.append( " " );
        out.append(surname);
        out.append( " " );
        out.append(name);
        return  out.toString();
    }
}

public class Manager extends Person {
 
    public Manager(String name, String surname) {
        super(name, surname);
    }
 
    @Override
    public String getTitle() {
        return "Manager";
    }
}

public class CodeMonkey extends Person {
 
    public CodeMonkey(String name, String surname) {
        super(name, surname);
    }
 
    @Override
    public String getTitle() {
        return "Code Monkey";
    }
 
}

 
Output:

Person est abstract, c'est la classe qui implémente Comparable (et compareTo, ses classes dérivées ne touchent jamais à compareTo), ça marche  
 
Après, pour le débat sur Comparator/Comparable, joue avec -- il aime bien en discuter de manière calme et courtoise

non

mais si, fais donc pas ton timide

C'est quoi le pb avec Comparable ?

Je me répond a moi meme : c'est vrai qu'avec Comparable ca défini aussi l'égalité d'object, ca peut poser pb dans le cas de structure qui ne gere pas les doublons ...
 
j'y avait jamais pensé tiens

en fait c'est Benou, spa --
 
le truc, c'est qu'il y a mille facons de comparer deux objets "Person" et a ce titre que ca n'a pas de sens reel que la classe Person implemente Comparable (comparaison par age, par nom, taille de bite, que sais-je encore ) et il est donc preferable d'utiliser un Comparator dedie au type de comparaison que l'on souhait mettre en oeuvre

Comparable ne devrait être utilisé que quand il y a un véritable ordre naturel aux objects, càd qu'il n'y a qu'une manière "sensible" de les comparer (exemple pour les nombres l'ordre naturel de comptage).
 
Les autres objets, pouvant potentiellement avoir de multiples bases de comparaisons (et d'ordonnancement) devraient utiliser des comparators (puisqu'ils n'ont pas de base de comparaison unique et intrinsèque, uniquement des conventions).
 
Exemple, les strings peuvent être comparés par ordre alphabétique (dictionnaire), mais il faut décider de la position que l'on donne aux lettres accentuées (aux caractères non-ascii en fait), au fait que la comparaison prenne en compte la casse ou pas, se demander si on effectue une comparaison numérique intelligente ou pas (== "foo2" devrait-il être avant ou après "foo10"? en comparaison alpha classique il sera après, en comparaison numérique intelligente il sera avant), etc etc etc.
 
Donc philosophiquement parlant les Strings par exemple ne devraient pas implémenter Comparable mais devraient en permanence utiliser des Comparators. En pratique néamoins dans la mesure ou le tri de chaînes le plus fréquent se fait par ordre lexicographique la majorité des langages (java compris) implémentent une comparaison par ordre lexicographique par défaut sur les strings.
 
C'est un cas classique de pûreté vs simplicité.
 
Ici, si la seule comparaison qui soit jamais effectuée est faite sur le nom autant utiliser Comparable (IMO), ça ne vaut pas le coup de se faire chier avec des Comparator.
Par contre si d'autres types de tris doivent être effectués (tri par âge, par profession, ...; et il est probable que ce soit le cas) mieux vaut passer par des Comparators on y gagne sur le long terme.

L'utilisation de Comparator aussi définit des égalités

Bien sûr que si c'est --, j'ai déjà débattu de ça avec lui

 
ouais, aussi

 
oui, oui, bien sur, mais ce que je voulais dire, c'est que Comparator n'est utilisé qu'a la demande, donc pas de risque d'effet de bord contrairement a Comparable, genre si on utilise un Set qui ne gère pas les doublons, si l'object implémente Comparable sur par ex le nom de la personne, on peut perdre des gens sans faire gaffe (si il y a plusieurs personnes avec le meme nom bien sur ).
 
Apres pour savoir si la comparaison est légitime (naturelle) suivant l'objet, c'est un choix fonctionnel, je ne vais pas débattre la dessus

Merci d'avoir résolu mon problème