EXERCICE 1 : Moyenne des valeurs d' un tableau

Ecrire un programme qui demande à l' utilisateur d' entrer les notes sur 20 de 10 élèves d' une classe. Puis le programme affiche la moyenne de ces notes.

 CORRECTION 1 : 

1.     public class Exercice1
2.     {
3.          public static void main (String [] args)
4.          {
5.               double [] notes = new double [10]; double somme = 0;
6.               for(int i = 0; i < notes.length; i++)
7.               {
8.                    System.out.println("entrez une nouvelle note : ");
9.                    notes[i] = Lire.reelDouble();
10.                   somme += notes[i];
11.              }
12.              System.out.println("moyenne des notes = " + somme/notes.length);
13.         }
14.    }         

Si vous n' avez pas compris la correction de cet exercice, regardez les exos sur les boucles. ICI. Ce qui veut dire d' ailleurs qu' on aurait pu résoudre ce problème sans les tableaux.

EXERCICE 2 : affectation d' un tableau au hasard

Ecrire un programme qui affecte aux 6 éléments d' un tableaux, des valeurs entières prises au hasard entre - 11 et + 11. Puis le programme affiche ces valeurs sur la même ligne.

 CORRECTION 2 : 

1.     public class Exercice2
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = new int [5];
6.               for(int i = 0; i < tab.length; i++)
7.               {
8.                     tab[i] = (int)(Math.random() * 23) - 11 ;
9.               }
10.              for(int i = 0; i < tab.length; i++)
11.              {
12.                   System.out.print(tab[i] + "*" );
13.              }
14.         }
15.    }

ligne 5 : on crée la table de type int avec 6 éléments. La première boucle permet d' initialiser chaque variable(élément) avec un nombre entier pris au hasard entre -11 et 11. Math.random() renvoie un nombre dans l' intervalle [0, 1[ . Donc (Math.random() * 23) renvoie un nombre dans l' intervalle [0, 23[ Puisque [0, 1[ fois 23 donne à la borne inférieure, 0 fois 23 = 0 et à la borne supérieure 1 fois 23 = 23. Le (int) permet une conversion explicite (cast) du nombre double en entier. Donc renvoie un nombre entier compris entre 0 et 22 (inclus) Puis en enlevant 11, on trouve [-11, 11].

EXERCICE 3 : Le nombre le plus proche de x dans un tableau d' entiers

Ecrire un programme qui recherche dans un tableau d' entiers, un nombre proche d' un entier x. Puis le programme affiche ce nombre

 CORRECTION 3 : 

1.     public class Exercice3
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = {5, 12, 9, 21, 3, 7, 31, 6, 10, 2};
6.               int x = 8; int proche = 5; int plusProche = 5;
7.               
8.               for(int i = 0; i < (tab.length - 1); i++)
9.               {
10.                   if ( Math.abs(x - tab[i]) < Math.abs(x - tab[i + 1]) )
11.                   {
12.                        proche = tab[i];
13.                        if ( Math.abs(x - proche) < Math.abs(x - plusProche) )
14.                        {
15.                             plusProche = proche;
16.                        }                      
17.                   }
18.                   else
19.                   {
20.                        proche = tab[i + 1];
21.                        if ( Math.abs(x - proche) < Math.abs(x - plusProche) )
22.                        {
23.                            plusProche = proche;
24.                        }
25.                   }                         
26.            }
27.            System.out.println("nombre le proche = " + plusProche);
28.         }
29.    }

Voici le genre de problème facile à comprendre. Vous écrivez alors facilement le code. Puis le résultat est loin de la vérité. Puis vous réfléchissez un peu. Puis vous codez à nouveau. Puis le résultat est à nouveau pas bon. Ainsi de suite. Et ça peut durer très longtemps comme ça. Jusqu' au découragement. Des problèmes comme ça, vous aurez à les affronter tout au long de votre carrière de programmeur. C' est pourquoi les explications ici vont être longues.

Si vous compilez puis exécutez ce programme, il sera affiché :

nombre le proche = 9

EXPLICATIONS :
Si vous voulez savoir de 2 nombres a et b, le plus proche de x, et sans penser à la programmation, vous cherchez la différence la plus faible. Si la différence entre x et a est plus faible que celle entre x et b, alors, a est plus proche de x. Mais attention, si vous avez par exemple a = 9, b = 14 et x = 10. x - a = 1 et x - b = -3. Cette logique vous fera croire que b est plus proche de x alors que c' est faux. Alors, il vaut mieux raisonner en terme de valeur absolue. De 2 nombres a et b, le plus proche de x est celui dont la valeur absolue de la différence entre ce nombre et x est plus faible.
Ligne 5 : déclaration et affectation des éléments du tableau. Ligne 6 : déclaration et affectation de la variable x dont on cherche le nombre le plus proche dans le tableau. La variable proche contient la valeur du nombre le plus proche de x en comparant seulement 2 valeurs quelqconques du tableau. La variable plusProche sera expliquée plus bas.
Voyons maintenant la boucle. On lui donne comma valeur initiale, le premier élément du tableau. Parce que sa valeur finale sera forcément celle de l' un des éléments du tableau.
On parcours alors la boucle du premier à l' avant-dernier élément. Pourquoi ? Parce que on veut comparer les différences entre l' un des éléments et x avec l' élément suivant et x. Si on parcours la boucle du premier au dernier. L' élément en position i+ 1 n' existera pas lorsque i sera la dernière position.
Voyons maintenant l' intérieur de la boucle. Avant tout, faîtes abstraction des lignes 13 à 16 et des lignes 21 à 24. Je les expliquerai plus bas en même temps que la variable plusProche.
En parcourant donc la boucle de la position zéro à l' avant dernier élément, je dis que si la valeur absolue de la différence entre x et la valeur du tableau en position i est inférieure à celle de la différence entre x et la valeur en position i + 1 (ligne 10), alors, proche = l' élément en position i (ligne 12). Sinon (ligne 18), proche = élément en position i + 1. Logique : Si ce n' est l' un, c' est forcément l' autre. Si je m' en tenais à cette façon de voir les choses, j' aurais ceci :

comparaison de 5 et 12, proche = 5. Puis comparaison entre 12 et 9, proche = 9. Puis comparaison entre 9 et 21, proche = 9. Puis comparaison entre 21 et 3, proche = 3. Puis comparaison entre 3 et 7, proche = 7. Puis comparaison entre 7 et 31, proche = 7. Puis comparaison entre 31 et 6 proche = 6. Puis comparaison entre 6 et 10. proche = 6. Puis comparaison entre 10 et 2, proche = 10.

Vous voyez ? Une absurdité. Dans ce cas, que faut-il faire. C' est donc là qu' intervient une nouvelle variable que j' appelle plusProche. A chaque tour de la boucla, sa valeur sera celle plus proche de x en comparant la valeur précédente de proche et la nouvelle valeur de proche. Je m' explique :
Je déclare plusProche en l' affectant la valeur initiale de proche. Parce que plusProche aura comme valeur, l' une des valeurs que prendra la variable proche tout au long de la boucle. Puis je compare la nouvelle valeur de proche et l' ancienne valeur de proche. Ligne 13 : Je dis que si la valeur absolue de la différence entre x et la nouvelle valeur de proche (la valeur de proche à un instant t est toujours la nouvelle valeur de proche) est inférieure la valeur absolue de la différence entre x et l' ancienne valeur de proche qui est plusProche, alors, plusProche est égale proche. Je m' explique là dessus. J' ai initialisé plusProche avec la première valeur de proche. Donc, l' ancienne valeur de proche. Lorsque je dis, dans la boucle, que plusProche = proche, je donne à plusProche la nouvelle valeur de proche. Mais quand je sors de cette boucle soit par la ligne 17 avec if ou par la ligne 25 avec else, et que je rentre à nouveau dans la boucle, du coup, plusProche contient maintenant l' ancienne valeur de proche. Puisque la nouvelle valeur de proche se trouve maintenant ligne 12 ou ligne 20.

Je sais que ça n' a pas l' air évident en lisant une seule fois. Aussi je vous demanderais de lire 2, 3, 4 ou 5 fois, je suis sûr que ça sera compréhensible. En tout cas, ça marche. Vous pouvez vous amuser à changer la valeur de x, à l' affichage, vous aure une nouvelle valeur plus proche de x.

EXERCICE 3 : afficher les valeurs d' un tableau dans l' ordre inverse

Ecrire un programme qui permet à l' utilisateur de saisir au clavier des nombres entiers. Puis les affiche dans l' ordre inverse de la saisie. Par exemple, si vous saisissez 3, 8, 1, 10 il sera affiché 10, 1, 8, 3. Considerez une saisie de 6 éléments pour exemple. Et saisie les nombres suivants : 1, 2, 3, 4, 5, 6.

 CORRECTION 3 : 

1.     public class Exercice3
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = new int [6];
6.               for(int i = 0; i < 6; i++)
7.               {
8.                   System.out.print("saisissez le nombre en position " + i + " : ");
9.                   tab[i] = Lire.entierInt();
10.              }
11.              System.out.println("valeurs du tableau dans l ordre inverse ");
12.              for(int i = 5; i >= 0; i--)
13.              {
14.                    System.out.print(tab[i] + " " );
15.              }
16.         }
17.    }

Si vous exécutez ce programme après compilation, il sera affiché : 6 5 4 3 2 1. Pas difficle à comprendre. La première boucle permet la saisie. La deuxième permet l' affichage et vous voyez bien que l' on commence par le dernier élément. Celui en position 5, puisque le tableau a 6 éléments. On va de 5 à 0 en décrémentant (i--).

EXERCICE 4 : inverser l' ordre des valeurs d' un tableau

Ecrire un programme qui permet d' inverser l' ordre des valeurs d' un tableau d' entiers. Si le tableau possède les valeurs dans cet ordre : 1, 2, 3, 4, 5, 6. En fin de programme, l' ordre sera : 6, 5, 4, 3, 2, 1.
Non, ce n' est pas le même exercice que l' exo 3. Dans l' exo 3, l' ordre des valeurs d' un tableau ne change pas. C' est en affichant qu' on commence par le dernier pour terminer par le premier. Ici, lorsque vous aurez changé l' ordre des valeurs, vous afficherez les valeurs de ce tableau en commençant par le premier. Mais le nouveau sera inverse de l' ancien. Allons-y !

 CORRECTION 4 : 

1.     public class Exercice4
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = {1, 2, 3, 4, 5, 6};
6.               System.out.println("les valeurs du tableau initial sont :");
7.               for(int i = 0; i < tab.length; i++)
8.               {
9.                    
10.                   System.out.print(tab[i] + " ");                
11.              }
12.              // Maintenant, inversons l ordre des valeurs. La boucle suivant le permet
13.              for( int i = 0; i < 3; i++)
14.              {
15.                   int tempo = tab[i];
16.                   tab[i] = tab[5 - i];
17.                   tab[5 - i] = tempo;
18.              }
19.              System.out.println();
20.              System.out.println("les valeurs du tableau final sont :");
21.              for(int i = 0; i < tab.length; i++)
22.              {
23.                   System.out.print(tab[i] + " ");                
24.              }
25.         }
26.    }

Il sera affiché :
les valeurs du tableau initial sont :
1 2 3 4 5 6
les valeurs du tableau final sont :
6 5 4 3 2 1

Ligne 5 : initialisation du tableau. lignes 7 à 10 : boucle permettant l' affichage des valeurs du tableau dans l' ordre. ligne 11 : un commentaire sur une ligne. Ce n' est pas souvent que j' en met. A partir de maintenant, j' en mettrai un peu plus souvent.
Expliquon maintenant la deuxième boucle. Celle qui permet l' inversion des valeurs du tableau. Je parcours la boucle de la position 0 à la position correspondant exactement à la moitié de la boucle. Et je dis que la valeur de l' élément en position i = celle en position 5 - i. 5 étant la position du dernier élément (ligne 15). Puis celle de l' élément en position 5 - i a la valeur initiale de celle en position i. Celle-ci a été mise dans une variable temporaire tempo. Souvenez vous. Pour échanger les valeurs de 2 variables, on est obligé de créer une troisième variable afin d' y mettre l' une des valeurs de l' échange. Voir l' exemple 15 du paragraphe 1.4 opérations sur les variables.
Ainsi, l' élément en position zéro échange sa valeur avec celui en position 5 - 0 = 5. premier et dernier.
L' élément en position 1 échange sa valeur avec celui en position 5-1 = 4. deuxième et avant-dernier. Ainsi de suite. Et voilà !

EXERCICE 5 : même exercice que le 4.

Mais cette fois, le tableau a 5 éléments, un nombre impairs. De 1, 2, 3, 4, 5 on obtient 5, 4, 3, 2, 1.

 CORRECTION 5 : 

1.     public class Exercice5
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = {1, 2, 3, 4, 5};
6.               System.out.println("les valeurs du tableau initial sont :");
7.               for(int i = 0; i < tab.length; i++)
8.               {
9.                    
10.                   System.out.print(tab[i] + " ");                
11.              }
12.              // Maintenant, inversons l ordre des valeurs. La boucle suivant le permet
13.              for( int i = 0; i < 3; i++)
14.              {
15.                   int tempo = tab[i];
16.                   tab[i] = tab[4 - i];
17.                   tab[4 - i] = tempo;
18.              }
19.              System.out.println();
20.              System.out.println("les valeurs du tableau final sont :");
21.              for(int i = 0; i < tab.length; i++)
22.              {
23.                   System.out.print(tab[i] + " ");                
24.              }
25.         }
26.    }

La question que vous vous posez est sans doute de savoir ce que ça change que la taille du tableau soit un nombre impair. Pas grand chose en fait. Sauf qu' on ne peut pas parcourir le tableau de position zéro à la position correspondant à la moitié. Puisque la moitié d' un nombre impair n' est pas un entier. Alors, la boucle est parcourue de zéro à taille du tableau - 1. Puisque dans cet échange, la valeur de l' élément central ne change pas. 1 2 3 4 5 donne 5 4 3 2 1. L' élément central, donc en position 3 a toujours la valeur 5. Puis on change les lignes 15 et 16. Au lieu de 5, on a 4. Voilà, c' est tout.

EXERCICE 6 : Généraliser 4 et 5

Prévoir que le programme demande maintenant à l' utilisateur de saisir la taille du tableau. Et selon la taille, les choses se feront un peu différement.

 CORRECTION 6 : 

1.     public class Exercice6
2.     {
3.          public static void main (String [] args)
4.          {
5.               System.out.print("Saisissez la taille de votre tableau : ");
6.               int n = Lire.entierInt();
7.               int [] tab = new int [n];
8.               System.out.println("Saisissez les valeurs du tableau :");
8.               for(int i = 0; i < n; i++)
9.               {
10.                   System.out.print("saisissez le nombre en position " + i + " : ");
10.                   tab[i] = Lire.entierInt();
11.              }
12.              if(n % 2 == 0)// si la taille du tableau est pair
13.              {
14.                    System.out.println("les valeurs du tableau initial sont :");
15.                    for(int i = 0; i < n; i++)
16.                    {
17.                        System.out.print(tab[i] + " ");                
18.                    }
19.                   // Maintenant, inversons l ordre des valeurs. La boucle suivant le permet
20.                   for( int i = 0; i < n/2; i++)
21.                   {
22.                        int tempo = tab[i];
23.                        tab[i] = tab[n - 1 - i];
24.                        tab[n - 1 - i] = tempo;
25.                   }
26.                   System.out.println();
27.                   System.out.println("les valeurs du tableau final sont :");
28.                   for(int i = 0; i < tab.length; i++)
29.                   {
30.                        System.out.print(tab[i] + " ");                
31.                   }
32.              }
33.              else// dans le cas où la taille du tableau est impair
34.              {
35.                   System.out.println("les valeurs du tableau initial sont :");
36.                   for(int i = 0; i < n; i++)
37.                   {
38.                        System.out.print(tab[i] + " ");                
39.                   }
40.                   // Maintenant, inversons l ordre des valeurs. La boucle suivant le permet
41.                   for( int i = 0; i < (n - 1)/2; i++)
42.                   {
43.                       int tempo = tab[i];
44.                       tab[i] = tab[n - 1 - i];
45.                       tab[n - 1 - i] = tempo;
46.                   }
47.                   System.out.println();
48.                   System.out.println("les valeurs du tableau final sont :");
49.                   for(int i = 0; i < n; i++)
50.                   {
51.                        System.out.print(tab[i] + " ");                
52.                   }
53.              }
54.         }
55.    }

compilez puis exécutez. ça marche à merveille. Exécuter dans les deux cax : taille du tableau = nombre impair et= nombre impair. Saisissez les valeurs du tableau dans l' ordre 1 2 3 4 5 6 et cas impair 1 2 3 4 5 . Ainsi, vous ne perdez pas le temps à réfléchir sur l' inversion des valeurs. C 'est évident tout de suite.

EXERCICE 7 :ordonner les valeurs d' un tableau d' entiers

Ecrire un programme qui classe les valeurs d' un tableau d' entiers par ordre croissant. Exemple : 2, 3, 9, 1, 7 devient 1, 2, 3, 7, 9.

 CORRECTION 7 : 

1.     public class Exercice7
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = {5, 3, 1, 4, 2};
6.               
7.               for(int i = 0; i < 4; i++)
8.               {
9.                    for(int i = 0; i < 4; i++)
10.                   {
11.                        if(tab[i] > tab[i + 1])
12.                        {
13.                             int tempo = tab[i];
14.                             tab[i] = tab[i + 1];
15.                             tab[i + 1] = tempo;
16.                        }
17.                   }
18.              }
19.              // affichage du tableau
20.              for(int i = 0; i < tab.length; i++)
21.              {
22.                   System.out.print(tab[i] + " " );
23.              }
24.         }
25.    }

Après compilation puis exécution, vous verrez affiché les valeurs du tablea&u par ordre croissant : 1 2 3 4 5

Ordonner les éléments d' un tableau se dit en programmation, trier un tableau. Ici, nous avons trié le tableau d' entiers par ordre croissant. Pour comprendre ce programme, considérez d' abord les lignes 9 à 17. Je dis que si l' on parcours le tableau du premier élément à l ' avant dernier (ligne 9), si 2 éléments consécutifs sont tels que la valeur du précédent est supérieure à celui du suivant (ligne 11), alors, il faut permuter les valeurs (lignes 13 à 15. je ne vais pas ré-expliquer ça. Déjà fait des d' autres exemples). C' est ce que tout bon débutant ferait. Et naturellement, à l' affichage, ce ne serait pas forcément suffisant. En effet, Faire seulement ça permet tout au plus de s' assurer que le plus grand élément se trouve en fin de tableau. Voyons un exmple concret :

5, 3, 1, 4, 2 Si j' applique le principe des lignes 9 à 17. J' aurais ceci :

Pour i = 0 : tab[0] > tab[1]. En effet, 5 > 3. Donc je permute et j' ai alors :
3, 5, 1, 4, 2

Pour i = 1 : tab[1] > tab[2]. En effet, 5 > 1. Donc je permute et j' ai alors :
3, 1, 5, 4, 2

Pour i = 2 : tab[2] > tab[3]. En effet, 5 > 4. Donc je permute et j' ai alors :
3, 1, 4, 5, 2

Pour i = 3 : tab[3] > tab[4]. En effet, 5 > 2. Donc je permute et j' ai alors :
3, 1, 4, 2, 5

Comme vous pouvez le constatez, le tableau n' est pas trié par ordre croissant. Il faut refaire tout ceci. Mais cela permet seulement de s' assurer que le deuxième plus grand élément se trouve aussi à la bonne position, avant. Ainsi de suite. Jusqu' à quand ?

1 fois, le 5ème en bonne position
2 fois, le 4ème aussi en bonne position
3 fois, le 3ème aussi en bonne position
4 fois, le 2ème aussien bonne position
Et si les 4 éléments se trouvent en bonne position, forcément le 5ème aussi. Donc, il faut effectuer la boucle (lignes 9 à 18), 4 fois. D' où la première boucle ligne 7 qui contient notre boucle.

Maintenant, refaisons la même correction de manière générale. taille du tableau = n.

 CORRECTION 7Bis : 

1.     public class Exercice7Bis
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = new int[n];
6.               
7.               for(int i = 0; i < (n - 1); i++)
8.               {
9.                    for(int i = 0; i < (n - 1); i++)
10.                   {
11.                        if(tab[i] > tab[i + 1])
12.                        {
13.                             int tempo = tab[i];
14.                             tab[i] = tab[i + 1];
15.                             tab[i + 1] = tempo;
16.                        }
17.                   }
18.              }
19.              // affichage du tableau
20.              for(int i = 0; i < n; i++)
21.              {
22.                   System.out.print(tab[i] + " " );
23.              }
24.         }
25.    }

Il existe un mot en programmation que je n' ai pas utilisé jusqu' ici. Il est sans doute temps de le faire : Algorithme. Une définiton simple de ce mot : ensemble des instructions permettant de résoudre un problème de programmation. En réalité, pas seulement en programmation.

Nous venons de voir exercice 7, un algorithme de tri d' un tableau. Sachez, vous qui êtes débutants en programmation, que les algorithmes de tri, il y en a beaucoup. Les grands informaticiens (10 ans d' expérience minimum) rivalisent dans la recherche d' un algo efficace. Vous aurez l' occasion de voir d' autres algo de tri dans d' autres sites ou autres bouquins. Ici même, lorsque nous étudierons un projet (projet Loto), nous verrons une autre façon de trier plus simple que ce que nous venons de faire. Plus simple en nombre de lignes (restreint), mais un peu moins évidente à comprendre.

EXERCICE 8 : afficher les deux plus grandes notes des élèves d' une classe

Ecrire un programme qui lit au clavier une suite d'entiers représentant les notes obtenues par des étudiants à un examen. L'utilisateur indique la fin de la saisie en tapant (-1). A la fin de la saisie, le programme affiche les deux meilleures notes de la classe

Exercice non corrigé. Maintenant que vous avez l' alogrithme de tri d' un tableau, exercez-vous. Bon courage. 

Vous prenez la correction 7 et vous changez peu de choses.

Laissons tomber les tableaux d' entiers et passons maintenant aux tableaux de String (chaines de caractères).

EXERCICE 9 : affichage d' un nom au hasard

Soit un tableau de String. Chaque élément ayant pour valeur un nom de famille. Ecrire un programme qui affiche l' un des noms pris au hasard.

 CORRECTION 9 : 

1.     public class Exercice9
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] tab = {"Frank", "Chris", "David", "Nico", "Sego", "Hardy", "Pandora"};
6.               int i = (int)(Math.random() * 7);
7.               System.out.println("un nom au hasard : " + tab[i]);
8.         }
9.     }

compilez, puis exécutez, vous verrez s' afficher un nom au hasard.

Ligne 5 : je déclare mon tableau de String avec les valeurs affectées aux 7 éléments du tableau. Si je veux afficher la valeur de l' un des éléments du tableau, par exemple le 2ème, je fait : System.out.println("un nom au hasard : " + tab[1]);

Mais si je veux que soit affichée la valeur de l' un des éléments au hasard, alors, je remplace la position (0, 1, 2, ...) par une variable à qui on affecte un nombre entier pris au hasard entre 0 et 6. D' où la ligne 6. Et ça, on l' a déjà fait dans des exemples du paragraphe 1.5 La classe Math

EXERCICE 10 : affichage d' un nom au hasard commençant par une lettre donnée

Soit un tableau de String. Chaque élément ayant pour valeur un nom de famille. Ecrire un programme qui affiche l' un des noms pris au hasard. A condition que le nom affiché commence par la lettre S

 CORRECTION 10 : 

1.     public class Exercice10
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] tab = {"Simon", "Chris", "David", "Sarko", "Ségo", "Hardy", "Patrick", "Frank", "Samir"};
6.               int i;
7.               do
9.               {
10.               	i = (int)(Math.random() * 10); 
11.              }
12.              while(tab[i].charAt(0) != 'S');
13.               
14.              System.out.println("un nom au hasard commençant par S : " + tab[i]);
15.        }
16.    }

Ligne 5 : tableau de String avec 10 prénoms. Puis on génère au hasard un nombres entier de 0 à 9 ligne 10. Et ce, tant que l' élément en position i n' a pas sa première lettre commençant par S. Vous vous souvenez les méthodes de la classe String ? paragraphe 1.7 La classe String Chqua élément d' un tableau de String est une variable de type String. Donc, on peut lui appliquer les méthodes de cette classe. LA boucle do...while continue donc à affecter un nombre pris au hasard entre 0 et 9 tant que l' élément en position i ne commence pas par S : ligne 12. Puis on affiche cet élément ligne 14.

Dans cet exercice, les seuls prénoms succeptible de s' afficher commencent par S majuscule. Puisque vous le savez, le langage Java est sensible à la casse. Il fait la différence entre majuscule et miniscule. Comment faire pour qu' il soit affiché un prénom commençant par S ou s ? Exercice suivant :

EXERCICE 11 : affichage d' un nom au hasard commençant par une lettre donnée quelque soit sa casse.

Soit un tableau de String. Chaque élément ayant pour valeur un nom de famille. Ecrire un programme qui affiche l' un des noms pris au hasard. A condition que le nom affiché commence par la lettre s majuscule ou miniscule.

 CORRECTION 11 : 

1.     public class Exercice11
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] tab = {"simon", "Chris", "David", "Sarko", "Ségo", "Hardy", "Patrick", "Frank", "Samir"};
6.               int i;
7.               do
9.               {
10.               	i = (int)(Math.random() * 9); 
11.              }
12.              while(tab[i].charAt(0) != 'S' && tab[i].charAt(0) != 's');
13.               
14.              System.out.println("un nom au hasard commençant par S : " + tab[i]);
15.        }
16.    }

Ici, on a seulement changé la ligne 12. On a ajouté du code || tab[i].chatAt(0) != 's'. La boucle do...while continue de tourner tant qu' on n' a pas trouvé une valeur de i telle que la première lettre de l' élément en position i est différent de S ou de s.

EXERCICE 12 : Présence d' un nom dans un tableau de noms.

Ecrire un programme qui demande à l' utilisateur d' entrer un nom. Puis le programme informe à l' utilisateur la présence ou l' absence de ce nom dans le système.

 CORRECTION 12 : 

1.     public class Exercice12
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] tab = {"simon", "Chris", "David", "Sarko", "Ségo", "Hardy", "Patrick", "Frank", "Samir"};
6.               System.out.print("Entrez un nom :"); String nom = Lire.chaine();
7.               String reponse = "Ce nom ne se trouve pas dans notre system";
8.               
9.               for(int i = 0; i < tab.length; i++)
10.              {
11.                   if(tab[i].equals(nom))
12.                   {
13.                        reponse = "Ce nom se trouve dans notre system";
14.                        break;
15.                   }
16.             }
17.             System.out.println(reponse);
18.         }
19.    }

Voici un exo qui apporte quelque chose de nouveau. Attention, suivez le guide !

L' ensemble des noms dans le systeme se trouve dans le tableau tab (ligtne 5). Puis on demande à l' utilisateur d' entrer un nom (ligne 6). Puis la saisie du nom se faite (2ème instruction de ligne 6). Puis on crée une variable reponse qui sera la phrase indiquant si oui ou non, le nom saisi au clavier se trouve pas dans le systeme. Cette variable est initialisée avec la réponse négative. Pourquoi ? Vous le comprendrez ci-dessous. On parcours la boucle de l' élément zéro au dernier (ligne 9). Et on dit que si l' un des éléments a sa valeur correspondant au nom, (ligne 11), alors réponse change de valeur. C' est plutôt la réponse positive. Puis on sort aussitôt de la boucle grâce à break. Pourquoi ? Parce que lorsque l' on trouve au moins un nom correspondant à celui saisi, pas la peine de continuer à comparer les autres éléments avec le nom saisi. Car, perte de temps. Si on va jusqu' au dernier élément du tableau, ça veut dire qu' on a rien trouvé. alors reponse conserve sa valeur initiale. c' est à dire "Ce nom ne se trouve pas dans notre system". D' où l' intérêt d' avoir initialisé la variable reponse avec la forme négative.
On aurait pu choisir la réponse positive comme valeur initiale. Mais dans ce cas, la façon de traiter la boucle nous aurait obliger de forcément parcourir la boucle toute entière. Ce qui aurait rendu le programme moins rapide. Un bon programme informatique n' est pas seulement celui qui règle un problème. Mais surtout celui qui apporte une solution optimale.

Voyons maintenant la ligne 11 qui nous apprend quelque chose de nouveau. Pour un débutant qui apprend Java, il aurait été logique d' écrire ceci if(tab[i] == nom ) . Le signe double égal étant la comparaison classique des variables. Mais ici, il s' agit de deux variables de type String. Ce sont des variables de type Objet. Et je vous l' ai déjà dit, une variable objet ne contient pas sa valeur. Mais plutôt la réfrérence à cette valeur. C' est à dire son adresse. C' est toujours délicat à expliquer. Vous comprendrez mieux quand on verra la programmation Objet. En attendant, utilisez la méthode equals() de la classe String pour comparer deux objets (ou variables) de type String.

La méthode equals() est déclarée : boolean equals(Object anObject) Cette méthode s' applique à un objet puisqu' il n' y a pas de mot static dans sa déclaration. ELle permet de comparer un objet String avec un autre objet. Quelqu' il soit. Si les deux variables font référence à des objets de même valeur, alors, la méthode fournit la valeur true. Dans le cas contraire, la valeur false est fournie.
Et l' instruction if() contient toujours une condition booléenne. Si elle est vraie, l' instruction entre accolades est exécutée. Voir 1.9 les structures de contrôles II

EXERCICE 13 : Présence d' un nom dans un tableau de noms.

Ecrire un programme qui demande à l' utilisateur d' entrer un caractère. Puis le programme affiche tous les noms pré-enregistrés dans le system et commençant par ce caractère. On ne tient pas compte de la casse du caractère (majuscule ou minuscule).

 CORRECTION 13 : 

1.     public class Exercice13
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] tab = {"simon", "Chris", "David", "Sarko", "Ségo", "Hardy", "Patrick", "Frank", "Samir"};
6.               System.out.print("Entrez un nom :"); char c = Lire.caractere();
7.               System.out.println("La liste des noms commençant par " + c + " est : ");
8.               for(int i = 0; i < tab.length; i++)
9.               {
10.                   if(tab[i].charAt(i) == 's' || tab[i].charAt(i) == 'S')
11.                   System.out.println(tab[i]);
12.              }
13.         }
14.    }