Le moyen le plus rapide d'écrire un tableau d'entiers dans un fichier en Java?

Comme le dit le titre, je suis à la recherche de la méthode la plus rapide pour écrire entier tableaux de fichiers. Les tableaux varient en taille, et de façon réaliste contiennent n'importe où entre 2 500 et 25 000 000 ints.

Voici le code, je suis actuellement en utilisant:

DataOutputStream writer = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename)));

for (int d : data)
  writer.writeInt(d);

Étant donné que DataOutputStream a une méthode d'écriture de tableaux d'octets, j'ai essayé de convertir le tableau int à un tableau d'octets comme ceci:

private static byte[] integersToBytes(int[] values) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    DataOutputStream dos = new DataOutputStream(baos);
    for (int i = 0; i < values.length; ++i) {
        dos.writeInt(values[i]);
    }

    return baos.toByteArray();
}

et comme ceci:

private static byte[] integersToBytes2(int[] src) {
    int srcLength = src.length;
    byte[] dst = new byte[srcLength << 2];

    for (int i = 0; i < srcLength; i++) {
        int x = src[i];
        int j = i << 2;
        dst[j++] = (byte) ((x >>> 0) & 0xff);
        dst[j++] = (byte) ((x >>> 8) & 0xff);
        dst[j++] = (byte) ((x >>> 16) & 0xff);
        dst[j++] = (byte) ((x >>> 24) & 0xff);
    }
    return dst;
}

Les deux semblent donner un mineur augmentation de la vitesse, d'environ 5%. Je n'ai pas testé rigoureusement assez pour confirmer qu'.

Sont là toutes les techniques qui accélèrent ce fichier opération d'écriture, des guides des meilleures pratiques pour Java IO performances d'écriture?

source d'informationauteur Ollie Glass

J'ai eu un coup d'oeil à trois options:

À l'aide de DataOutputStream;
À l'aide de ObjectOutputStream (pour Serializable objets, qui int[] est); et
À l'aide de FileChannel.

Les résultats sont

DataOutputStream wrote 1,000,000 ints in 3,159.716 ms
ObjectOutputStream wrote 1,000,000 ints in 295.602 ms
FileChannel wrote 1,000,000 ints in 110.094 ms

Donc le NIO version est la plus rapide. Il a également l'avantage de permettre des modifications, ce qui signifie que vous pouvez facilement changer un int alors que la ObjectOutputStream nécessiterait la lecture de l'ensemble de la matrice, de la modifier et l'écrire dans un fichier.

Code suit:

private static final int NUM_INTS = 1000000;
interface IntWriter {
void write(int[] ints);
}
public static void main(String[] args) {
int[] ints = new int[NUM_INTS];
Random r = new Random();
for (int i=0; i<NUM_INTS; i++) {
ints[i] = r.nextInt();
}
time("DataOutputStream", new IntWriter() {
public void write(int[] ints) {
storeDO(ints);
}
}, ints);
time("ObjectOutputStream", new IntWriter() {
public void write(int[] ints) {
storeOO(ints);
}
}, ints);
time("FileChannel", new IntWriter() {
public void write(int[] ints) {
storeFC(ints);
}
}, ints);
}
private static void time(String name, IntWriter writer, int[] ints) {
long start = System.nanoTime();
writer.write(ints);
long end = System.nanoTime();
double ms = (end - start) / 1000000d;
System.out.printf("%s wrote %,d ints in %,.3f ms%n", name, ints.length, ms);
}
private static void storeOO(int[] ints) {
ObjectOutputStream out = null;
try {
out = new ObjectOutputStream(new FileOutputStream("object.out"));
out.writeObject(ints);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
safeClose(out);
}
}
private static void storeDO(int[] ints) {
DataOutputStream out = null;
try {
out = new DataOutputStream(new FileOutputStream("data.out"));
for (int anInt : ints) {
out.write(anInt);
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
safeClose(out);
}
}
private static void storeFC(int[] ints) {
FileOutputStream out = null;
try {
out = new FileOutputStream("fc.out");
FileChannel file = out.getChannel();
ByteBuffer buf = file.map(FileChannel.MapMode.READ_WRITE, 0, 4 * ints.length);
for (int i : ints) {
buf.putInt(i);
}
file.close();
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
safeClose(out);
}
}
private static void safeClose(OutputStream out) {
try {
if (out != null) {
out.close();
}
} catch (IOException e) {
//do nothing
}
}

Je voudrais utiliser FileChannel de la nio paquet et ByteBuffer. Cette approche semble (sur mon ordinateur) donner 2 à 4 fois de meilleures performances en écriture:

De sortie du programme:

normal time: 2555
faster time: 765

C'est le programme:

public class Test {
public static void main(String[] args) throws IOException {
//create a test buffer
ByteBuffer buffer = createBuffer();
long start = System.currentTimeMillis();
{
//do the first test (the normal way of writing files)
normalToFile(new File("first"), buffer.asIntBuffer());
}
long middle = System.currentTimeMillis(); 
{
//use the faster nio stuff
fasterToFile(new File("second"), buffer);
}
long done = System.currentTimeMillis();
//print the result
System.out.println("normal time: " + (middle - start));
System.out.println("faster time: " + (done - middle));
}
private static void fasterToFile(File file, ByteBuffer buffer) 
throws IOException {
FileChannel fc = null;
try {
fc = new FileOutputStream(file).getChannel();
fc.write(buffer);
} finally {
if (fc != null)
fc.close();
buffer.rewind();
}
}
private static void normalToFile(File file, IntBuffer buffer) 
throws IOException {
DataOutputStream writer = null;
try {
writer = 
new DataOutputStream(new BufferedOutputStream(
new FileOutputStream(file)));
while (buffer.hasRemaining())
writer.writeInt(buffer.get());
} finally {
if (writer != null)
writer.close();
buffer.rewind();
}
}
private static ByteBuffer createBuffer() {
ByteBuffer buffer = ByteBuffer.allocate(4 * 25000000);
Random r = new Random(1);
while (buffer.hasRemaining()) 
buffer.putInt(r.nextInt());
buffer.rewind();
return buffer;
}
}

3

Je pense que vous devriez envisager l'utilisation de fichier de chaînes (la java.nio bibliothèque) au lieu de la plaine de flux (java.io). Un bon point de départ est cette discussion intéressante: Java NIO FileChannel contre FileOutputstream performance /utilité

et les commentaires ci-dessous.

Cheers!
3

La principale amélioration, vous pouvez avoir écrit int [];
- augmenter la taille de la mémoire tampon. La taille est exacte pour la plupart des flux, mais l'accès au fichier peut être plus rapide avec une grande mémoire tampon. Cela pourrait rendement de 10 à 20% d'amélioration.
- Utilisation NIO et un tampon. Cela permet d'écrire des valeurs de 32 bits sans avoir à les convertir octets. Cela peut aboutir à une amélioration de 5%.
BTW: Vous devez être capable d'écrire au moins 10 millions d'int les valeurs par seconde. Avec la mise en cache disque vous augmenter ce chiffre à 200 millions de dollars par seconde.
0

Tableau est Sérialisable - ne pouvez-vous pas simplement utiliser writer.writeObject(data);? Qui va certainement être plus rapide que l'individu writeInt appels.

Si vous avez d'autres exigences sur le format des données de sortie de récupération en int[]c'est une autre question.

Vous devez vous connecter pour publier un commentaire.