Le Tutoriel de Java DataOutputStream

DataOutputStream
Constructors
Methods
Examples
writeBytes(String s)
writeChars(String s)
writeUTF(String str)
writeBoolean(boolean v)
writeByte(int v)
writeShort(int v)
writeChar(int v)
writeInt(int v)
writeLong(long v)
writeFloat(float v)
writeDouble(double v)
size()

1. DataOutputStream

DataOutputStream est souvent utilisé pour écrire des données primitives dans un autre OutputStream. Une application peut donc utiliser le DataInputStream pour relire les données.

public class DataOutputStream extends FilterOutputStream implements DataOutput

DataOutputStream est recommandé pour écrire des données tabulaires, comme Excel. (Voir l'exemple au milieu de cet article).

OrderDate	Finished	Item	Units	UnitCost	Total
2020-01-06		Pencil	95	1.99	189.05
2020-01-23		Binder	50	19.99	999.50
2020-02-09		Pencil	36	4.99	179.64
2020-02-26		Pen	27	19.99	539.73
2020-03-15		Pencil	56	2.99	167.44

ByteArrayOutputStream
FileOutputStream
FilterOutputStream
ObjectOutputStream
PipedOutputStream
BufferedOutputStream
OutputStream
PrintStream
CheckedOutputStream
CipherOutputStream
DeflaterOutputStream
DigestOutputStream
InflaterOutputStream

2. Constructors

public DataOutputStream(OutputStream out)

3. Methods

public final void writeBoolean(boolean v) throws IOException  
public final void writeByte(int v) throws IOException  
public final void writeShort(int v) throws IOException
public final void writeChar(int v) throws IOException  
public final void writeInt(int v) throws IOException  
public final void writeLong(long v) throws IOException  
public final void writeFloat(float v) throws IOException  
public final void writeDouble(double v) throws IOException  

public final void writeBytes(String s) throws IOException
public final void writeChars(String s) throws IOException  
public final void writeUTF(String str) throws IOException  

public final int size()

Autres méthodes héritées des classes parentes :

public static OutputStream nullOutputStream()  

public void write(int b) throws IOException
public void write(byte b[]) throws IOException  
public void write(byte b[], int off, int len) throws IOException  

public void flush() throws IOException  
public void close() throws IOException

4. Examples

DataOutputStream est souvent utilisé pour écrire des données structurées comme Excel. Maintenant, on va écrire la table de données suivante dans un fichier :

OrderDate	Finished	Item	Units	UnitCost	Total
2020-01-06		Pencil	95	1.99	189.05
2020-01-23		Binder	50	19.99	999.50
2020-02-09		Pencil	36	4.99	179.64
2020-02-26		Pen	27	19.99	539.73
2020-03-15		Pencil	56	2.99	167.44

Tout d'abord, écrire une classe Order qui simule les données d'une seule ligne d'une table.

Order.java

package org.o7planning.dataoutputstream.ex;

import java.time.LocalDate;

public class Order {
    private LocalDate orderDate;
    private boolean finished;
    private String item;
    private int units;
    private float unitCost;
    private float total;

    public Order(LocalDate orderDate, boolean finished, //
            String item, int units, float unitCost, float total) {
        this.orderDate = orderDate;
        this.finished = finished;
        this.item = item;
        this.units = units;
        this.unitCost = unitCost;
        this.total = total;
    }
    public LocalDate getOrderDate() {
        return orderDate;
    }
    public boolean isFinished() {
        return finished;
    }
    public String getItem() {
        return item;
    }
    public int getUnits() {
        return units;
    }
    public float getUnitCost() {
        return unitCost;
    }
    public float getTotal() {
        return total;
    }
}

Ensuite, utiliser DataOutputStream pour écrire la table de données ci-dessus dans un fichier :

WriteDataFile_example1.java

package org.o7planning.dataoutputstream.ex;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.time.LocalDate;

public class WriteDataFile_example1 {

    // Windows: C:/somepath/data-file.txt
    private static final String filePath = "/Volumes/Data/test/data-file.txt";

    public static void main(String[] args) throws IOException {

        Order[] orders = new Order[] { //
                new Order(LocalDate.of(2020, 1, 6), true, "Pencil", 95, 1.99f, 189.05f),
                new Order(LocalDate.of(2020, 1, 23), false, "Binder", 50, 19.99f, 999.50f),
                new Order(LocalDate.of(2020, 2, 9), true, "Pencil", 36, 4.99f, 179.64f),
                new Order(LocalDate.of(2020, 2, 26), false, "Pen", 27, 19.99f, 539.73f),
                new Order(LocalDate.of(2020, 3, 15), true, "Pencil", 56, 2.99f, 167.44f) //
        };
        File outFile = new File(filePath);
        outFile.getParentFile().mkdirs();

        OutputStream outputStream = new FileOutputStream(outFile);
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);

        for (Order order : orders) {
            dataOutputStream.writeUTF(order.getOrderDate().toString());
            dataOutputStream.writeBoolean(order.isFinished());
            dataOutputStream.writeUTF(order.getItem());
            dataOutputStream.writeInt(order.getUnits());
            dataOutputStream.writeFloat(order.getUnitCost());
            dataOutputStream.writeFloat(order.getTotal());
        }
        dataOutputStream.close();
    }
}

Après avoir exécuté l'exemple ci-dessus, on obtient un fichier de données. Son contenu est pratiquement confus :

Enfin, on utilise DataInputStream pour lire le fichier ci-dessus.

ReadDataFile_example1.java

package org.o7planning.dataoutputstream.ex;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ReadDataFile_example1 {

    // Windows: C:/somepath/data-file.txt
    private static final String filePath = "/Volumes/Data/test/data-file.txt";

    public static void main(String[] args) throws IOException {

        File file = new File(filePath);

        InputStream inputStream = new FileInputStream(file);
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        int row = 0;
        
        System.out.printf("|%3s | %-10s | %10s | %-15s | %8s| %10s | %10s |%n", //
                "No", "Order Date", "Finished?", "Item", "Units", "Unit Cost", "Total");
        
        System.out.printf("|%3s | %-10s | %10s | %-15s | %8s| %10s | %10s |%n", //
                "--", "---------", "----------", "----------", "------", "---------", "---------");

        while (dataInputStream.available() > 0) {
            row++;
            String orderDate = dataInputStream.readUTF();
            boolean finished = dataInputStream.readBoolean();
            String item = dataInputStream.readUTF();
            int units = dataInputStream.readInt();
            float unitCost = dataInputStream.readFloat();
            float total = dataInputStream.readFloat();

            System.out.printf("|%3d | %-10s | %10b | %-15s | %8d| %,10.2f | %,10.2f |%n", //
                               row, orderDate, finished, item, units, unitCost, total);

        }
        dataInputStream.close();
    }
}

Output:

5. writeBytes(String s)

Convertir la String donnée en une séquence de caractères, puis convertir chaque caractère en byte et écrire dans ce DataOutputStream à l'aide de la méthode writeByte(byte).

public final void writeBytes(String s) throws IOException

Convoquer la méthode writeBytes(String) est l'équivalent de :

int len = s.length();
for (int i = 0 ; i < len ; i++) {
    out.write((byte)s.charAt(i));
}
incCount(len);

6. writeChars(String s)

Convertir la String donnée en une séquence de caractères, puis écrire chaque caractère à tour de rôle dans ce DataOutputStream à l'aide de la méthode writeChar(char).

public final void writeChars(String s) throws IOException

Convoquer la méthode writeChars(String) est l'équivalent de :

int len = s.length();
for (int i = 0 ; i < len ; i++) {
    int v = s.charAt(i);
    writeChar(v);
}

7. writeUTF(String str)

Écrire une String dans ce DataOutputStream avec le codage "Modified UTF-8" (UTF-8 modifié).

public final void writeUTF(String str) throws IOException

Tout d'abord, deux bytes sont écrits dans le flux de sortie comme par la méthode writeShort donnant le nombre de bytes à suivre. Cette valeur est le nombre de bytes réellement écrits, pas la longueur de la chaîne.

Par exemple, convoquer la méthode writeUTF("ÂBC") pour écrire la chaîne "ÂBC". Comme on le sait, UTF-8 utilise 1, 2, 3 ou 4 bytes pour stocker un caractère.

'Â' --> 2 bytes
'B' --> 1 byte
'C' --> 1 byte

Tout d'abord, 2 bytes sont utilisés pour stocker des informations sur le nombre de bytes nécessaires pour stocker cette chaîne. Les 4 bytes suivants sont utilisés pour écrire la chaîne "ÂBC" en codage "Modified UTF-8".

UTF-8
DataInputStream

Modified UTF-8:
https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/DataInput.html#modified-utf-8

8. writeBoolean(boolean v)

public final void writeBoolean(boolean v) throws IOException

La méthode writeBoolean(boolean) écrit une valeur bolean dans ce DataOutputStream. Si cette valeur est true, alors (byte)1 y sera écrit, sinon (byte)0 y sera écrit.

9. writeByte(int v)

public final void writeByte(int v) throws IOException

Écrire un byte dans ce DataOutputStream.

10. writeShort(int v)

public final void writeShort(int v) throws IOException

La méthode writeShort(int) écrit 2 bytes dans ce DataOutputStream.

Les deux bytes écrits sont :

(byte)(0xff & (v >> 8))
(byte)(0xff & v)

11. writeChar(int v)

public final void writeChar(int v) throws IOException

La méthode writeChar(int) écrit 2 bytes dans ce DataOutputStream.

Les deux bytes écrits sont :

(byte)(0xff & (v >> 8))
(byte)(0xff & v)

12. writeInt(int v)

public final void writeInt(int v) throws IOException

La méthode writeInt(int) écrit 4 bytes dans ce DataOutputStream.

Les quatre bytes écrits sont :

(byte)(0xff & (v >> 24))
(byte)(0xff & (v >> 16))
(byte)(0xff & (v >>  8))
(byte)(0xff & v)

13. writeLong(long v)

public final void writeLong(long v) throws IOException

La méthode writeLong(long) écrit 8 bytes dans ce DataOutputStream.

Les huit bytes écrits sont :

(byte)(0xff & (v >> 56))
(byte)(0xff & (v >> 48))
(byte)(0xff & (v >> 40))
(byte)(0xff & (v >> 32))
(byte)(0xff & (v >> 24))
(byte)(0xff & (v >> 16))
(byte)(0xff & (v >>  8))
(byte)(0xff & v)

14. writeFloat(float v)

public final void writeFloat(float v) throws IOException

La méthode writeFloat(float) écrit 4 bytes dans ce DataOutputStream.

15. writeDouble(double v)

public final void writeDouble(double v) throws IOException

La méthode writeDouble(double) écrit 8 bytes dans ce DataOutputStream.

16. size()

Renvoyer le nombre de bytes écrits dans ce DataOutputStream, ou Integer.MAX_VALUE si la valeur est réellement supérieure.

public final int size()

Par exemple :

DataOutputStream_size_ex1.java

ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);

dos.writeByte(111);
System.out.println("Number of bytes: " + dos.size()); // 1

// 1 char = 2 bytes.
dos.writeChars("ÂBC");
System.out.println("Number of bytes: " + dos.size()); // 1 + 2*3 = 7

// 1 char = 2 bytes.
dos.writeChar('A');
System.out.println("Number of bytes: " + dos.size()); // 7 + 2 = 9

// In UTF-8:
// Two bytes of length information is added before the UTF-8 String (See writeUTF methods).
// UTF-8 String: "ÂBC" =4 bytes; 'Â' = 2 bytes, 'B' = 1 byte, 'C' = 1 byte.
dos.writeUTF("ÂBC");
System.out.println("Number of bytes: " + dos.size()); // 9 + 2 + 4 = 15