malloc et free pour une liste de 504 bytes
Salut à tous,
Je suis en train de faire un programme qui doit décoder un fichier assemblé en plusieurs blocs. L'un de ces blocs est un bloc pur de données. Dans un autre bloc, j'ai des sous-parties qui définissent le type et l'organisation des données qui pointent vers des blocs de données. Le problème c'est que ces blocs ne sont pas du tout organisés : un bloc de données peut apparaître avant le bloc de type et inversement. Des données peuvent également être sur plusieurs blocs de données simultanément et peuvent aussi commencé à être située en plein milieu du bloc.
Mon problème est alors assez simple : Je peux lire mes 504 bytes en lisant mon fichier. Après avoir lu complètement mon fichier, je voudrais faire du post-traitement qui consiste pour chaque type à aller chercher les données lues et les ré-encoder comme il faut. Il me faut donc un moyen de stocker 504 bytes et de les libérer ensuite quand j'aurais fini mon post-traitement. Aujourd'hui, je travaille sur des fichiers de quelques ko pour les tests mais au final, les fichiers pourront être de quelques Mo et là ça sera plus la même histoire par rapport à la taille de la RAM utilisée.
J'ai imaginé plusieurs solutions :
1) Une ArrayList de bytes. C'est ce qu'il me semble le plus efficace mais une liste sous-entend souvent des pointeurs pour le précédent et le suivant donc pour des fichiers de quelques Mo, c'est peut-être pas idéal
2) Un tableau de 504 bytes : Pour moi, je ne vois pas comment réduire après avoir post-traiter les données le tableau à 0
3) Un String de 504 bytes : J'ai cru lire dans un post dans le forum que le système à chaque nouvelle opération de non-lecture sur un String qu'il en créé un nouveau. Donc si je crée un String de 504 bytes et que je le transformer en String de 1 byte, y'aura-t-il toujours 504 bytes utilisés quelque part où je ne pourrais pas accéder ?
4) Un système de malloc, free comme en C mais je n'ai rien vu qui pourrait se rapprocher à ça en java.
Bon, pour que ça soit un peu plus parlant, voici quelques éléments de code. Voici un bloc de données pur (ce sont des coordonnées, Ushort : unsigned short, Uint : unsigned int, Ubyte : unsigned byte), je suppose ici utiliser la méthode 2 citée ci-dessus (celle du tableau) :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class CoordBlock {
private Ushort BlockCode;
private Ushort ByteCount;
private Uint Link; // offset du prochain CoordBlock
private Ubyte Datas[] = new Ubyte[504];
private int Parent;
private long Position; // offset du CoorBock dans le fichier
public CoordBlock(Ushort arg1, Ushort arg2, Uint arg3, Ubyte arg4, int arg5, long arg6) {
BlockCode = arg1;
ByteCount = arg2;
Link = arg3;
Datas = arg4;
Parent = arg5;
Position = arg6;
} |
Voilà une sous-partie, un exemple de type à gérer. Je compte ajouter encore ici des éléments permettant de stocker les données calculées dans le post-traitement :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class SRBlock {
private Ubyte ObjectCode; // code d'identification du SRBlock
private Uint AttributeIndex; // numéro du SRBlock
private Uint SectionPointer; // offset des CoordBlock dans le fichier
private Uint ByteCountCoordData; // nombre de données à lire
public SRBlock(Ubyte arg1, Uint arg2, Uint arg3, Uint arg4) {
ObjectCode = arg1;
AttributeIndex = arg2;
SectionPointer = arg3;
ByteCountCoordData = arg4;
} |
Je rajoute au final une chose qui me semble évidente mais bon, il y a bien sûr de nombreux CoordBlock, c'est d'ailleurs eux qui forment la plus grosse partie du fichier, j'ai donc un peu plus en amont du programme une ArrayList de CoordBlock (si ça peut influer dans le choix).
Voilà, j'espère que j'ai été assez clair :?
En gros, mon problème pourrait se résumerer à savoir faire du malloc et free en Java.
Merci d'avance aux courageux qui ont lu ce post jusqu'au bout et merci d'avance et ce qui y répondront :D
