Classe Utilitaire

Version imprimable

Classe Utilitaire

Bonjour, je suis un jeune étudiant en 1ère année de DUT Informatique.

J'ai un devoir sur une classe Utilitaire à réaliser mais j'ai un problème dans la réalisation de celle-ci.
Je vous explique, j'ai un tableau à 2 dimension à mettre en forme suivant ce schéma :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
   +---+---+---+ 
 0 | R | C | V | 
   +---+---+---+ 
 1 | W | V | B | 
   +---+---+---+ 
 2 | X | U | Z | 
   +---+---+---+ 
 3 | V | U | E | 
   +---+---+---+ 
 4 | W | B | B | 
   +---+---+---+ 
     0   1   2

Mais lorsque, par exemple j'ai plus de valeur sur une ligne que du nombre que j'ai de ligne, suivant ce schéma :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
   +---+---+---+---+---+---+  
 0 | R | C | V | A | B | C |
   +---+---+---+---+---+---+  
 1 | W | V | B | A | B | C | 
   +---+---+---+---+---+---+  
 2 | X | U | Z | A | B | C | 
   +---+---+---+---+---+---+  
 3 | V | U | E | A | B | C | 
   +---+---+---+---+---+---+ 
 4 | W | B | B | A | B | C | 
   +---+---+---+---+---+---+ 
     0   1   2   3   4   5

J'obtiens une erreur comme celle-ci à l'exécution :

Code:

1
2
3
 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7
        at Tableau.enChaine(Tableau.java:104)
        at Test.main(Test.java:36)

Je ne sais plus du tout comment procéder. Auriez-vous une solution à me donner ?
Voici les lignes de code que j'ai réaliser, dans un premier temps la classe main (nommé Test.java) puis dans un deuxième temps ma classe Utilitaire (nommé Tableau.java)

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
 
public class Test
{
 
	public static void main(String[] arg)
	{
 
		/*-----------------*/
		/* Variables       */
		/*-----------------*/
 
		// Variables
 
		char t1[][] = {{'R', 'C', 'V', 'A', 'B', 'C', 'D'},
		               {'W', 'V', 'B', 'A', 'B', 'C', 'D'},
		               {'X', 'U', 'Z', 'A', 'B', 'C', 'D'},
		               {'V', 'U', 'E', 'A', 'B', 'C', 'D'},
		               {'W', 'B', 'B', 'A', 'B', 'C', 'D'},
		               {'R', 'C', 'V', 'A', 'B', 'C', 'D'},
		               {'R', 'C', 'V', 'A', 'B', 'C', 'D'}};
 
		/*int t2[][] = {{'1', '2', '3', '4', '5', '6'},
			        {'1', '2', '3', '4', '5', '6'},
			        {'1', '2', '3', '4', '5', '6'},
			        {'1', '2', '3', '4', '5', '6'},
			        {'1', '2', '3', '4', '5', '6'},
			        {'1', '2', '3', '4', '5', '6'},
			        {'1', '2', '3', '4', '5', '6'}};*/
 
		int cpt = 0;  
		char carac;              
 
		/*-----------------*/
		/* Instructions    */
		/*-----------------*/
 
		System.out.println ( Tableau.enChaine ( t1 ) );
		// System.out.println ( Tableau.enChaine ( t2 ) );
 
	}
}

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
public class Tableau	
{	
 
   public static String enChaine( char[] tab )	
   {	
      String sRet = "";	
      String lig  = "+";
 
      int cpt = 0;
      while(cpt < (tab.length)) {
         lig = lig + "---+";
         cpt++;
      }
      sRet = lig + "\n";
      cpt = 0;
      while(cpt < (tab.length))
      {
         sRet = sRet + "| " + tab[cpt] + " ";
         cpt++;
      }
      cpt = 0;
      String num = "";
      while (cpt < (tab.length))
      {
         num = num + " " + String.format("%3d", cpt);
         cpt++;
      }
      sRet = sRet + "|\n" + lig + "\n" + num + "\n";
      return sRet;	
   }	
 
   public static String enChaine( int[] tab, int largeur )	
   {	
      String sRet = "";
      String lig  = "+";
 
      int cpt = 0;
      while (cpt < (tab.length)) 
      {
         if ((tab.length) < 10)
         {
            lig = lig + "----+";
         }
         else
         {
            lig = lig + "--+"; 
         }
         cpt++;
      }
      sRet = lig + "\n";
      cpt = 0;
      while (cpt < (tab.length))
      {
         if ((tab.length) < 10)
         {
            sRet = sRet + "|" + String.format("%4d", tab[cpt]);
         }
         else
         {
            sRet = sRet + "|" + String.format("%2d", tab[cpt]); 
         }
         cpt++;
      }
      cpt = 0;
      String num = "";
      while (cpt < (tab.length))
      {
         if ((tab.length) < 10)
         {
            num = num + " " + String.format("%4d", cpt);
         }
         else
         {
            num = num + " " + String.format("%2d", cpt);
         }
         cpt++;
      }
      sRet = sRet + "|\n" + lig + "\n" + num + "\n";
 
      return sRet;
   }	
 
   public static String enChaine ( char[][] tab )
   {  
      String sRet = "";
      String lig  = "   +";
      int i;
      int j = 0;
      /* i : ligne ; j : colonne */
 
      int cpt = 0;
      while(cpt < (tab[j].length)) 
      {
         lig = lig + "---+";
         cpt++;
      }
      sRet = lig + "\n";
 
      i = 0;
      while (i < (tab[i].length))
      {
         sRet = sRet + i + " ";
         j = 0;
         while (j < (tab[j].length))
         {
            sRet = sRet + " | " + tab[i][j];
            j++;
         }
         sRet = sRet + " |\n" + lig + "\n";
         i++;
      }
 
      sRet = sRet + "  ";
      cpt = 0;
      while (cpt < (tab[j].length))
      {
         sRet = sRet + "   " + cpt;
         cpt++;
      }
 
      return sRet;
   }
 
   public static String enChaine ( int[][] tab, int largeur )
   {
      String sRet = "";
      String lig  = "   +";
      int i;
      int j = 0;
      /* i : ligne ; j : colonne */
 
      int cpt = 0;
      while(cpt < (tab[j].length)) 
      {
         lig = lig + "---+";
         cpt++;
      }
      sRet = lig + "\n";
 
      i = 0;
      while (i < (tab[i].length))
      {
         sRet = sRet + i + " ";
         j = 0;
         while (j < (tab[j].length))
         {
            sRet = sRet + " | " + tab[i][j];
            j++;
         }
         sRet = sRet + " |\n" + lig + "\n";
         i++;
      }
 
      sRet = sRet + "  ";
      cpt = 0;
      while (cpt < (tab[j].length))
      {
         sRet = sRet + "   " + cpt;
         cpt++;
      }
 
      return sRet;
   }
 
}

J'espère profondément que vous pourrez m'apporter une aide.

Cordialement, Daethe.

01/11/2014, 13h20
joel.drigo
Salut,

Quand tu as un tableau à 2 dimensions, tab[][], le nombre de lignes est nbLignes = tab.length, les numéros des lignes vont de 0 à nbLignes-1, et la taille de chaque ligne i (compris entre 0 et nbLignes donc), est nbColonnes=tab[i].length, donc les index vont de 0 à nbColonnes-1.

L'usage de n'importe quelle valeur d'index situé en dehors des bornes cause l'exception dont tu parles.

Dans ton code, ici :
Code:

1 2 3 4 5 6 7 while (i < (tab[i].length)) { sRet = sRet + i + " "; j = 0; while (j < (tab[j].length)) { sRet = sRet + " | " + tab[i][j];
dans tab[i][j], i est l'index de la ligne : or, tu le bornes dans le premier while par rapport à la taille de la ligne i (tab[i].length, et non pas le nombre de lignes tab.length). On pourrait dire que ça n'a pas d'importance si le tableau est carré (même nombre de lignes et de colonnes), mais si : si tu as 7 lignes, et que i vaut 6, tu fais i=i+1, puis tu testes si cette ligne i existe par i<tab[i].length, soit 7<tab[7].length, or tab[7] n'existe pas, et tu obtiens l'exception ArrayIndexOutOfBounds (index en dehors des limites).

Donc, dans cette boucle, pour corriger l'erreur il faudrait que je fasse :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 while (i < (tab[i].length - 1)) { sRet = sRet + i + " "; j = 0; while (j < (tab[j].length)) { sRet = sRet + " | " + tab[i][j]; j++; } sRet = sRet + " |\n" + lig + "\n"; i++; }
Ou bien changer la condition i<tab[i].length en i<tab.length ?
Ou alors changer i<(tab[i].length-1) par i<(tab.length-1) ?

Je suis un jeune étudiant et je suis un peu perdu dans tout ceci.

01/11/2014, 14h03
joel.drigo

Si tab[i].length cause une exception tab[i].length - 1; aussi. C'est bien i<tab.length qu'il faut mettre. tab.length c'est le nombre de lignes du tableau, et i étant l'index d'une ligne, il doit être compris entre 0 inclus et tab.length exclu.

Dans un premier temps je vous remercie de votre aide.
Mais j'ai encore un problème, la même erreur se répète mais au niveau de la deuxième boucle incluse dans celle que vous m'avez donné de l'aide.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 while (i < tab.length) { sRet = sRet + i + " "; j = 0; while (j < (tab[j].length)) { sRet = sRet + " | " + tab[i][j]; j++; } sRet = sRet + " |\n" + lig + "\n"; i++; }
Je ne sais pas si je peux faire comme pour la première, c'est à dire passer par j<tab.length. Mais comme d'après ce que vous m'avez dit la méthode length sert à compter le nombre d'éléments. Comment faire pour se déplacer ?

01/11/2014, 15h47
joel.drigo

Là ou tu as fait :

Code:

while (j < (tab[j].length))

C'est

Code:

while (j < (tab[i].length))

qu'il fallait faire. j permet de parcourir une ligne, donc tab[i], donc j doit être compris entre 0 inclus et tab[i].length exclu.
01/11/2014, 15h51
Daethe

Je vous remercie de votre précieuse aide, maintenant je comprend qu'il faut inverser lorsque l'on souhaite faire un tableau à 2 dimension. :)

Cordialement, Daethe.

Il n'y a rien à inverser (ou alors je ne comprends pas ce que tu veux dire par là) : on compare ce qui est comparable.

Pour parcourir un tableau à 2 dimensions avec des for :
Code:

1 2 3 4 5 int[][] tab = ... for(int ligne = 0; ligne<tab.length; ligne++) { for(int colonne = 0; colonne<tab[ligne].length; colonne++) { } }
Pour parcourir un tableau à 3 dimensions, ce serait :
Code:

1 2 3 4 5 6 7 8 int[][][] tab = new int[10][3][6]; for (int i = 0; i < tab.length; i++) { for (int j = 0; j < tab[i].length; j++) { for (int k = 0; k < tab[i][j].length; k++) { System.out.println(tab[i][j][k]); } } }
Un tableau à 2 dimensions, c'est juste un tableau de tableau. Donc on a applique les mêmes règles pour parcourir chaque tableau, ainsi que le tableau de tableau.

01/11/2014, 16h39
Daethe

Ce que je voulais dire par 'inverser' c'est que dans mon code, c'est la variable 'i' qui a pris la place de 'j'.
Je suis débutant en Java, vous vous avez de l'expérience. Je ne suis même pas encore au tableau à 3 dimensions.

Enfin outre ceci, désolé de mettre mal exprimé.