La création et la lecture à partir d'un type de fichier personnalisé en Java

Il ya beaucoup de questions que vous devez répondre pour vous-même sur les exigences de ce type de fichier. Est-il besoin d'être comprimé? Chiffré? Il a besoin de l'appui d'accès aléatoire lecture, ou est-ce stream-lecture assez bon?

J'ai peut-être tort, mais je ne pense pas que c'est ce que vous demandez dans cette question. Si je suis en train de lire correctement, je pense que vous vous posez la question "comment puis-je lire & écriture de fichiers arbitraires de données?"

Donc, c'est la question que je vais répondre. Mise à jour de votre question, si ce n'est pas tout à fait ce que vous cherchez.

Personnalisés types de fichiers peuvent facilement être mises en œuvre à l'aide de la DataInputStream et DataOutputStream classes. Il vous permettra de lire & écrire primitives (boolean, char, byte, int, long, float, double) pour le flux. Il y a aussi quelques méthodes pratiques pour la lecture & écrit codé en UTF-8 Cordes, byte-tableaux, et quelques autres goodies.

Nous allons commencer.

Pour les besoins de la discussion, supposons que toutes mes données sont des éléments de tableaux d'octets. Et chacun d'eux a un nom. Donc, mon type de fichier peut être modélisé logiquement comme un Map<String, byte[]>. J'aimerais mettre en œuvre mon type de fichier personnalisé lecteur/enregistreur de classe comme ceci:

public class MyFileTypeCodec {
public static void writeToFile(File f, Map<String, byte[]> map)
throws IOException {
//Create an output stream
DataOutputStream stream = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(f))
);
//Delegate writing to the stream to a separate method
writeToStream(stream, map);
//Always be sure to flush & close the stream.
stream.flush();
stream.close();
}
public static Map<String, byte[]> readFromFile(File f)
throws IOException {
//Create an input stream
DataInputStream stream = new DataInputStream(
new BufferedInputStream(new FileInputStream(f))
);
//Delegate reading from the stream to a separate method
Map<String, byte[]> map = readFromStream(stream);
//Always be sure to close the stream.
stream.close();
return map;
}
public static void writeToStream(DataOutputStream stream, Map<String, byte[]> map)
throws IOException {
//First, write the number of entries in the map.
stream.writeInt(map.size());
//Next, iterate through all the entries in the map
for (Map.Entry<String, byte[]> entry : map.entrySet()) {
//Write the name of this piece of data.
stream.writeUTF(entry.getKey());
//Write the data represented by this name, making sure to
//prefix the data with an integer representing its length.
byte[] data = entry.getValue();
stream.writeInt(data.length);
stream.write(data);
}
}
public static Map<String, byte[]> readFromStream(DataInputStream stream)
throws IOException {
//Create the data structure to contain the data from my custom file
Map<String, byte[]> map = new HashMap<String, byte[]>();
//Read the number of entries in this file
int entryCount = stream.readInt();
//Iterate through all the entries in the file, and add them to the map
for (int i = 0; i < entryCount; i++) {
//Read the name of this entry
String name = stream.readUTF();
//Read the data associated with this name, remembering that the
//data has an integer prefix representing the array length.
int dataLength = stream.readInt();
byte[] data = new byte[dataLength];
stream.read(data, 0, dataLength);
//Add this entry to the map
map.put(name, data);
}
return map;
}
}

L'idée de base est que vous pouvez écrire toutes les données d'un flux de sortie (et de le lire en arrière de nouveau) si vous pouvez vous le représenter ces données comme une combinaison de primitives. Les tableaux (ou d'autres collections) peut être préfixé avec leur longueur, comme je l'ai fait ici. Ou vous pouvez éviter d'écrire le préfixe de longueur si vous mettez un TERMINUS sentinelle à la fin (un peu comme null chaînes de caractères).

Je toujours utilisation de ce type d'installation lorsque j'mettre en œuvre un type de fichier personnalisé codec, avec e /s de fichiers des méthodes de déléguer vers le bas dans les cours d'eau IO méthodes. Habituellement, je l'ai découvert plus tard que l'objet que je suis en train de lire & l'écriture de ce flux pourrait être tout aussi facilement écrite dans certaines grandes & plus complexes fichier.

Donc je pourrais avoir un SuperFancyCodec pour la lecture/écriture des données pour l'ensemble de mon système, et qu'il appelle dans mon TinySpecialPurposeCodec. Tant que le flux de la lecture & méthodes d'écriture sont publiques, alors je peux assembler de nouveaux types de fichiers à l'aide d'un composant de méthode axée sur la.