Die Anleitung zu 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 wird häufig verwendet, um primitive Daten in einen anderen OutputStream zu schreiben. Eine Anwendung kann dann den DataInputStream verwenden, um die Daten zurückzulesen.

public class DataOutputStream extends FilterOutputStream implements DataOutput

DataOutputStream wird zum Schreiben tabellarischer Daten wie Excel empfohlen. (Siehe das Beispiel in der Mitte dieses Artikels).

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()

Andere Methoden, die von Elternklassen geerbt wurden

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 wird häufig verwendet, um strukturierte Daten wie Excel zu schreiben. Nun schreiben wir die folgende Datentabelle in eine Datei:

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

Schreiben Sie zunächst eine Klasse Order, die die einzeiligen Daten einer Tabelle simuliert.

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;
    }
}

Verwenden Sie als Nächstes DataOutputStream, um die obige Datentabelle in eine Datei zu schreiben:

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();
    }
}

Nachdem wir das obige Beispiel ausgeführt haben, haben wir eine Datendatei. Sein Inhalt ist ziemlich verwirrend:

Schließlich verwenden wir DataInputStream, um die obige Datei zu lesen.

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)

Wandeln Sie den angegebenen String in eine Zeichenfolge um, wandeln Sie dann jedes Zeichen in ein byte um und schreiben Sie mit der Methode writeByte(byte) in diesen DataOutputStream.

public final void writeBytes(String s) throws IOException

Der Aufruf der Methode writeBytes(String) entspricht:

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

6. writeChars(String s)

Wandeln Sie den angegebenen String in eine Zeichenfolge um und schreiben Sie dann jedes Zeichen nacheinander mit der Methode writeChar(char) in diesen DataOutputStream.

public final void writeChars(String s) throws IOException

Der Aufruf der Methode writeChars(String) ist äquivalent zu:

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

7. writeUTF(String str)

Schreiben Sie einen String in diesen DataOutputStream mit der Codierung "Modified UTF-8" (UTF-8 wurde geändert).

public final void writeUTF(String str) throws IOException

Zunächst werden zwei bytes wie von der Methode writeShort in den Ausgabestream geschrieben, die die Anzahl der folgenden bytes angeben. Dieser Wert ist die Anzahl der tatsächlich ausgeschriebenen bytes, nicht die Länge des Strings.

Rufen Sie beispielsweise die Methode writeUTF("ÂBC") auf, um die Zeichenfolge "ÂBC" zu schreiben. UTF-8 verwendet bekanntlich 1, 2, 3 oder 4 bytes, um ein Zeichen zu speichern.

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

Zuerst werden 2 bytes verwendet, um Informationen über die Anzahl der bytes zu speichern, die zum Speichern dieser Zeichenfolge erforderlich sind. Die nächsten 4 bytes werden verwendet, um den String "ÂBC" in "Modified UTF-8"-Kodierung zu schreiben.

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

Die Methode writeBoolean(boolean) schreibt einen Wert boolean in diesen DataOutputStream. Wenn dieser Wert true ist, wird in (byte)1 geschrieben, andernfalls wird in (byte)0 geschrieben.

9. writeByte(int v)

public final void writeByte(int v) throws IOException

ein byte in diesem DataOutputStream schreiben.

10. writeShort(int v)

public final void writeShort(int v) throws IOException

Die Methode writeShort(int) schreibt 2 bytes in diesem DataOutputStream .

Zwei bytes , die geschrieben werden, sind:

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

11. writeChar(int v)

public final void writeChar(int v) throws IOException

Die Methode writeChar(int) schreibt 2 bytes in diesem DataOutputStream.

Zwei geschriebenen bytes sind:

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

12. writeInt(int v)

public final void writeInt(int v) throws IOException

Die Methode writeInt(int) schriebt 4 bytes in diesem DataOutputStream.

Die vier geschriebenen bytes sind:

(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

Die Methode writeLong(long) schreibt 8 bytes in diesem DataOutputStream.

Die acht geschriebenen bytes sind:

(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

Die Methode writeFloat(float) schreibt 4 bytes in diesem DataOutputStream.

15. writeDouble(double v)

public final void writeDouble(double v) throws IOException

Die Methode writeDouble(double) schreibt 8 bytes in diesem DataOutputStream.

16. size()

Gibt die Anzahl der bytes zurück, die in diesen DataOutputStream geschrieben werden, oder Integer.MAX_VALUE, wenn der Wert tatsächlich größer ist.

public final int size()

Zum Beispiel:

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