Discussion :

[ToTo13]

Bonjour,

je souhaiterai créer une classe qui gèrerai et stockerai des fichiers tabulés.
Lorsque je vais lire mon fichier, certaines colonnes seront des int, d'autres des double, des string, ... Bref je ne sais pas à l'avance ce que j'aurai comme type dans chacune de mes colonnes.

Question : Y a t-il une bonne façon de faire ce genre de représentation et stockage ?

Si non, mon idée est la suivante :
- Lire une fois le fichier afin de déterminer le type de CHAQUE colonne (ça ne me plait pas, mais obligé... je peux très bien avoir que des int au début de ma colonne et me retrouver avec un double à la fin).
- Prendre une liste dont chaque maillon stockera une colonne.
- Allouer à chaque maillon un tableau du type correspondant à la colonne.
Cela me semble très moche, mais pour l'instant c'est tout ce qui me passe par la tête (pas bien pleine je sais )

Merci par avance...

[gifffftane]

Moi je ferais de la manière suivante.

Chaque cellule serait représentée par une classe (appelons là Cellule) qui stoquerait la cellule toujours au format String, donc aucun problème de typage lors de la lecture du fichier.

Cette classe comporterait les méthodes enString, enInteger et enDecimal (par exemple). Pour que l'utilisateur puisse déterminer le type, elle comporterait assi isString, isInteger et isDecimal.

Et voilà ! Finalement, le problème de l'usage du bon type de ta colonne est rejeté à l'utilisateur. Sympa, non ?

[ToTo13]

Bonjour,

oui effectivement cela pourrait être une solution.
Mais je me demande si cela est une si bonne chose pour les raisons suivantes :
- Stocker en String est plus volumineux et il faudrait faire une convertion de type chaque fois que ce n'est pas un string.
- L'avantage des tableaux typés est donc un gain de vitesse, mais il est vrai que la solution que j'ai proposé n'est pas très jolie.
- Une colonne doit avoir un type UNIQUE et la solution d'un type par cellule rend la chose un peu risqué (mais à débattre).

En tout cas cette solution est intéressante surtout que l'on manipulerait un tableau et non une liste puis un tableau.
Donc est ce qu'une solution hybride ne serait pas de faire un tableau comme tu l'as annoncé, mais dont chaque case serait une interface Cellule. Puis on instancie chaque cellule avec une classe CelluleInt, CelluleDouble, ... Et on ajoute à tout cela un tableau une dimension qui stocke le type d'une colonne, bien qu'un instanceof sur la première cellule permettrait de savoir quel est le type.

Cette proposition est à débattre et murir.
Toute autre proposition est toujours la bienvenue.

[gifffftane]

Cela dépend un peu de l'usage prévu.

Si l'utilisateur devra lire simplement les cellules une fois de temps en temps, alors je pense que ma solution est la meilleure.

Mais s'il doit les lire et les relire fréquemment, si le nombre de cellules est élevé, alors il faut réfléchir un peu plus.

Il existe des tas de possibilités d'optimisation. Mais, à mon avis, il faut d'abord réfléchir à ce qu'est ce tableau et ce qu'est cet (ou ces) utilisateur(s).

Tant que tu en resteras au C'est un tableau que je sais pas quelles sont ses colonnes, tu feras des choses astucieuses, tu transmettras tes astuces à tes utilisateurs, mais, de fait, tu leur demanderas de faire tout le boulot.

[ToTo13]

Bonjour,

Ca stockera plusieurs milliers de lignes dans mon fichier et il y aura de TRES TRES nombreux accés.

[gifffftane]

Alors, fais des choses astucieuses

[venegan]

Tu peux nous décrire les propriétés de ton fichier ? (Peut on le découper en élément ?) Ainsi que les actions qui seront faites par les utilisateurs sur ta liste ?

[ToTo13]

Bonjour,

en fait mon fichier tabulé va stocker des informations concernant des noyaux de cellules : taille, périmètre (int), différentes valeurs d'indices (donc des double), différents diagnostics (des int), le numéro du noyau, le numéro de l'image du noyau, ...
Chaque ligne correspondra à un noyau.

Je vais appliquer des méthodes statistiques pour l'apprentissage sur l'ensemble des noyaux => Beaucoup d'opérations sur chaque ligne.

[venegan]

Etant donné que chaque ligne représente un objet et que tous ces objets ont la même propriété :

Tu dois faire une classe "NoyauxCellule" avec des champs :
- taille
- périmètre (int),
- valeurs d'indices (un tableau si le nombre de valeur et/ou l'ordre est défini, une arrayList sinon, contenant des double
- différents diagnostics (des int) idem
etc :

Enfin tu mets tous tes objets NoyauxCellule dans une ArrayList ou un tableau...

[ToTo13]

Bonjour,

j'ai déjà pensé à ce type de solution, mais les données changent d'un fichier tabulé à un autre, donc je ne peux créer une classe qui codera en dur mes informations. Je dois à tout prix rester générique dans ma construction de mon fichier tabulé.

[gifffftane]

À mon tour

Je vois avec plaisir que nous avons tout de même gagné la notion de noyau de cellule, tout de même un peu plus métier que la notion de tabulation, si je puis me permettre.

Soit tes données sont si complexes, si nombreuses, si élaborées, qu'aucune technique ne saurait vraiment prendre en charge une telle vastitude, une telle exigence de performances.

En ce cas la solution - bien imparfaite - tient aux bases de données. Il faut que tu interprètes une première fois ton fichier plat, et remplir pendant cette phase les tables. Tu peux affecter un identificateur à chaque cellule, et de là organiser les liens entre chaque table, respectant ainsi l'extraordinaire diversité des composants.

Le moteur de base s'occupe de toute la gestion des caches, des optimisations d'accés, etc, choses que tu devras de toutes façons faire si tu ne te bases que sur ton fichier plat, et qui seront bien mieux faites par le moteur.

A partir de java 6 il y a même une base de données incluse dans le JDK, parfaitement suffisante pour qui n'a pas en plus des exigences de luxe.

Ou bien les exigences s'inscrivent dans une organisation, tant des objets que des traitements.

Par exemple au niveau des objets, on y accède petit à petit en les découvrant au fur et à mesure : il y a des cellules... combien ?... de quel type ?... pour une cellule donnée, combien de diagnostics ?... etc.

Cette approche permet de quantifier et qualifier les données, de façon adéquate au besoin. Très naturellement par cette approche, tu ne lis une donnée de ton fichier plat qu'une fois par traitement, et le système de cache s'organise simplement par les appels de procédures que l'utilisateur fait lui même.

Par exemple pour les traitements, les statistiques sont la plupart du temps basées sur une lecture séquentielle des données. Cette propriété est très importante, car elle permet d'organiser les choses en flux, et donc de ne mémoriser que ce qui est utile à la ligne en cours d'examen.

Ainsi pour le calcul d'une moyenne - mes connaissances en stats sont maigres, pardonne-moi - aussi grand soit le nombre de nombres, tu n'as besoin que d'un accumulateur et d'une séquence pour la calculer.

C'est en approfondissant ces éléments métier que tu découvriras les biais pour transformer cette généricité molle et vaste en un univers ayant quelque dimension.

[ToTo13]

Wahou... ça a l'air sympa, mais peut être un peu trop pour ce que je veux faire.
Toutefois, est ce que tu aurais de bons exemples d'utilisation ou des tutoriaux ?
En tout cas merci je vais regarder.

[gifffftane]

Là je ne connais pas vraiment de tutoriaux, sauf peut être dans les milieux UML... le distributeur d'argent est un des grands classiques, tu devrais le trouver facilement, et la technique de débroussaillage est toujours la même : écouter, écouter, écouter. Bannir toute forme de vocabulaire technique. Faire des patates. Etc.

[ToTo13]

En tout cas merci... je vais regarder cette solution.

La discussion est toujours ouverte à d'autres propositions...

[ToTo13]

Bonjour,

j'ai voulu stocker mes différentes valeurs dans un tableau deux dimensions "Object" et ensuite faire un "cast" pour récupérer les valeurs.

Code :

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

1
2
3
4
5
 
Object[][] Tableau = ...
Scanner Entree = ...
...
Object[y][x] = Integer.ValueOf(Entree.next()) ;

Malheuresement pour lire mes valeurs stockées, je ne peux faire de cast "int" ou "double" sur un Object (int toto = (int)Tableau[y][x] ; est interdit ), seulement un cast en String (int toto = Integer.ValueOf((String)Tableau[y][x]) ), ce qui n'est pas du tout sympathique au niveau rapidité.

Si quelque voit une solution pour contourner le problème...

[daedric]

j'avoue que je n'ai aps lu toutes les reponses (vu l'heure et la journee pas le courage ...) mais utiliser une base de donnees ne serait aps plus simple pour toi ?

[Lorantus]

Et mieux,

s'il y a beaucoup de données, il a meilleur temps de faire un parser dynamique et traiter les lignes par paquets (type SAX pour un tablué). Il peut ainsi avoir un énorme fichier et utiliser peu de ressources... Surtout si c'est pour un résultat statistique.

[McFoggy]

Salut,

la première question que je voudrais te poser est : est-ce que ton fichier doit être lisible dans un éditeur texte ou pas.
Tu parles d'entrée de fichier tabulé, donc je me dis que tu veux que ce soit un fichier texte.
Mais ensuite tu parles de données à stocker en binaire, d'où ma question.

Si vraiment tu n'as pas besoin que ce fichier soit lisible dans un éditeur, il suffit que tu sérializes, au sens Java du terme, chacune de tes "lignes" dans ce fichier.

[ToTo13]

Bonsoir,

le fichier provient d'un programme appelé JMP qui produit un fichier texte.
D'autres fichiers de ce type viennent aussi de mon appli et je sauvegarde au format texte.

J'ai finalement opté pour la solution suivante qui est assez facile, mais je garde tout de même l'idée de la base de donnée sous le coude :
- Je déclare une tableau d'Object et dans chaque case j'alloue une colonne au type qui me convient (int, double, String).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Object[] Tableau = new Object[nbColonnes] ;
...
for (i=0 ; i < Largeur ; i++)
		switch ( TypeColonnes[i] )
			{
			case INTEGER : Tableau[i] = new int[Hauteur] ; break ;
			case DOUBLE : Tableau[i] = new double[Hauteur] ; break ;
			case STRING : Tableau[i] = new String[Hauteur] ; break ;
			default : throw new Error("Default => Type de colonne incorrect : " + TypeColonnes[i]) ;
			}

C'est rapide et largement satisfaisant pour le moment.
Comme je manipule des colonnes, la recopie est facile et l'accé également.

[komando]

Concernant ton probleme de cast tu peux faire ça:

Code :

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

1
2
3
4
 
Integer.parseInt(str);
Double.parseDouble(str);
....