III - Classes d'usage courant
III- F - La classe Arrays
La classe java.util.Arrays donne accès à des méthodes statiques permettant différentes opérations sur les tableaux en particulier les tris et les recherches d'éléments. En voici quelques méthodes ;
static void sort(tableau) trie tableau en utilisant pour cela l'ordre implicite du type de données du tableau, nombre ou chaînes de caractères.
static void sort (Object[] tableau, Comparator C)
trie trie tableau en utilisant pour comparer les éléments la fonction de comparaison C
static int binarySearch(tableau,élément) rend la position de élément dans tableau ou une valeur <0 sinon. Le tableau doit être auparavant trié.
static int binarySearch(Object[]
tableau,Object élément, Comparator C)
idem mais utilise la fonction de comparaison C pour comparer deux éléments du tableau. Voici un premier exemple :
import java.util.*;
public class sort2 implements Comparator{
// une classe privée interne private class personne{ private String nom; private int age;
public personne(String nom, int age){ this.nom=nom; // nom de la personne this.age=age; // son âge
}
// récupérer l'âge public int getAge(){ return age; }
// identité de la personne public String toString(){ return ("["+nom+","+age+"]"); } }; // classe personne // constructeur public sort2() { // un tableau de personnes
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80), new personne("tournesol",40)};
// tri du tableau de personnes Arrays.sort(amis,this);
// vérification for(int i=0;i<3;i++)
System.out.println(amis[i]); }//constructeur
// la fonction qui compare des personnes public int compare(Object o1, Object o2){ // doit rendre
// -1 si o1 "plus petit que" o2 // 0 si o1 "égal à" o2
// +1 si o1 "plus grand que" o2 personne p1=(personne)o1; personne p2=(personne)o2; int age1=p1.getAge(); int age2=p2.getAge(); if(age1<age2) return (-1); else if (age1==age2) return (0); else return +1;
// fonction de test
public static void main(String[] arg){ new sort2();
}//main }//classe
Examinons ce programme. La fonction main crée un objet sort2. Le constructeur de la classe sort2 est le suivant : // constructeur
public sort2() {
// un tableau de personnes
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80), new personne("tournesol",40)};
// tri du tableau de personnes Arrays.sort(amis,this);
// vérification for(int i=0;i<3;i++)
System.out.println(amis[i]); }//constructeur
Le tableau à trier est un tableau d'objets personne. La classe personne est définie de façon privée (private) à l'intérieur de la classe sort2. La méthode statique sort de la classe Arrays ne sait pas comment trier un tableau d'objets
personne, aussi est-on obligé ici d'utiliser la forme void sort(Object[] obj, Comparator C). Comparator est une interface
ne définissant qu'une méthode :
int compare(Object o1, Object o2)
et qui doit rendre
0 : si o1=o2, -1 : si o1<02, +1 : si o1>o2
Dans le prototype void sort(Object[] obj, Comparator C) le second argument C doit être un objet implémentant l'interface Comparator. Dans le constructeur sort2, on a choisi l'objet courant this :
// tri du tableau de personnes Arrays.sort(amis,this);
Ceci nous oblige à faire deux choses :
1. indiquer que la classe sort2 implémente l'interface Comparator
public class sort2 implements Comparator{
2. écrire la fonction compare dans la classe sort2. Celle-ci est la suivante :
// la fonction qui compare des personnes public int compare(Object o1, Object o2){ // doit rendre
// -1 si o1 "plus petit que" o2 // 0 si o1 "égal à" o2
// +1 si o1 "plus grand que" o2 personne p1=(personne)o1; personne p2=(personne)o2; int age1=p1.getAge(); int age2=p2.getAge(); if(age1<age2) return (-1); else if (age1==age2) return (0); else return +1;
Pour comparer deux objets personne, on utilise ici l'âge (on aurait pu utiliser le nom). Les résultats de l'exécution sont les suivants :
[tournesol,40] [milou,80] [tintin,100]
On aurait pu procéder différemment pour mettre en oeuvre l'interface Comparator :
import java.util.*;
public class sort2 {
// une classe privée interne private class personne{ ##.
}; // classe personne // constructeur public sort2() {
// un tableau de personnes
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80), new personne("tournesol",40)};
// tri du tableau de personnes Arrays.sort(amis,
new java.util.Comparator(){
public int compare(Object o1, Object o2){ return compare1(o1,o2);
}//compare }//classe );
// vérification for(int i=0;i<3;i++)
System.out.println(amis[i]); }//constructeur
// la fonction qui compare des personnes public int compare1(Object o1, Object o2){ // doit rendre
// -1 si o1 "plus petit que" o2 // 0 si o1 "égal à" o2
// +1 si o1 "plus grand que" o2 personne p1=(personne)o1; personne p2=(personne)o2; int age1=p1.getAge(); int age2=p2.getAge(); if(age1<age2) return (-1); else if (age1==age2) return (0); else return +1;
}//compare1
// main
public static void main(String[] arg){ new sort2();
}//main }//classe
L'instruction de tri est devenue la suivante : // tri du tableau de personnes
Arrays.sort(amis,
new java.util.Comparator(){
public int compare(Object o1, Object o2){ return compare1(o1,o2);
}//compare }//classe );
Le second paramètre de la méthode sort doit être un objet implémentant l'interface Comparator. Ici nous créons un tel objet par new java.util.Comparator() et le texte qui suit {#.} définit la classe dont on crée un objet. On appelle cela une classe anonyme car elle ne porte pas de nom. Dans cette classe anonyme qui doit implémenter l'interface
Comparator, on définit la méthode compare de cette interface. Celle-ci se contente d'appeler la méthode compare1
de la classe sort2. On est alors ramené au cas précédent.
La classe sort2 n'implémente plus l'interface Comparator. Aussi sa déclaration devient-elle :
public class sort2 {
Maintenant nous testons la méthode binarySearch de la classe Arrays sur l'exemple suivant :
import java.util.*;
public class sort4 {
// une classe privée interne private class personne{ // attributs
private String nom; private int age; // constructeur
public personne(String nom, int age){ this.nom=nom; // nom de la personne this.age=age; // son âge
}
// récupérer le nom public String getNom(){ return nom;
}
// récupérer l'âge public int getAge(){ return age; }
// identité de la personne public String toString(){
return ("["+nom+","+age+"]"); } }; // classe personne // constructeur public sort4() { // un tableau de personnes
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80), new personne("tournesol",40)};
// des comparateurs
java.util.Comparator comparateur1= new java.util.Comparator(){
public int compare(Object o1, Object o2){ return compare1(o1,o2); }//compare }//classe ; java.util.Comparator comparateur2= new java.util.Comparator(){
public int compare(Object o1, Object o2){ return compare2(o1,o2);
}//compare }//classe ;
// tri du tableau de personnes Arrays.sort(amis,comparateur1); // vérification
for(int i=0;i<3;i++)
// recherches
cherche("milou",amis,comparateur2); cherche("xx",amis,comparateur2); }//constructeur
// la fonction qui compare des personnes public int compare1(Object o1, Object o2){ // doit rendre
// -1 si o1 "plus petit que" o2 // 0 si o1 "égal à" o2
// +1 si o1 "plus grand que" o2 personne p1=(personne)o1; personne p2=(personne)o2; int age1=p1.getAge(); int age2=p2.getAge(); if(age1<age2) return (-1); else if (age1==age2) return (0); else return +1;
}//compare1
// la fonction qui compare une personne à un nom
public int compare2(Object o1, Object o2){ // o1 est une personne
// o2 est un String, le nom nom2 d'une personne // doit rendre
// -1 si o1.nom "plus petit que" nom2 // 0 si o1.nom "égal à" nom2
// +1 si o1.nom "plus grand que" nom2 personne p1=(personne)o1; String nom1=p1.getNom(); String nom2=(String)o2; return nom1.compareTo(nom2); }//compare2
public void cherche(String ami,personne[] amis, Comparator comparateur){ // recherche ami dans le tableau amis
int position=Arrays.binarySearch(amis,ami,comparateur); // trouvé ?
if(position>=0)
System.out.println(ami + " a " + amis[position].getAge() + " ans"); else System.out.println(ami + " n'existe pas dans le tableau");
}//cherche
// main
public static void main(String[] arg){ new sort4();
}//main }//classe
Ici, nous avons procédé un peu différemment des exemples précédents. Les deux objets Comparator nécessaires aux méthodes sort et binarySearch ont été créés et affectés aux variables comparateur1 et comparateur2.
java.util.Comparator comparateur1= new java.util.Comparator(){
public int compare(Object o1, Object o2){ return compare1(o1,o2); }//compare }//classe ; java.util.Comparator comparateur2= new java.util.Comparator(){
public int compare(Object o1, Object o2){ return compare2(o1,o2);
}//compare }//classe ;
Une recherche dichotomique sur le tableau amis est faite deux fois dans le constructeur de sort4 : // recherches
cherche("milou",amis,comparateur2); cherche("xx",amis,comparateur2);
La méthode cherche reçoit tous les paramètres dont elle a besoin pour appeler la méthode binarySearch :
public void cherche(String ami,personne[] amis, Comparator comparateur){ // recherche ami dans le tableau amis
int position=Arrays.binarySearch(amis,ami,comparateur); // trouvé ?
if(position>=0)
System.out.println(ami + " a " + amis[position].getAge() + " ans"); else System.out.println(ami + " n'existe pas dans le tableau");
}//cherche
La méthode binarySearch travaille avec le comparateur comparateur2 qui lui-même fait appel à la méthode compare2 de la classe sort4. La méthode rend la position du nom cherché dans le tableau s'il existe ou un nombre <0 sinon. La méthode compare2 sert à comparer un objet personne à un nom de type String.
// la fonction qui compare une personne à un nom public int compare2(Object o1, Object o2){ // o1 est une personne
// o2 est un String, le nom nom2 d'une personne // doit rendre
// -1 si o1.nom "plus petit que" nom2 // 0 si o1.nom "égal à" nom2
// +1 si o1.nom "plus grand que" nom2 personne p1=(personne)o1;
String nom1=p1.getNom(); String nom2=(String)o2; return nom1.compareTo(nom2); }//compare2
Contrairement à la méthode sort, la méthode binarySearch ne reçoit pas deux objets personne, mais un objet
personne et un objet String dans cet ordre. Le 1er paramètre est un élément du ableau amis, le second le nom de
la personne cherchée.