Pourquoi les List n'ont pas besoin de Comparable contrairement au Set?
C'est une question que je me suis posé après avoir vu des annales de mon université.
Pourquoi les List n'ont pas besoin de Comparable contrairement au Set?
Par exemple avec ce code:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
class Personnels implements Comparable, PersonnelsStandard{
int no;
int anciennete;
String nom;
String adresse;
ElementsSalaire es;
HistoriqueServices histo;
Personnels(int no,String n,String a, int base,int anc){
this.no=no; à compléter
}
public String toString(){
return no + " " + nom + " " + " base "+ es.salaireBase+" Primes " + es.primes + " sal. Total "+es.salaireTotal()+
" Histo Serv. "+historique();
}
public List historique(){
return histo.services;}
public void ajoutHistorique(Sites s){histo.services.add(s);}
public void ajoutPrime(String pr){
if (pr=="PA") {es.primes.add(es.new PrimeAnciennete(this));}
if (pr=="PR") {es.primes.add(es.new PrimeResultat(this));}
}
public void suppressionPrime(String pr){
à compléter
}
public int compareTo(Object o){
return(no-((Personnels)o).no);
}
private class ElementsSalaire{
int salaireBase;
List primes;
ElementsSalaire(int b){salaireBase=b;primes= new ArrayList();}
int salaireTotal(){
int x=0;
for (int i=0;i<primes.size();i++)x=x+((Prime)(primes.get(i))).montant;
return salaireBase+x;}
class PrimeAnciennete extends Prime{
PrimeAnciennete(Personnels p){
super(p);type="PA";calculPrime();
}
void calculPrime(){
montant=(int)(p.es.salaireBase*anciennete*0.02);
}
public String toString(){return "PA= "+montant;}
}
class PrimeResultat extends Prime{ PrimeResultat(Personnels p){
super(p);type="PR";calculPrime();
}
void calculPrime(){
montant=(int) (p.es.salaireBase*0.05);
}
public String toString(){
return type+" "+montant;}
}
}
class HistoriqueServices{
List services;
HistoriqueServices(){services= new ArrayList();}
}
}
abstract class Prime implements Comparable{
Personnels p;
int montant; String type;
static List L=new ArrayList(); Prime(Personnels p){this.p=p;L.add(this);}
abstract void calculPrime();
public String toString(){return type;}
public int compareTo(Object o){return montant - ((Prime)o).montant;}
} |
compareTo() n'est pas obligatoire pour la classe Prime (car les primes sont ajoutées à une collection (List) de la classe interne ElementsSalaire de Personnels). Les instances de Personnels sont ajoutées à une collection de type Set, compareTo() est nécessaire.
Pourtant Prime impélmente Comparable! Tout comme Personnels!
Je suis prêts à recevoir vos lumières qui éclaireront mon obscure pensée
