Discussion :

[Zangdaarr]

Bonjour à tous,

Je cherche à créer une méthode qui me permette d'afficher tous les élements d'un tableau à n dimensions, n étant inconnu.

Pour cela j'ai pensé à une méthode récursive de la forme suivante:

ecrireTout : prend un tableau (tab) en argument (peut être une table d'entiers, de doubles, de String... on ne sait pas)

1 - J'obtiens la dimension de tab stockée dans un entier (dim)
2 - Si dim > 1 alors
2.1 Pour chaque sous tableau (nommé sousTab) que constitue chaque ligne, de la ligne 0 à la dernière on exécute ecrireTout(sousTab)
3 - Sinon alors
3.1 Pour chaque élément de mon tableau à une dimension, de la case 0 à la dernière, j'affiche le contenu de chaque case
4 - Fin

Pour les boucles, je compte utiliser la syntaxe suivante, par exemple pour un tableau à trois dimensions de String:

For (String sousTab[][] : tab) {
ecrireTout(sousTab)
}

Sur le papier, cette méthode donne le résultat escompté (à la mise en forme et l'utilité finale près)

Problèmes:

- J'ai pris ici l'exemple d'une table de String, mais je ne sais pas à l'avance qu'il s'agit d'un String, je ne peux donc pas écrire "String", là seule chose, c'est que l'objet soit itérable
- J'ai pris ici l'exemple d'une table de 3 dimensions, mais je ne connais pas cela à l'avance non plus. D'autre part, je ne peux pas le coder en dur puisque de toutes façons, à l'itération suivante de la fonction, la table sera de dimension 2

Comme je ne connais pas bien du tout Java, je ne sais pas comment gérer cela de façon dynamique, et c'est ce que je souhaiterais faire.

C'est à dire qu'à partir d'un tableau je veux:

- être capable de déterminer le type de ce qu'il contient
- être capable de faire comprendre au compilateur qu'il faut lire: sousTab[][], ou sousTab[], ou sousTabl[][][], juste à partir de l'information de dimension: 1, 2 ou 3

Bien sur, je peux aussi utiliser un itérateur i qui va s'incrémenter, créer moi même un nouveau tableau à chaque itération, mais je doute de l'interêt en termes de temps de calcul pour des tableaux costauds (je vais être ammené à manier des tables à 7 dimensions dont certaines contiendront jusqu'à 400 lignes de base).
De plus, ça sera bien plus intéressant pour moi en terme d'apprentissage sur Java d'avoir la réponse à ces questions.

Merci !

PS:

Pour déterminer la dimension du tableau, voici la méthode que j'utilise:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public static int getNbDimension( Object table ) {
		int dim=0;
		Class<?> cls = table.getClass();
		while( cls.isArray() ) {
			cls = cls.getComponentType();
			dim++;
		} 
		return( dim );
	}

J'avoue que je n'arrive pas à bien comprendre cette méthode, j'ai l'impression que le cls parcours chaque dimension du tableau jusqu'à ne plus être un Array, même en utilisant le mode debug je n'arrive pas à comprendre ce que font les méthodes getClass, isArray, getComponentType, même si ça parait intuitif, le résultat reçu ne l'est pas.
Quelqu'un pourrait-il m'expliciter cette méthode ?

Merci à vous

[snake264]

Voila ce que fait getClass :
http://download.oracle.com/javase/1....getClass%28%29

Ce que fait isArray :
http://download.oracle.com/javase/1....#isArray%28%29

Ce que fait getComponentType:
http://download.oracle.com/javase/1....nentType%28%29

En gros tu récupère le type de la classe que ton tableau contient, ensuite tu dis que tant que l'élément trouvé est un tableau tu augmente d'une dimension en gros tu parcours tes dimensions.

Ensuite une fois que tu connais la dimension tu peux aussi connaître la taille de chaque tableau avec la méthode length, et ainsi avec ces deux infos (taille et dimension) tu a juste à faire une boucle sur la taille et un appel récursif par dimension.

Voici d'ailleurs un petit cours sur les tableaux java:
http://java.sun.com/docs/books/jls/s...rrays.doc.html

[Zangdaarr]

Merci du coup de main mais en fait je n'y arrive toujours pas,

j'ai crée les deux méthodes suivantes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
	public static void printAllCells(Object table) {
		int dim = getNbDimension(table);
		printAllCells(table,dim);
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
	private static void printAllCells(Object table, int dim) {
		Class<?> cls = table.getClass();
		Field[] cpt = cls.getFields();
 
		if (dim > 1)
		{
			for (int i =0;i<cpt.length;i++)
			{
				printAllCells(table,dim-1);
			}
		}
		else
		{
			for (int i=0;i<cpt.length;i++)
			{
				System.out.println(cpt[i]);
			}
		}
	}

Le problème est toujours le même en fait. Je peux connaitre le nombre de dimensions de mon tableau. Mais je suis incapable d'accéder à son contenu ensuite.

[tchize_]

votre code n'a ni queue ni tete. Les "fields" ne sont pas les entrées du tableau, et vous gardez toujous le même tableau pour afficher à une dimension moindre (au lieu de l'explorer)

Vous devez faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
if (table.getClass().isArray()){
  Object[] tableau = (Object[])table;
  for (Object o : tableau)
    printAllCells(o);
} else {
  // afficher l'élément.
}

[Zangdaarr]

Ok, merci, je vais essayer ça et essayer de comprendre comment ça marche.

Je commence java depuis jeudi dernier alors forcement ce n'est pas évident pour moi

[Zangdaarr]

Merci beaucoup cela marche très bien, en revanche je ne saisis pas bien ce que fais la ligne:

Object[] tableau = (Object[])table;

On crée un objet tableau de type tableau à partir de table que l'on caste dans un objet de type tableau mais comme c'était déjà le cas à la base ?

[tchize_]

on ne crée rien, on fait juste un typecasting, après avoir testé (cf le isArray) qu'il sera faisable, bien sur.