codestory

Die Anleitung zu Java DataOutputStream

View more Tutorials:

Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt. Facebook

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

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.

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

View more Tutorials:

Vielleicht bist du interessiert

Das sind die Online-Courses außer der Website o7planning, die wir empfehlen. Sie können umsonst sein oder Discount haben.