| ← (précédent) A.9 Les tableaux (1) : déclaration, affection, taille. |
| B.0 Ecriture de méthodes → |
| Accueil ↔ S O M M A I R E |
A.10 Les tableaux (2) : |
|
Nous allons progiter des exercices sur les tableaux pour reviser toutes les bases du langage Java. Sur ce chapitre, exceptionnellement, pas d'explications. C'est à vous de comprendre
chaque ligne grâce à vos connaissances acquises au cours des autres chapitres. Cela dit, si dans mes corrections, une nouvelle notion se présente, je n'hésiterais pas à expliquer. Je peux aussi rappeler une notion que je peux considérer comme un peu compliquée pour un débutant. |
|
Exercice 1 Ecrire un programme qui demande à l'utilisateur de saisir 5 valeurs. Puis le programme affiche ces valeurs. Choisissez le type de ces valeurs. |
Correction Exercice 1
1. public class ExoTablo1
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Bonjour, Vous devez saisir 5 valeurs qui seront ensuite affichées ");
6.
7. //Je choisis le type char pour les valeurs à entrer
8. char [] tabChar = new char[6];
9.
9. // utilisation de la classe Lire (voir Chapitre A3) pour saisir les valeurs du tableau
10. for(int i = 0; i < 6; i++)
11. {
12. tabChar[i] = Lire.caractere();
13. }
14.
15. System.out.println("Les valeurs que vous avez saisies sont : ");
16.
17. //affichage des valeurs du tableau
18. for(int i = 0; i < 6; i++)
19. {
20. System.out.print(tabChar[i] + " ");
21. }
22. }
23. }
|
|
Rappel : Pour utiliser la classe Lire définie en chapitre A3, vous devez l'enregistrer dans le même repertoire que la classe dans laquelle vous l'utilisez. Ici, c'est class ExoTablo1 |
|
Exercice 2 : Ecrire un programme qui affiche les valeurs d'un tableau unidimensionnel. Ces valeurs sont des nombres entiers qui apparaissent au hasard. Ces nombres sont compris entre -5 et +20 (inclus). La taille du tableau se fait au choix. |
Correction Exercice 2
1. public class ExoTablo2
2. {
3. public static void main (String [] args)
4. {
5. //Choix du nombre entier représentant la taille du tableau
6. System.out.println("Entrez un nombre entier, taille du tableau : ");
7. int t = Lire.entierInt();
8.
9. //Création du tableau de taille t
10. int [] tab = new int[t];
11.
12. // affectation de valeurs entières, pris au hasard entre -5 et +20, au tableau
13. for(int i = 0; i < t; i++)
14. {
15. tab[i] = (int) ( (Math.random() * 26) - 5 );
16. }
17.
18. //affichage des valeurs du tableau
19. for(int i = 0; i < t; i++)
20. {
21. System.out.print(tab[i] + " ");
22. }
23. }
24. }
|
|
Rappel : Pour ceux qui n'ont pas encore bien capté les subtilités de la méthode random() de la classe Math. Math.random() fournit une valeur comprise entre 0 (inclus) et 1 (exclu). Donc, l'intervalle [0, 1[ Mutiplié par 26, l'intervalle devient [0, 26[ En le soustrayant de 5, l'intervalle devient [-5, +21[ En le convertissant en int, on obtient une valeur comprise entre -5 (inclus) et +21 (exclu). Donc, le 20 est inclus. Dans l'énoncé, on a ceci : Ces nombres sont compris entre -5 et +20 (inclus) Quand on met entre parenthèses seul le mot inclus, cela veut dire que les 2 bornes sont incluses. Ici, -5 et +20 Si on s'adresse seulement à une seule borne, on le précise. |
|
Exercice 3 : Ecrire un programme qui demande à l'utilisateur de saisir les notes sur 20 des élèves d'une classe. Le nombre d'élèves est choisi au début du programme. Puis le programme affiche la somme, la plus grande valeur, la plus petite, et enfin, la moyenne. |
Correction Exercice 3
1. public class ExoTablo3
2. {
3. public static void main (String [] args)
4. {
5. //déclaration et initialisation des variables
6. double som = 0; double pgNote = 0; double ppNote = 0; double moy = 0;
7.
8. //Choix du nombre entier représentant le nombre d'élèves
9. System.out.println("Entrez un nombre entier, taille du tableau : ");
10. int nombre = Lire.entierInt();
11.
12. //création du tableau dont la taille est le nombre d'élèves
13. double [] tab = new double[nombre];
14.
15. /* Saisir les notes (max = 20) des élèves. En même temps, on calcule
16. la somme, la moyenne, la plus grande note */
17. System.out.println("Saisissez les notes sur 20 des élèves ");
18. for( int i = 0; i < nombre; i++)
19. {
20. System.out.println("La note numéro " + (i+1) + " est : ");
21. tab[i] = Lire.reelDouble();
22.
22. som = som + tab[i];
23. moy = som/nombre;
24. pgNote = Math.max(pgNote, tab[i]);
25. ppNote = Math.min(ppNote, tab[i]);
26. }
27. //évaluation de la plus petite note
28. ppNote = tab[0];
29. for(int i = 0; i < nombre; i++)
30. {
31. ppNote = Math.min(ppNote, tab[i]);
32. }
33. //Affichage somme, moyenne, plus grande note et plus petite.
34. System.out.println("Somme des notes = " + som);
35. System.out.println("Moyenne des notes = " + moy);
36. System.out.println("Plus grande des notes = " + pgNote);
37. System.out.println("Plus petite des notes = " + ppNote);
38. }
39. }
|
|
exercice 4 Ecrire un programme qui permet de tester la présence d'une valeur dans un tableau prédéfini. Le type des valeurs se fait au choix. |
Correction Exercice 4
1. public class ExoTablo4
2. {
3. public static void main (String [] args)
4. {
5. String [] tab = new String[5];
6. tab[0] = "paprika"; tab[1] = "curry"; tab [2] = "cumin";
7. tab[3] = "Gigembre"; tab[4] = "canelle";
8. String reponse = new String("");
9. //Saisie du nom d'une épice
10. System.out.println("Entrez le nom d'une épice : " );
11. String epice = Lire.chaine();
12. for(int i = 0; i < 5; i++)
13. {
14. if(tab[i] == epice)
15. {
16. reponse = "L epice appartient à la liste";
17. }
18. break;
19. }
20. System.out.println(reponse);
21. }
22. }
|
|
compilez puis exécuter ce programme, quelque soit le nom d'épice saisi au clavier, la réponse sera toujours : L epice n existe pas Pourquoi ? Parce que le type de la valeur est un objet. La comparaison des objets (au sens de la poo) est plus complexe. Parce que dans la variable, ce n'est pas la valeur de la variable. Mais plutôt une adresse mémoire. Nous reprendrons cet exercice au chapitre consacré aux exercices corrigés de POO. Reprenons l'exercice ci-dessus avec une variable de type de base : byte, short, int, long, char ou boolean. |
Correction Exercice 4bis
1. public class ExoTablo4bis
2. {
3. public static void main (String [] args)
4. {
5. int [] tab = new int[5];
6. tab[0] = 22; tab[1] = -5; tab [2] = 111;
7. tab[3] = 30; tab[4] = 8;
8. String reponse = new String("Le nombre n existe pas");
9. //Saisie du nom d'une valeur entière de type int
10. System.out.println("Entrez un nombre entier de type int : " );
11. int nombre = Lire.entierInt();
12. for(int i = 0; i < 5; i++)
13. {
14. if(tab[i] == nombre)
15. {
16. reponse = "Le nombre appartient à la liste";
17. break;
18. }
22. }
23. System.out.println(reponse);
23. }
24. }
|
|
Quelque chose de nouveau : break Le mot-clé break a une signification précise en Java. Il permet d'arrêter une boucle (for ou while) lorsque une condition suffisante est vérifiée. Dans l'exemple ci-dessus, on parcours tous les éléments du tableau tab (ligne 12). Puis on dit (ligne 14) que si l'une des valeur du tableau est égale au nombre saisi, alors (ligne 16) le nombre appartient bien au tableau (la liste des nombres du tableau). Si on ne met pas l'intruction break, le parcours de la boucle continuerait jusqu'au dernier. Si bien que la valeur de la variable reponse au sorti de la boucle correspondrait au test de la dernière valeur du tableau tab. Si la dernière valeur du tableau (ici, c'est 8) ne correspond pas à la valeur saisie, reponse sera toujours égale à "Le nombre n existe pas" Vérifiez : Enlevez le mot break dans ce programme. Puis compilez à nouveau. Puis exécutez 4 fois le programme. Les valeurs saisies à chaque exécution seront respectivement : 22, -5, 111 et 30. Vous verrez que la réponse sera toujours "Le nombre n existe pas" Par contre, si vous exécutez une fois de plus en saisissant le nombre 8, alors reponse = "Le nombre appartient à la liste" |
|
exercice 6 Ecrire un programme qui demande à l'utilisateur de saisir une valeur entière. Puis le programme affiche le quotient de la division de ce nombre par les valeurs d'un tableau prédéfini. par exemple, un tableau a 3 valeurs : 2, 5 et 3. Le nombre entré est 30. Les valeurs affichées seront donc : 15, 6 et 10. 30 divisé par 2 = 15. 30 divisé par 5 = 6. 30 divisé par 3 = 10. |
Coorection exercice 6
1. public class ExoTablo6
2. {
3. public static void main (String [] args)
4. {
5. int [] tab = {3, 0, 6, 5 };
6.
7. // saisir une valeur entière
8. System.out.println(".......................");
9. int n = Lire.entierInt();
10. for(int i = 0; i < tab.length; i++)
11. {
12. if(tab[i] == 0)
13. {
14. continue;
15. }
16. else
17. {
18. System.out.println(n/tab[i]);
19. }
20. }
21. }
21. }
|
|
Quelque chose de nouveau : continue L'instruction continue permet d'ignorer l' une des itérations d'une boucle. (une itération est une répétition). Vous savez que dans une boucle, il s'agit de répéter une action un certain nombre de fois avec des valeur définies dans les parenthèses de while ou de for. continue, pour une valeur donnée, permet à la répétition de zaper la valeur donnée. Plus concrètement ici, on demande à la boucle d'afficher le quotion du nombre saisi au clavier par chacun des nombres du tableau prédéfini. Mais nous savons tous que la division par Zéro est impossible. C'est pourquoi on écrit (ligne 12) que si l'une des valeurs du tableau est égale à 0, alors, le programme doit continuer (continue;) comme si de rien n'était. Sans tenir compte de cette valeur. Et c'est pourquoi vous aurez toujours affichées, 3 valeurs au lieu de 4 à l'exécution du programme. |
|
exercice 7 Un casier possède 3 compartiments. Chaque compartiment possède 2 compartiments qui sont vides. Illustrez cette situation dans un programme qui affiche les valeurs. indications d'affichage : premier compartiment = c1 - 2ème = c2 - 3ème = c3 premier sous-compartiment de chaque compartiment = sc1. 2ème = sc2 |
Coorection exercice 7
1. public class ExoTablo7
2. {
3. public static void main (String [] args)
4. {
5. int [][] tab = new int[3][2];
6. for (int i = 0; i < 3; i++)
7. {
8. for(int j = 0; j < 2; j++)
9. {
10. System.out.println("valeur sc" + (j+1) + " du compartiment c" + (i+1) + " = " + tab[i][j]);
11. }
12. }
13. }
14. }
|
|
compilez puis exécutez ce programme, il sera affiché : valeur sc1 du compartiment c1 = 0 valeur sc2 du compartiment c1 = 0 valeur sc1 du compartiment c2 = 0 valeur sc2 du compartiment c2 = 0 valeur sc1 du compartiment c3 = 0 valeur sc2 du compartiment c3 = 0 Explications : Ici, la casier est tab Ligne 5 : création d'un tableau bidimensionnel (int [][] tab) de 3 tableau dont chacun possède 2 éléments ( = new int[3][2];) De la ligne 6 à la ligne 10, on voit 2 boucles for imbriquées. Une boucle for à l'intérieur d'une autre. Pour les super débutants, sachez que ça n'a rien d'étonnant On pourrait, dans un programme, trouver plus de boucles imbriquées. Et pas seulement la boucle for. Revenons au programme : ligne 6 : Pour chaque élément du tableau tab (ils sont 3 et sont des tableaux : tab[0], tab[1] et tab[2] ), on parcours (ligne 8) ses éléments (qui sont au nombre de 2 et sont des variables de type int), on affiche (ligne 10) la valeur de ces variables. Pour ceux à qui l'explications peut paraître encore compliquée, essayons autre chose : Lorsque i = 0, on est sur le tableau tab[0]. Puid le programme entre dans la 2ème boucle pour parcourir les éléments de tab[0] qui sont tab[0][0] (j = 0) et tab[0][1] (j = 1). Et on sait que le fait d'écire la ligne 5 fait que toutes les valeurs sont nulles. Pour le type int, nul = 0. Même raisonnement pour i = 1 et i = 2. Pour la ligne 10, avec un peu d'effort, on comprend aisément le (j + 1) et le (i + 1). |
|
exercice 8 On reprend l'exercice 7. Mais cette fois, le nombre de sous-compartiments de chaque compartiments change. Chaque compartiment possède un nombre de sous-compartiments égal au numéro de saposition, ajouté au nombre 1. exemple : Le compartiment tab[0] aura 0 + 1 sous-compartiment. Ainsi de suite. |
Coorection exercice 8
1. public class ExoTablo8
2. {
3. public static void main (String [] args)
4. {
5. int [][] tab = new int[3][0];
6.
7. //attribution de sous-compartiments à chaque compartiment.
8. for(int i = 0; i < 3; i++)
9. {
10. tab[i] = new int[i +1];
11. }
12.
13. //affichage des valeurs de chaque sous-compartiment.
14. for(int i = 0; i < 3; i++)
15. {
16. for(int j = 0; j < tab[i].length; j++)
17. {
18. System.out.println("valeur sc" + (j+1) + " du compartiment c" + (i+1) + " = " + tab[i][j]);
19. }
20. }
21. }
22. }
|
|
compilez puis exécutez ce programme, il sera affiché : valeur sc1 du compartiment c1 = 0 valeur sc1 du compartiment c2 = 0 valeur sc2 du compartiment c2 = 0 valeur sc1 du compartiment c3 = 0 valeur sc2 du compartiment c3 = 0 valeur sc3 du compartiment c3 = 0 Vous voyez bien à l'affichage que : le premier compartiment a un seul sous-compratiment (0+ 1) le deuxième compartiment a 2 sous-compratiments (1+ 1) le troisième compartiment a 3 sous-compratiments (2+ 1) Explications : faites un effort de compréhension. C'est pas bien dificile. |
|
exercice 9 On reprend l'exercice 8. Cette fois, les sous-compartiments ne sont pas forcément vides. Dans cahque sous-compartiment, on y met un nombre entier correspondant à la somme des numéros représentant la position du copartiment et la position du sous-compartiment correspondants. Exemple : le nombre qui se trouve dans le premier sous-compartiment du premier compartiment est = 0. Parce que le premier compartiment est en position 0 et son premier sous-compartiment est aussi en position 0. Vous devez avoir les 6 valeurs suivantes qui ne sont plus tous égaux à zéro : 0-1-2-2-3-4 correspondants respectivement aux sommes des positions :( (0+0)-(0+1)-(1+1)-(2+0)-(2+1)-(2+2) ) Si vous décidiez de ne pas regarder la correction et essayer d'écrire le programme. Sachez qu'il suffit d'ajouter une seule ligne de code à la correction de l'exercice 8. |
Coorection exercice 9
1. public class ExoTablo9
2. {
3. public static void main (String [] args)
4. {
5. int [][] tab = new int[3][0];
6.
7. //attribution de sous-compartiments à chaque compartiment.
8. for(int i = 0; i < 3; i++)
9. {
10. tab[i] = new int[i +1];
11. }
12.
13. //affichage des valeurs de chaque sous-compartiment.
14. for(int i = 0; i < 3; i++)
15. {
16. tab[i][j] = i + j;
17. for(int j = 0; j < tab[i].length; j++)
18. {
19. System.out.println("valeur sc" + (j+1) + " du compartiment c" + (i+1) + " = " + tab[i][j]);
20. }
21. }
22. }
23. }
|
| ← (précédent) A.9 Les tableaux (1) : déclaration, affection, taille. |
| B.0 Ecriture de méthodes → |
| Accueil ↔ S O M M A I R E |
A.10 Les tableaux (2) : exercices corrigés tableaux uni et bi dimensionnels |