DataOutputStream数据输出流 将java基本数据类型写入数据输出流中,并可以通过数据输入流DataInputStream将数据读入。
分类 | 字节输入流 | 字节流输出流 |
特殊流 | DataInoutStream | DataInputStream |
应用场景:可以直接输出float类型和long类型等,通过使用该流可以提高数据读写的效率
DataInputStream源码浅析
继承关系:
public class ObjectInputStream
extends InputStream implements ObjectInput, ObjectStreamConstants{}
//继承自InputStream类,实现了ObjectInput, ObjectStreamConstants接口
基本属性:
// 字节数组
private byte bytearr[] = new byte[80];
// 字符数组
private char chararr[] = new char[80];
构造函数和基本方法:
// 有参数构造方法,传入底层的输入流
public DataInputStream(InputStream in) {
super(in);
}
// 将数据从数据输入流中读取到字节数组b中
public final int read(byte b[]) throws IOException {
return in.read(b, 0, b.length);
}
// 将数据从数据输入流中读取到字节数组b中,
//b的起始位置是off,长度是len
public final int read(byte b[], int off, int len) throws IOException {
return in.read(b, off, len);
}
// 从数据输入流中读取数据,填充字节数组b.
public final void readFully(byte b[]) throws IOException {
readFully(b, 0, b.length);
}
// 将数据从数据输入流读取到字节数组b中,起始位置是off,长度len.
// 此方法会循环从输入流读取len个字节.
public final void readFully(byte b[], int off, int len) throws IOException {
if (len < 0)
throw new IndexOutOfBoundsException();
int n = 0;
while (n < len) {
int count = in.read(b, off + n, len - n);
if (count < 0)
throw new EOFException();
n += count;
}
}
// 跳过n个字节
public final int skipBytes(int n) throws IOException {
int total = 0;
int cur = 0;
while ((total < n) && ((cur = (int) in.skip(n - total)) > 0)) {
total += cur;
}
return total;
}
// 从数据输入流中读取布尔类型.
public final boolean readBoolean() throws IOException {
int ch = in.read();
if (ch < 0)
throw new EOFException();
return (ch != 0);
}
// 从数据输入流中读取一个字节
public final byte readByte() throws IOException {
int ch = in.read();
if (ch < 0)
throw new EOFException();
return (byte) (ch);
}
// 从数据输入流中读取一个无符号的字节
public final int readUnsignedByte() throws IOException {
int ch = in.read();
if (ch < 0)
throw new EOFException();
return ch;
}
// 从数据输入流中读取一short类型数据
public final short readShort() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (short) ((ch1 << 8) + (ch2 << 0));
}
// 从数据输入里中读取一个无符号short类型数据
public final int readUnsignedShort() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (ch1 << 8) + (ch2 << 0);
}
// 从数据输入流中读取一个字符数据
public final char readChar() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (char) ((ch1 << 8) + (ch2 << 0));
}
// 从数据输入流中读取一个int类型数据
public final int readInt() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}
private byte readBuffer[] = new byte[8];
// 从数据输入流中读取一个long类型的数据
public final long readLong() throws IOException {
readFully(readBuffer, 0, 8);
return (((long) readBuffer[0] << 56) + ((long) (readBuffer[1] & 255) << 48) + ((long) (readBuffer[2] & 255) << 40)
+ ((long) (readBuffer[3] & 255) << 32) + ((long) (readBuffer[4] & 255) << 24) + ((readBuffer[5] & 255) << 16)
+ ((readBuffer[6] & 255) << 8) + ((readBuffer[7] & 255) << 0));
}
// 从数据输入流中读取一个float类型的数据
public final float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
}
// 从数据输入流中读取一个double类型的数据
public final double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
}
private char lineBuffer[];
DataOutputStream源码浅析:
继承关系
public
class DataOutputStream extends FilterOutputStream implements DataOutput {}
//继承自FilterOutputStream类,实现了DataOutput接口
基本属性
// 写到数据输出流中字节数
protected int written;
// 数据输出流中的字节数组
private byte[] bytearr = null;
构造函数和基本方法
// 构造方法.参数传入的是基础输出流
public DataOutputStream(OutputStream out) {
super(out);
}
// 数据输出流的字节数增加,value是增加的字节数
private void incCount(int value) {
int temp = written + value;
if (temp < 0) {
temp = Integer.MAX_VALUE;
}
written = temp;
}
// 将int类型数据b写到数据输出流中
public synchronized void write(int b) throws IOException {
out.write(b);
incCount(1);
}
// 将字节数组b,off索引位置开始,len个长度写到数据输出流中
public synchronized void write(byte b[], int off, int len) throws IOException {
out.write(b, off, len);
incCount(len);
}
// 刷新数据输出流
public void flush() throws IOException {
out.flush();
}
// 将boolean类型的数据写到数据输出流中
public final void writeBoolean(boolean v) throws IOException {
out.write(v ? 1 : 0);
incCount(1);
}
// 将字节数据写到数据输出流中
public final void writeByte(int v) throws IOException {
out.write(v);
incCount(1);
}
// 将short类型数据写到数据输出流中
// short占两个字节,将高8位和低8位分别存储
public final void writeShort(int v) throws IOException {
out.write((v >>> 8) & 0xFF);
out.write((v >>> 0) & 0xFF);
incCount(2);
}
// 将字符类型的数据写到数据输出流中
// char占两个字节,将高8位和低8位分别存储
public final void writeChar(int v) throws IOException {
out.write((v >>> 8) & 0xFF);
out.write((v >>> 0) & 0xFF);
incCount(2);
}
// 将int类型的数据写到数据输出流中
// int占4个字节.所以将4个字节分别存储
public final void writeInt(int v) throws IOException {
out.write((v >>> 24) & 0xFF);
out.write((v >>> 16) & 0xFF);
out.write((v >>> 8) & 0xFF);
out.write((v >>> 0) & 0xFF);
incCount(4);
}
private byte writeBuffer[] = new byte[8];
// 将long类型数据写到数据输出流
// long是8个字节,将8个字节分别存储.
public final void writeLong(long v) throws IOException {
writeBuffer[0] = (byte) (v >>> 56);
writeBuffer[1] = (byte) (v >>> 48);
writeBuffer[2] = (byte) (v >>> 40);
writeBuffer[3] = (byte) (v >>> 32);
writeBuffer[4] = (byte) (v >>> 24);
writeBuffer[5] = (byte) (v >>> 16);
writeBuffer[6] = (byte) (v >>> 8);
writeBuffer[7] = (byte) (v >>> 0);
out.write(writeBuffer, 0, 8);
incCount(8);
}
// 将float类型的数据写到数据输出流中
public final void writeFloat(float v) throws IOException {
writeInt(Float.floatToIntBits(v));
}
// 将double类型的数据写到数据输出流中
public final void writeDouble(double v) throws IOException {
writeLong(Double.doubleToLongBits(v));
}
// 将字符串转换成字节写到数据输出流中
public final void writeBytes(String s) throws IOException {
int len = s.length();
for (int i = 0; i < len; i++) {
out.write((byte) s.charAt(i));
}
incCount(len);
}
// 将字节数据转换成字符写到数据输出流中
public final void writeChars(String s) throws IOException {
int len = s.length();
for (int i = 0; i < len; i++) {
int v = s.charAt(i);
out.write((v >>> 8) & 0xFF);
out.write((v >>> 0) & 0xFF);
}
incCount(len * 2);
}
写一个运用的例子:
import java.io.*;
public class DataDemo {
/**
* DataOutputStream & DataInputStream 用于操作基本数据类型
*/
public static void main(String[] args) throws IOException {
writeDemo();
readDemo();
}
public static void readDemo() throws IOException {
DataInputStream dos = new DataInputStream(new FileInputStream("data.txt"));
String s = dos.readUTF();
System.out.println(s);
}
public static void writeDemo() throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("你好啊");
}
}
/**
*运行结果
*
*你好啊
*
*Process finished with exit code 0
*/