Afficher une feuille excel à partir d'une ligne spécifique

Version imprimable

Voir 40 message(s) de cette discussion en une page

Salut à tous,

Comme l'intitulé le dit : je voudrai pouvoir commencer la lecture d'une feuille Excel selon la première qui à le mot "abs".
J'ai essayer de le faire de cette façon :

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
public JTable createJTableWithExcel(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		/*
		 * System.out.println("In the sheet " + sheet.getSheetName() +
		 * " there are " + nbRows + " lines and " + nbColumns + " columns");
		 */
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];

		// Array header
		String[] title = new String[nbColumns];
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);

			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "abs"
					cell = row.getCell((short) columnContent);
					if (cell.getStringCellValue() == "abs") {
						//for hide the first column begin in the second column, so index 1
						columnContent = 1;
						//begin in row index
						rowContent = cell.getRowIndex();
						
						Object value = contentCell(cell);
						obj[rowContent][columnContent] = value;
	
						// the title
						title[columnContent] = (String) obj[0][columnContent];
					}
				}
			}
		}
		table.setModel(new DefaultTableModel(obj, title));
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);

		return table;
	}

Apparemment on ne peux pas utiliser cell.getStringCellValue() dans mon cas car il est null.

► Merci pour vos aides :) :)

Déjà, pour commencer, toujours tester l'égalité des chaînes avec equals() (== c'est pour l'identité).

Code:

if (cell.getStringCellValue() == "abs") {

Ensuite, dans une cellule, il peut y avoir des données de types différents : toujours tester le type et lire le contenu en fonction.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 switch (cell.getCellType()) { case Cell.CELL_TYPE_STRING: ... = cell.getRichStringCellValue().getString(); break; case Cell.CELL_TYPE_NUMERIC: if (DateUtil.isCellDateFormatted(cell)) { ... = cell.getDateCellValue(); } else { ... = cell.getNumericCellValue(); } break; case Cell.CELL_TYPE_BOOLEAN: ... = cell.getBooleanCellValue(); break; case Cell.CELL_TYPE_FORMULA: ... = cell.getCellFormula(); // ou voir la documentation pour évaluer la formule au besoin break; default: } }
De plus, d'après ta description, on devrait lire toutes les lignes dès qu'on trouve "abs", alors que ton code lit toutes les lignes qui contiennent le mot "abs", ce qui n'est pas du tout la même chose. Pour faire ça il faut utiliser par exemple un flag :
Code:

1 2 3 4 5 6 7 8 9 10 flag = faux pour toutes les lignes si la ligne contient le mot abs flag = vrai fin si si flag est vrai récupérer la ligne fin si fin pour
Ou alors faire 2 boucles : une première pour chercher la ligne avec "abs" (elle incrémente l'index de ligne), et une seconde qui copie toutes les lignes à partir de l'index de ligne déterminé dans la première boucle.

Enfin, attention, ton tableau ne va pas contenir uniquement les lignes que tu lis : il va contenir des valeurs null pour toutes les lignes non lues, et ce, aux mêmes positions de lignes (donc un tableau avec des trous que tu ne connaîtras pas (il faudra tester toutes les cellules d'une ligne et si elles sont toutes null, alors la ligne doit être ignorée).
Vraiment pas très pratique et source de problèmes. Soit tu utilises un compteur que tu incrémentes à chaque nouvelle ligne (le compteur étant le nombre de lignes utiles dans le tableau), soit tu utilises une liste pour cumuler les lignes, et tu la convertis éventuellement en tableau ensuite.

31/03/2016, 09h31
nadong94

Je vois l'idée mais pas simple à mettre en pratique, en fait c'est surtout savoir quel est la syntaxe pour dire : String abs = la ligne qui contient "abs";
A savoir que dans ma premier boucle, celle qui balaye les lignes contient déjà :
row = sheet.getRow(rowContent); afin de récupérer toutes les lignes.
Et dans ma seconde ligne à un moment donner j'ai également :
Object value = contentCell(cell);
la méthode contentCell() récupère le format de la cellule tel que tu me la donner au dessus.

A partir delà, comment faire ceci :
► une première pour chercher la ligne avec "abs" (elle incrémente l'index de ligne),
donc row récupère toutes les lignes et là je dois chercher "abs" mais comment ?

► et une seconde qui copie toutes les lignes à partir de l'index de ligne déterminé dans la première boucle.
donc je suppose faire un : for (Object r : row) { String copy = r }

► Soit tu utilises un compteur que tu incrémentes à chaque nouvelle ligne (le compteur étant le nombre de lignes utiles dans le tableau),
du-coup avec ce qu'il y a juste avant, ça déterminerait le conteur de lignes utiles non ?

Citation:

Envoyé par nadong94

A partir delà, comment faire ceci :
► une première pour chercher la ligne avec "abs" (elle incrémente l'index de ligne),
donc row récupère toutes les lignes et là je dois chercher "abs" mais comment ?

Bah, par exemple :

Code:

1
2
3
4
Object value = contentCell(cell);
if ( "abs".equals(value) ) {
   // la ligne contient une cellule de valeur "abs"
}

Soit dans une boucle

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
int rowIndex=0;
for( ; rowIndex< nbRows; rowIndex++) {
 
    /*...*/
 
   Object value = contentCell(cell);
   if ( "abs".equals(value) ) {
      // la ligne contient une cellule de valeur "abs"
      break;
   }
 
}
 
// créer un tableau pour stocker les lignes de dimension nbRows-rowIndex.
 
for(int i=0 ; rowIndex< nbRows; rowIndex++,i++) {
 
    // copie de la ligne d'index rowIndex dans le tableau à l'index i
 
 
}

Le programme tourne en boucle, et n'affiche pas le premier System.out.println :

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
 
public JTable createJTableWithExcel(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// Array header
		String[] header = new String[nbColumns];
		int absIndex = 0;
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
 
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "abs"
					cell = row.getCell((short) columnContent);
					//il affiche seulement 2 à l'infini
					System.out.println("c : "+ columnContent);
					Object value = contentCell(cell);
					if ( "abs".equals(value) ) {
						absIndex = cell.getRowIndex();
						//il plante avant ceci
						System.out.println("absIndex : "+ absIndex);
						break;
					}
					//for hide the first column begin in the second column, so index 1
					columnContent = 1;
					//begin in abs index
					rowContent = absIndex;
 
					obj[rowContent][columnContent] = value;
 
					// the title
					for (int i = 0; i < table.getColumnCount(); i++)
					{
						TableColumn column1 = table.getTableHeader().getColumnModel().getColumn(columnContent);
						System.out.println(i);
						column1.setHeaderValue(header[i]);
					}
				}
			}
		}
		table.setModel(new DefaultTableModel(obj, header));
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
 
		return table;
	}

Avec cette petite modification logique d'ailleurs il ne bogue plus mais il ne respecte pas la condition :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Object value = contentCell(cell); if ( "abs".equals(value) ) { absIndex = cell.getRowIndex(); System.out.println("absIndex : "+ absIndex); //for hide the first column begin in the second column, so index 1 columnContent = 1; //begin in abs index rowContent = absIndex; break; } obj[rowContent][columnContent] = value;
je fait un :
columnContent = 1; pour commencer à la deuxième colonne (chose qu'il ne fait pas)
rowContent = absIndex; pour commencer à l'index de "abs" mais ça non plus il ne le fait pas

J'ai du oublier quelque chose

Le programme tourne en boucle parce que :
Code:

1 2 3 4 for (int columnContent = 0; columnContent< nbColumns; columnContent++) { /*...*/ //for hide the first column begin in the second column, so index 1 columnContent = 1;
Et qu'il n'y a pas de "abs" dans la première colonne, et qu'il y a plus de 2 colonnes (columnContent est incrémenté en fin d'itération, donc passe à 2).

Forcément, quand on modifie l'indice de boucle de manière à ce qu'il soit toujours hors condition de sortie, on ne sort pas de la boucle.

De la même façon

Code:

rowContent = absIndex;

va

La première fois, s'il n'y a pas "abs" dans la première colonne de la première ligne, absIndex vaudra 0, donc rowContent repassera à 0, puis sera incrémenté, donc ça va boucler en gros sur la ligne 1, indéfiniment
Sinon, absIndex sera l'index de la ligne, donc en fin d'itération, sera la ligne suivante : si celle-ci ne contient pas de "abs", rowContent va repasser à absIndex (la ligne d'avant), puis on incrémentera, et donc on bouclera indéfiniment sur la ligne suivant la première ligne qui contient "abs"
Le break ci-dessous
Code:

1 2 3 4 5 6 if ( "abs".equals(value) ) { absIndex = cell.getRowIndex(); //il plante avant ceci System.out.println("absIndex : "+ absIndex); break; }
sort de la boucle for (int columnContent = 0; columnContent < nbColumns; columnContent++) { : ça ne sert à rien, à part que la ligne qui contient "abs" ne sera pas sélectionnée, ou plutôt la fin de la ligne ne le sera pas (après la colonne qui contient "abs" y compris celle-ci)
La boucle suivante est effectuée (si on break pas parce qu'on a "abs") avant d'affecter le tableau de données à la JTable, donc quand il n'y a pas encore de colonnes...
Code:

1 2 3 4 5 6 7 // the title for (int i = 0; i < table.getColumnCount(); i++) { TableColumn column1 = table.getTableHeader().getColumnModel().getColumn(columnContent); System.out.println(i); column1.setHeaderValue(header[i]); }
Cela dit comme header[i] n'est pas affecté, même si ça fonctionnait, ça mettrait null dans tous les titres.

Citation:
Envoyé par nadong94
Avec cette petite modification logique d'ailleurs il ne bogue plus mais il ne respecte pas la condition :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Object value = contentCell(cell); if ( "abs".equals(value) ) { absIndex = cell.getRowIndex(); System.out.println("absIndex : "+ absIndex); //for hide the first column begin in the second column, so index 1 columnContent = 1; //begin in abs index rowContent = absIndex; break; } obj[rowContent][columnContent] = value;
je fait un :
columnContent = 1; pour commencer à la deuxième colonne (chose qu'il ne fait pas)
rowContent = absIndex; pour commencer à l'index de "abs" mais ça non plus il ne le fait pas

J'ai du oublier quelque chose
Code:

columnContent = 1;

Ne sert à rien : le break fait sortir de la boucle sur columnContent.
Code:

1 2 //begin in abs index rowContent = absIndex;
Toujours le même problème, sauf que là ça sert à rien : rowContent c'est déjà absIndex, puisque absIndex contient cell.getRowIndex(), cell étant une cellule de la ligne row, d'index rowContent...
Puis lors du bouclage, donc juste après le break, rowContent est incrémenté...

Et ceci :

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
 
public JTable createJTableWithExcel(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		/*
		 * System.out.println("In the sheet " + sheet.getSheetName() +
		 * " there are " + nbRows + " lines and " + nbColumns + " columns");
		 */
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// Array header
		String[] header = new String[nbColumns];
		int absIndex = 0;
		int firstColumn = 0;
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
 
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "abs"
					cell = row.getCell((short) columnContent);
 
					Object value = contentCell(cell);
					if ( "abs".equals(value) ) {
						absIndex = cell.getRowIndex();
						firstColumn = 1;
						obj[absIndex][firstColumn] = value;
						absIndex++;
						System.out.println("absIndex : "+ absIndex);
					} else {
						//begin in abs index
						obj[rowContent][columnContent] = value;
					}
					// the title
					for (int i = 0; i < table.getColumnCount(); i++)
					{
						header[columnContent] = (String) obj[0][columnContent];
						TableColumn column1 = table.getTableHeader().getColumnModel().getColumn(columnContent);
						System.out.println(i);
						column1.setHeaderValue(header[i]);
					}
				}
			}
		}

Bah

Code:

1
2
3
4
5
6
7
8
9
10
11
 
if ( "abs".equals(value) ) {
						absIndex = cell.getRowIndex();
						firstColumn = 1;
						obj[absIndex][firstColumn] = value;
						absIndex++;
						System.out.println("absIndex : "+ absIndex);
					} else {
						//begin in abs index
						obj[rowContent][columnContent] = value;
					}

Peut aussi bien s'écrire

Code:

1
2
3
4
5
6
7
8
9
 
if ( "abs".equals(value) ) {
    firstColumn = 1;
    obj[rowContent][firstColumn] = value;
    absIndex=rowContent+1;
} else {
   //begin in abs index
   obj[rowContent][columnContent] = value;
}

Donc en gros :

les lignes qui ne contiennent pas "abs" sont copiées telles quelles
les lignes qui contiennent "abs" sont copiées telles quelles sauf les cellules qui contiennent "abs", et la colonne numéro 2 qui contient "abs"

ligne d'origine ligne obtenue

x x abs x abs

x abs x

Je ne comprends pas ce que tu essayes de faire avec ton "column=1". Et pourquoi tu ne suis pas ce que j'ai dit. Je te donne un programme exemple :

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
public static void main(String[] args) {
 
		final int nbRow=5;
		final int nbCol=5;
 
                // remplissage du tableau initial (correspond au sheet)
		final Object[][] obj = new Object[nbRow][nbCol];		
		for(int i=0; i<nbRow; i++) {
			for(int j=0; j<nbCol; j++) {
				obj[i][j]="x";
			}
		}
		obj[nbRow/2][nbCol/2]="abs";
		obj[3*nbCol/4][0]="abs";
		System.out.println(Arrays.deepToString(obj));
 
                // récupération des lignes voulues
		final Object[][] recup = new Object[nbRow][nbCol];
		int index=-1; // indique l'index de la prochaine ligne à récupérer sauf si vaut -1
		for(int i=0; i<nbRow; i++) {
 
			if ( index<0 ) { // on n'a encore rien trouvé, donc on cherche
				for(int j=0; j<nbCol; j++) {
					if ( "abs".equals(obj[i][j]) ) { // on a trouvé une ligne qui contient "abs"
						index=0;
						break; // pas besoin de continuer à chercher dans la ligne
					}
				}
			}
 
			if ( index>=0 ) { // on a trouvé une ligne qui contenait "abs", alors on copie
				// copie des lignes après la première qui contient "abs" y compris celle-ci
				for(int j=0; j<nbCol; j++) { // on copie la ligne entière
					recup[index][j]=obj[i][j];
				}
				index++; // on avance dans le tableau de récup
			}
 
		}
 
		if ( index>=0 ) {
			// on a trouvé des lignes : on les récupère
			Object[][] result = Arrays.copyOf(recup, index); // index correspond aux nombres de lignes trouvées
			System.out.println(Arrays.deepToString(result));
		}
		else {
			// aucune lignes trouvées
		}
 
 
 
	}

Qu'est-ce qu'il ne va pas.
1 : il m'affiche toute la feuille et non juste les ligne à partir de "abs".
2 : le titre prend toujours un index de trop, alors qu'il utilise le même index que abs.

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
 
public JTable createJTableWithExcel(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// Array header
		String[] header = new String[nbColumns];
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
 
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "abs"
					cell = row.getCell((short) columnContent);
					Object value = contentCell(cell);
					obj[rowContent][columnContent] = value;
				}
			}
		}
		obj[nbRows / 2][nbColumns / 2] = "abs";
		obj[3 * nbColumns / 4][0] = "abs";
		//System.out.println(Arrays.deepToString(obj));
 
		// récupération des lignes voulues
		final Object[][] recup = new Object[nbRows][nbColumns];
		int index = -1; // indique l'index de la prochaine ligne à récupérer sauf si vaut -1
		for (int i = 0; i < nbRows; i++) {
 
			if (index < 0) { // on n'a encore rien trouvé, donc on cherche
				for (int j = 0; j < nbColumns; j++) {
					if ("abs".equals(obj[i][j])) { // on a trouvé une ligne qui contient "abs"
						index = 0;
						break; // pas besoin de continuer à chercher dans la ligne
					}
				}
			}
 
			if (index >= 0) { // on a trouvé une ligne qui contenait "abs", alors on copie
				// copie des lignes après la première qui contient "abs" y compris celle-ci
				for (int j = 0; j < nbColumns; j++) { // on copie la ligne entière
					recup[index][j] = obj[i][j];
					header[index] = (String) obj[0][j];
				}
				index++; // on avance dans le tableau de récup
			}
 
		}
 
		if (index >= 0) {
			// on a trouvé des lignes : on les récupère
			Object[][] result = Arrays.copyOf(recup, index); // index correspond aux nombres de lignes trouvées
			//System.out.println(Arrays.deepToString(result));
		} else {
			JOptionPane.showMessageDialog(null, "The program didn't find the column « abs » in this excel file");
		}
 
		// the title
		for (int g = 0; g < table.getColumnCount(); g++) {
			for (int h = 0; h <= nbColumns; h++) {
				header[h] = (String) obj[0][h];
				TableColumn column = table.getTableHeader().getColumnModel().getColumn(h);
				System.out.println(Arrays.deepToString(obj));
				column.setHeaderValue(header[h]);
			}
		}
		table.setModel(new DefaultTableModel(obj, header));
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
 
		return table;
	}

Merci encore :)

31/03/2016, 15h38
joel.drigo

Euh, c'est sûr que coller mon exemple de principe au milieu de ton code va pas faire fonctionner ton code. C'est pour le principe (j'ai mis les commentaires suffisant pour le comprendre, mais, au besoin, tu peux me demander des précisions). Mais il faut l'adapter (= implémenter un algorithme similaire avec ton code).
31/03/2016, 16h25
nadong94

Très bien merci.

Tout d'abord, je sais que c'est des maths mais bon que signifie ceci :
obj[nbRows / 2][nbColumns / 2] = "abs";
obj[3 * nbColumns / 4][0] = "abs";
31/03/2016, 16h43
joel.drigo
C'est juste pour mettre des "abs" à 2 endroits dans le tableau. Les lignes d'avant on remplit le tableau de "x", et on met à 2 endroits "abs", pour tester l'algorithme.

Si tu testes le programme exemple, tu obtiens :
```
[[x, x, x, x, x], [x, x, x, x, x], [x, x, abs, x, x], [abs, x, x, x, x], [x, x, x, x, x]]
[[x, x, abs, x, x], [abs, x, x, x, x], [x, x, x, x, x]]
```
La première ligne le tableau complet généré, avec les 2 "abs" placés avec les lignes dont tu parles.
La seconde ligne, le tableau résultant, avec toutes les lignes qui suivent la première avec "abs" dedans, y compris celle-ci.
31/03/2016, 16h51
Carhiboux

Citation:

Envoyé par nadong94

Très bien merci.

Tout d'abord, je sais que c'est des maths mais bon que signifie ceci :
obj[nbRows / 2][nbColumns / 2] = "abs";
obj[3 * nbColumns / 4][0] = "abs";

Hello,

On peut difficilement parler de maths ici;

Est-ce que ce n'est pas plutôt le fait que tu ne maitrise pas les tableaux à deux dimension ton problème?

Dans les deux lignes d'exemple que tu donnes, l'instruction est la même, aux indices près. tu fais un :

Code:

obj[x][y] = "abs";

Sauf que x et y sont eux même des opérations mathématique avec ou sur des variables.

obj[x][y] veut dire, prends moi l'objet obj, qui est en l'occurence un tableau à deux dimension (imagine une feuille de calcul excel par exemple), et récupère la case qui est en colonne x et en ligne y. En gardant en tête que ligne et colonne commencent à 0.

Donc quand tu fais

obj[nbRows / 2][nbColumns / 2] => Trouve moi dans l'objet obj (qui est donc un tableau à deux dimensions), la case en colonne (nbRows/2) et en ligne (nbColumns/2), avec nbRows et nbColumns des variables que tu as défini et initialisé précédemment.

Je crois que c'est bon pour le contenu sauf le header;
Je l'initialise comme ça :

Code:

header[index] = (String) obj[0][j];

et sur cette ligne il me dit :

Code:

1
2
3
 
Exception in thread "AWT-EventQueue-0" java.lang.ArrayIndexOutOfBoundsException: 64
	at EVENT.UtilityMethods.createJTableWithExcel(UtilityMethods.java:220)

Voici la méthode complète :

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
 
public JTable createJTableWithExcel(Sheet sheet) 
{
	// Create new table
	JTable table = new JTable();
	// Reading the excel file
	// Count the line number
	int nbRows = sheet.getLastRowNum();
	// Count the column number
	int nbColumns = numberMaxColumn(sheet);
	// Create new object array
	Object[][] obj = new Object[nbRows][nbColumns];
 
	// Array header
	String[] header = new String[nbColumns];
	// Browsing the sheet and retrieves the lines one by one
	for (int rowContent = 0; rowContent < nbRows; rowContent++) {
		row = sheet.getRow(rowContent);
 
		// Browsing the line and retrieves the columns
		if (row != null) {
			for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
				// Retrieves the cell and this value but begging at "dbs"
				cell = row.getCell((short) columnContent);
				final Object value = contentCell(cell);
				obj[rowContent][columnContent] = value;
			}
		}
	}
 
	// récupération des lignes voulues
	final Object[][] recup = new Object[nbRows][nbColumns];
	int index = -1; // indique l'index de la prochaine ligne à récupérer sauf si vaut -1
	for (int i = 0; i < nbRows; i++) {
 
		if (index < 0) { // on n'a encore rien trouvé, donc on cherche
			for (int j = 0; j < nbColumns; j++) {
				if ("dbs".equals(obj[i][j])) { // on a trouvé une ligne qui contient "dbs"
					index = 0;
					break; // pas besoin de continuer à chercher dans la ligne
				}
			}
		}
 
		if (index >= 0) { // on a trouvé une ligne qui contenait "dbs", alors on copie
			// copie des lignes après la première qui contient "dbs" y compris celle-ci
			for (int j = 0; j < nbColumns; j++) { // on copie la ligne entière
				recup[index][j] = obj[i][j];
				header[index] = (String) obj[0][j]; //j'initialise l'entête de la table
			}
			index++; // on avance dans le tableau de récup
		}
	}
 
	Object[][] result = null;
	if (index >= 0) {
		// on a trouvé des lignes : on les récupère
		result = Arrays.copyOf(recup, index); // index correspond aux nombres de lignes trouvées
		//System.out.println(Arrays.deepToString(result));
	} else {
		JOptionPane.showMessageDialog(null, "The program didn't find the column « abs » in this excel file");
		IhmConverter.getHDMT().removeAll();
	}
 
	// the title
	for (int g = 0; g < table.getColumnCount(); g++) {
		for (int h = 0; h < nbColumns; h++) {
			header[h] = (String) obj[0][h];
			TableColumn column = table.getTableHeader().getColumnModel().getColumn(h);
			System.out.println("\n"+Arrays.deepToString(obj));
			column.setHeaderValue(header[h]);
		}
	}
	table.setModel(new DefaultTableModel(result, header));
	table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
 
	return table;
}

► Merci :) :)

Déjà, je t'ai dit que tu ne pouvais pas faire cette boucle :

Code:

for (int g = 0; g < table.getColumnCount(); g++) {

avant d'avoir affecter le modèle (et les titres de colonnes) à la JTable. Oublie cette boucle. Remplis le tableau header et passe le simplement à la JTable :

Code:

table.setModel(new DefaultTableModel(result, header));

Ensuite :
Code:

1 2 3 4 5 6 7 8 if (index >= 0) { // on a trouvé une ligne qui contenait "dbs", alors on copie // copie des lignes après la première qui contient "dbs" y compris celle-ci for (int j = 0; j < nbColumns; j++) { // on copie la ligne entière recup[index][j] = obj[i][j]; header[index] = (String) obj[0][j]; //j'initialise l'entête de la table } index++; // on avance dans le tableau de récup }
index c'est un indice de ligne, or dans header, l'indice est un indice de colonne : dans ton message, on voit que l'erreur se passe lorsque l'index vaut 64 : il y a probablement donc 64 colonnes dans ton tableau header, et donc lorsqu'on traite la ligne 64, ça plante.

Si la première ligne est censée être la ligne qui contient les titres, il suffit de copier cette ligne au bon "moment".
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 for (int i = 0; i < nbRows; i++) { if ( i==0 ) { // il s'agit de la première ligne, donc celle des headers // on récupère donc les headers for (int j = 0; j < nbColumns; j++) { header[j] = String.valueOf(obj[i][j]); // il y a moins de risque de faire String.valueOf() qu'un cast, en particulier si tu as des colonnes dont le titre est un nombre ou une date (cependant avec une date, il faudrait faire éventuellement un traitement spécial pour le format) } } else { // tant qu'a faire, on ne traite pas la ligne des headers dans la recherche de ligne avec "abs" if (index < 0) { // on n'a encore rien trouvé, donc on cherche /*...*/ } if (index >= 0) { // on a trouvé une ligne qui contenait "dbs", alors on copie /*...*/ } } }

C'est pas mal mais il rendre bonne dizaine de fois dans le else où il y est le JOptionPane.
De plus la premier ligne affiche des null partout et ensuite l'entête :

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
 
public JTable createJTableWithExcel(Sheet sheet) 
	{
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
		Object[][] result = null;
 
		// table header
		String[] header = new String[nbColumns];
 
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "dbs"
					cell = row.getCell((short) columnContent);
					final Object value = contentCell(cell);
					obj[rowContent][columnContent] = value;
				}
			}
		}
 
		// recovery of adequate lines
		final Object[][] recorvery = new Object[nbRows][nbColumns];
		int index = -1; // indicates the index of the next line to recover, except of -1
		for (int i = 0; i < nbRows; i++) {
		    if ( i==0 ) { // the first line: the headers
		    	// on récupère donc les headers 
		    	for (int j = 0; j < nbColumns; j++) {
		    		header[j] = String.valueOf(obj[i][j]);
		    	}
		    } else {
				if (index < 0) { // we found nothing, so we are searching
					for (int j = 0; j < nbColumns; j++) {
						if ("dbs".equals(obj[i][j])) { // we found a line that contains "dbs"
							index = 0;
							break; // needn't to search in this line
						}
					}
				}
 
				if (index >= 0) { // we found a line that contained "dbs", then copy
					// copy the lines after the first that contains "dbs" including this one
					for (int j = 0; j < nbColumns; j++) { // on copie la ligne entière
						recorvery[index][j] = obj[i][j];
					}
					index++; // we advance in the recovery table
				}
		    }
 
			if (index >= 0) {
				// we found lines : are recovered
				result = Arrays.copyOf(recorvery, index); // index corresponds to the number of rows found
			} else {
				JOptionPane.showMessageDialog(null, "The program didn't find the column « abs » in this excel file");
				IhmConverter.getHDMT().removeAll();
			}
		}
		table.setModel(new DefaultTableModel(result, header));
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
 
		return table;
	}

Rien dans la console côté erreur.

Citation:

Envoyé par nadong94

C'est pas mal mais il rendre bonne dizaine de fois dans le else où il y est le JOptionPane.

Bah, c'est normal, le bloc :

Code:

1
2
3
4
else {
				JOptionPane.showMessageDialog(null, "The program didn't find the column « abs » in this excel file");
				IhmConverter.getHDMT().removeAll();
			}

est dans la boucle for (int i = 0; i < nbRows; i++) {. Il est donc exécuté tant qu'on à pas trouver "abs" (ou "dbs", puisque tu as changé ça).
Sors-le de la boucle. D'ailleurs, le if/else complet doit être sorti de la boucle.

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
 
public JTable createJTableWithExcel(Sheet sheet) 
	{
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// table header
		String[] header = new String[nbColumns];
 
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "dbs"
					cell = row.getCell((short) columnContent);
					final Object value = contentCell(cell);
					obj[rowContent][columnContent] = value;
				}
			}
		}
 
		// recovery of adequate lines
		final Object[][] recorvery = new Object[nbRows][nbColumns];
		int index = -1; // indicates the index of the next line to recover, except of -1
		for (int i = 0; i < nbRows; i++) {
		    if ( i==0 ) { // the first line: the headers
		    	// on récupère donc les headers 
		    	for (int j = 0; j < nbColumns; j++) {
		    		header[j] = String.valueOf(obj[i][j]);
		    	}
		    } else {
				if (index < 0) { // we found nothing, so we are searching
					for (int j = 0; j < nbColumns; j++) {
						if ("dbs".equals(obj[i][j])) { // we found a line that contains "dbs"
							index = 0;
							break; // needn't to search in this line
						}
					}
				}
 
				if (index >= 0) { // we found a line that contained "dbs", then copy
					// copy the lines after the first that contains "dbs" including this one
					for (int j = 0; j < nbColumns; j++) { // on copie la ligne entière
						recorvery[index][j] = obj[i][j];
					}
					index++; // we advance in the recovery table
				}
 
 
 
		    }
 
		}
 
		if (index >= 0) {
		    // we found lines : are recovered
		    Object[][] result = Arrays.copyOf(recorvery, index); // index corresponds to the number of rows found
                    table.setModel(new DefaultTableModel(result, header));
 
		} else {
                    JOptionPane.showMessageDialog(null, "The program didn't find the column « abs » in this excel file");
		    IhmConverter.getHDMT().removeAll();
                    table.setModel(new DefaultTableModel(header, 0)); // une table sans ligne
	        }
		    table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
		return table;
	}

Citation:

Envoyé par nadong94

CDe plus la premier ligne affiche des null partout et ensuite l'entête :

C'est-à-dire ? La première ligne de quoi ? Affiche où ? Ensuite l'entête de quoi ?

2 pièce(s) jointe(s)

:) Merci pour le code :)

Tout d'abord, quand je test un fichier qui n'a pas "dbs" il me fait toujours plusieurs fois le même message, à la limite je préfère même qu'il me demande un autre fichier ce celui-ci ne convient pas donc je vais essayer de faire un new FileChooser().
Mais je voudrais pas qu'il me l'affiche autant de fos qu'il n'a pas trouvé d"dbs"
Code:

1 2 3 4 5 6 7 8 } else { JOptionPane .showMessageDialog(null, "The program didn't find the column « dbs » in this excel file"); IhmConverter.getHDMT().removeAll(); table.setModel(new DefaultTableModel(header, 0)); // a no-line table }
Ensuite voici le résultat pour les null header :
Pièce jointe 205572
PS : Je confirme pour le FileChooser, il s'affiche juste après le message autant de fois que celui-ci

MERCI → :) ←

Voir 40 message(s) de cette discussion en une page

Fuseau horaire GMT +2. Il est actuellement 11h12.