JavaIO（二）：InputStream与OutputStream
罗炜光
4月 26, 2016
ByteArrayInputStream
public class Test
{
public static void main(String[] args) throws IOException
{
byte[] bytes1 = new byte[52];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
ByteArrayInputStream bais1 = new ByteArrayInputStream(bytes1);
//skip(long n) long 从此输入流中跳过 n 个输入字节。
System.out.println("skip(long n):" + bais1.skip(256));
//available() int 返回可从此输入流读取（或跳过）的剩余字节数。
System.out.println("available():" + bais1.available());
//markSupported() boolean 测试此 InputStream 是否支持 mark/reset。
System.out.println("markSupported():" + bais1.markSupported());
//mark(int readAheadLimit) void 设置流中的当前标记位置。
bais1.mark(512);
//read() int 从此输入流中读取下一个数据字节。
System.out.println("read():" + bais1.read());
byte[] bytes2 = new byte[512];
//read(byte[] int 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
System.out.println("read(byte[]):" + bais1.read(bytes2));
System.out.println(new String(bytes2));
//read(byte[] b, int off, int len) int 将最多 len 个数据字节从此输入流读入 byte 数组。
System.out.println("read(byte[] b, int off, int len):" + bais1.read(bytes2, 0, 128));
System.out.println(new String(bytes2));
//reset() void 将缓冲区的位置重置为标记位置。
bais1.reset();
System.out.println("reset():" + bais1.available());
//close() void 关闭 ByteArrayInputStream
bais1.close();
}
}
输出
skip(long n):26
available():26
markSupported():true
read():97
read(byte[]):25
bcdefghijklmnopqrstuvwxyz
FileInputStream
public class Test
{
public static void main(String[] args) throws IOException
{
FileInputStream in1 = new FileInputStream("E:\\Test.txt");
//available() int 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
System.out.println("available():" + in1.available() );
//skip(long n) long 跳过和丢弃此输入流中数据的 n 个字节。
in1.skip(6);
byte[] bytes = new byte[1024];
//read() int 从此输入流中读取一个数据字节。
System.out.println("read():"+in1.read());
//markSupported() boolean 测试此输入流是否支持 mark 和 reset 方法。
System.out.println("markSupported():" + in1.markSupported());
//read(byte[] b) int 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
System.out.println("read(buffer):" + in1.read(bytes));
//read(byte[] b, int off, int len) int 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
System.out.println("read(byte[] b, int off, int len):" + in1.read(bytes, 512, 512));
//getChannel() FileChannel 返回与此文件输入流有关的唯一 FileChannel 对象。
FileChannel finleChannel = in1.getChannel();
//getFD() FileDescriptor 返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。
FileDescriptor fileDescriptor = in1.getFD();
//close() void 关闭此文件输入流并释放与此流有关的所有系统资源。
in1.close();
}
}
输出
available():496800
read():55
markSupported():false
read(buffer):1024
read(byte[] b, int off, int len):512
E:\Test.txt
1234567890123456789012345678901234567890......
SequenceInputStream
public class Test
{
public static void main(String[] args) throws IOException
{
FileInputStream in1 = new FileInputStream("E:\\Test3.txt");
byte[] bytes1 = new byte[1024];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
ByteArrayInputStream bais1 = new ByteArrayInputStream(bytes1);
SequenceInputStream sis1 = new SequenceInputStream(in1, bais1);
//available() int 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
System.out.println("available():" + sis1.available());
byte[] bytes2 = new byte[128];
//read() int 从此输入流中读取一个数据字节。
System.out.println("read():" + sis1.read());
//read(byte[] b) int 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
System.out.println("read(byte[] b):" + sis1.read(bytes2));
//read(byte[] b, int off, int len) int 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
System.out.println("read(byte[] b, int off, int len):" + sis1.read(bytes2,0,26));
//markSupported() boolean 测试此输入流是否支持 mark 和 reset 方法。
System.out.println("markSupported():" +sis1.markSupported());
//close() void 关闭此输入流并释放与此流关联的所有系统资源。
sis1.close();
}
}
输出
available():10
read():49
read(byte[] b):9
read(byte[] b, int off, int len):26
markSupported():false
BufferedInputStream
public class Test
{
public static void main(String[] args) throws IOException
{
BufferedInputStream bis1 = new BufferedInputStream(new FileInputStream("E:\\Test.txt"),2048);
//available() int 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
System.out.println("available():" + bis1.available() );
//skip(long n) long 跳过和丢弃此输入流中数据的 n 个字节。
bis1.skip(6);
byte[] bytes = new byte[1024];
//read() int 从此输入流中读取一个数据字节。
System.out.println("read():"+bis1.read());
//markSupported() boolean 测试此输入流是否支持 mark 和 reset 方法。
System.out.println("markSupported():" + bis1.markSupported());
//mark(int readAheadLimit) void 设置流中的当前标记位置。
bis1.mark(1);
//read(byte[] b) int 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
System.out.println("read(buffer):" + bis1.read(bytes));
//read(byte[] b, int off, int len) int 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
System.out.println("read(byte[] b, int off, int len):" + bis1.read(bytes, 512, 512));
//reset() void 将缓冲区的位置重置为标记位置。
bis1.reset();
System.out.println("reset():"+bis1.read());
}
}
输出
available():496800
read():55
markSupported():true
read(buffer):1024
read(byte[] b, int off, int len):512
reset():56
PushbackInputStream
public class Test
{
public static void main(String[] args) throws IOException
{
final PushbackInputStream pis1 = new PushbackInputStream(new FileInputStream("E:\\Test.txt"),2048);
//available() int 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
System.out.println("available():" + pis1.available() );
//skip(long n) long 跳过和丢弃此输入流中数据的 n 个字节。
pis1.skip(6);
byte[] bytes1 = new byte[1024];
byte[] bytes2 = new byte[1024];
//read() int 从此输入流中读取一个数据字节。
System.out.println("read():"+pis1.read());
//markSupported() boolean 测试此输入流是否支持 mark 和 reset 方法。
System.out.println("markSupported():" + pis1.markSupported());
//read(byte[] b) int 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
System.out.println("read(buffer):" + pis1.read(bytes1));
//read(byte[] b, int off, int len) int 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
System.out.println("read(byte[] b, int off, int len):" + pis1.read(bytes2, 512, 512));
//unread(byte[] b, int off, int len) void 推回 byte 数组的某一部分：将其复制到推回缓冲区之前。
pis1.unread(bytes2, 512, 512);
//unread(byte[] b) void 推回一个 byte 数组：将其复制到推回缓冲区之前。
pis1.unread(bytes1);
//unread(int b) void 推回一个字节：将其复制到推回缓冲区之前。
pis1.unread(55);
//close() void 关闭此输入流并释放与此流关联的所有系统资源。
pis1.close();
}
}
输出
available():496800
read():55
markSupported():false
read(buffer):1024
read(byte[] b, int off, int len):512
ObjectInputStream
public class Test
{
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException
{
ObjectInputStream ois1 = new ObjectInputStream(new FileInputStream("E:\\Test5.txt"));
//readObject() Object 从 ObjectInputStream 读取对象。
System.out.println("readObject():" + (Date)ois1.readObject());
//available() int 返回可以不受阻塞地读取的字节数。
System.out.println("available():" + ois1.available());
byte[] bytes1 = new byte[26];
//read(byte[] b) int 读入 byte 数组。
System.out.println("readByte():" + ois1.read(bytes1));
//read(byte[] buf, int off, int len) int 读入 byte 数组
System.out.println("read(byte[] buf, int off, int len):" + ois1.read(bytes1, 0, 26));
//read() int 读取数据字节。
System.out.println("read():" + ois1.read());
//readBoolean() boolean 读取一个 boolean 值。
System.out.println("readBoolean():" + ois1.readBoolean());
//readByte() byte 读取一个 8 位的字节。
System.out.println("readByte():" + ois1.readByte());
byte[] bytes2 = new byte[11];
System.out.println("read(byte[] b):" + ois1.read(bytes2));
System.out.println(new String(bytes2));
//readChar() char 读取一个 16 位的 char 值。
System.out.println("readChar():" + ois1.readChar());
System.out.println("readChar():" + ois1.readChar());
//skip(long n) int 跳过和丢弃此输入流中数据的 n 个字节。
System.out.println("skip(long n):" + ois1.skip(10));
//skipBytes(int len) int 跳过字节。
System.out.println("skipBytes(int len):" + ois1.skipBytes(10));
//readDouble() double 读取一个 64 位的 double 值。
System.out.println("readDouble():" + ois1.readDouble());
//readFloat() float 读取一个 32 位的 float 值。
System.out.println("readFloat():" + ois1.readFloat());
//readInt() int 读取一个 32 位的 int 值。
System.out.println("readInt():" + ois1.readInt());
//readLong() long 读取一个 64 位的 long 值。
System.out.println("readLong():" + ois1.readLong());
//readShort() short 读取一个 16 位的 short 值。
System.out.println("readShort():" + ois1.readShort());
//readUnshared() Object 从 ObjectInputStream 读取“非共享”对象。
System.out.println("readUnshared():" + (Date)ois1.readUnshared());
//readUTF() String 读取 UTF-8 修改版格式的 String。
System.out.println("readUTF():" + ois1.readUTF());
//close() void 关闭输入流。
ois1.close();
}
}
输出
readObject():Sat Apr 23 21:12:41 CST 2016
available():116
readByte():26
read(byte[] buf, int off, int len):26
read():97
readBoolean():true
readByte():97
read(byte[] b):11
Hello World
readChar():a
readChar():H
skip(long n):10
skipBytes(int len):10
readDouble():1024.0
readFloat():1024.0
readInt():1024
readLong():1024
readShort():26
readUnshared():Sat Apr 23 21:12:41 CST 2016
readUTF():你好，世界
- E:\Test5.txt为ObjectOutputStream输出
DataInputStream
public class Test
{
public static void main(String[] args) throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("E:\\Test6.txt"));
//available() int 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
System.out.println("available():" + dis.available());
byte[] bytes1 = new byte[26];
dis.read(bytes1, 0, 13);
System.out.println("read(byte[] b, int off, int len):" + new String(bytes1));
//read() int 从此输入流中读取下一个数据字节。
System.out.println("read():" + dis.read());
//boolean 读取一个输入字节，如果该字节不是零，则返回 true，如果是零，则返回 false。
System.out.println("readBoolean():" + dis.readBoolean());
//readByte() byte 读取并返回一个输入字节。
System.out.println("readByte():" + dis.readByte());
byte[] bytes2 = new byte[11];
//read(byte[] b) int 从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中
dis.read(bytes2);
System.out.println("read(byte[] b):" + new String(bytes2));
//readChar() char 读取两个输入字节并返回一个 char 值
System.out.println("readChar():" + dis.readChar());
//skip(long n) long 跳过和丢弃此输入流中数据的 n 个字节。
System.out.println("skip(long n):" + dis.skip(11));
//skipBytes(int n) int 试图在输入流中跳过数据的 n 个字节，并丢弃跳过的字节。
System.out.println("skipBytes(int n):" + dis.skipBytes(11));
//readDouble() double 读取八个输入字节并返回一个 double 值。
System.out.println("readDouble():" + dis.readDouble());
//readFloat() float 读取四个输入字节并返回一个 float 值。
System.out.println("readFloat():" + dis.readFloat());
//readInt() int 读取四个输入字节并返回一个 int 值。
System.out.println("readInt():" + dis.readInt());
//readLong() long 读取八个输入字节并返回一个 long 值。
System.out.println("readLong():" + dis.readLong());
//readShort() short 读取两个输入字节并返回一个 short 值。
System.out.println("readShort():" + dis.readShort());
//readUTF() String 读入一个已使用 UTF-8 修改版格式编码的字符串。
System.out.println("readUTF():" + dis.readUTF());
//markSupported() boolean 测试此输入流是否支持 mark 和 reset 方法
System.out.println("markSupported():" + dis.markSupported());
//close() void 关闭此输入流并释放与此流关联的所有系统资源。
dis.close();
}
}
输出
available():94
read(byte[] b, int off, int len):abcdefghijklm
read():97
readBoolean():true
readByte():98
read(byte[] b):Hello World
readChar():c
skip(long n):11
skipBytes(int n):11
readDouble():99.9
readFloat():99.8
readInt():100
readLong():101
readShort():102
readUTF():你好，世界
markSupported():false
- E:\Test6.txt为DataOutputStream输出
PipedInputStream与PipedOutputStream
public class Test
{
public static void main(String[] args) throws Exception
{
PipedInputStream pis1 = new PipedInputStream();
PipedOutputStream pos1 = new PipedOutputStream();
//connect(PipedInputStream snk) void 将此管道输出流连接到接收者。
pis1.connect(pos1);
ReadThread readTh = new ReadThread(pis1);
WriteThread writeTh = new WriteThread(pos1);
new Thread(readTh).start();
new Thread(writeTh).start();
}
}
class ReadThread implements Runnable
{
private PipedInputStream pis;
ReadThread(PipedInputStream pis) //
{
this.pis=pis;
}
public void run() //由于必须要覆盖run方法,所以这里不能抛,只能try
{
try
{
System.out.println("PipedInputStream:读取前没有数据,阻塞中...等待数据传过来再输出到控制台...");
//available() int 返回可以不受阻塞地从此输入流中读取的字节数。
System.out.println("available():" + pis.available());
byte[] bytes1 = new byte[26];
//read(byte[] b) int 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
pis.read(bytes1);
System.out.println("PipedInputStream:读取数据成功,阻塞解除...");
System.out.println(new String(bytes1)); //将读取的数据流用字符串以字符串打印出来
//read() int 读取此管道输入流中的下一个数据字节。
System.out.println(pis.read());
byte[] bytes2 = new byte[26];
//read(byte[] b, int off, int len) int 将最多 len 个数据字节从此管道输入流读入 byte 数组。
pis.read(bytes2, 0, 14);
System.out.println(new String(bytes2));
//markSupported() boolean 测试此输入流是否支持 mark 和 reset 方法。
System.out.println(pis.markSupported());
//close() int 关闭此管道输入流并释放与该流相关的所有系统资源。
pis.close();
}
catch(Exception e)
{
throw new RuntimeException("PipedInputStream:管道读取流失败!");
}
}
}
class WriteThread implements Runnable
{
private PipedOutputStream pos;
WriteThread(PipedOutputStream pos)
{
this.pos= pos;
}
public void run()
{
try
{
System.out.println("PipedOutputStream:开始将数据写入");
byte[] bytes1 = new byte[26];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('A' + i%26);
}
//write(byte[] b) void 将 b.length 个字节从指定的 byte 数组写入此输出流。
pos.write(bytes1);
//write(int b) void 将指定 byte 写入传送的输出流。
pos.write(97);
//write(byte[] b, int off, int len) void 将 len 字节从初始偏移量为 off 的指定 byte 数组写入该管道输出流。
pos.write(bytes1, 0, 13);
//flush() void 刷新此输出流并强制写出所有缓冲的输出字节。
pos.flush();
Thread.sleep(5000);
//close() void 关闭此管道输出流并释放与此流有关的所有系统资源。
pos.close();
}
catch(Exception e)
{
throw new RuntimeException("PipedOutputStream:WriteThread写入失败...");
}
}
}
输出
PipedInputStream:读取前没有数据,阻塞中...等待数据传过来再输出到控制台...
PipedOutputStream:开始将数据写入
available():0
PipedInputStream:读取数据成功,阻塞解除...
ABCDEFGHIJKLMNOPQRSTUVWXYZ
97
ABCDEFGHIJKLM
ByteArrayOutputStream
public class Test
{
public static void main(String[] args) throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//write(int b) void 将指定的字节写入此 byte 数组输出流。
baos.write(97);
byte[] bytes1 = new byte[26];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
//write(byte[] b) void 将 b.length 个字节从指定的 byte数组写入此输出流。
baos.write(bytes1);
//write(byte[] b, int off, int len) void 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流。
baos.write(bytes1, 0, 13);
//toString(String charsetName) String 使用指定的 charsetName，通过解码字节将缓冲区内容转换为字符串。
System.out.println(baos.toString("UTF-8"));
//toByteArray() byte[] 创建一个新分配的 byte 数组。
System.out.println(new String(baos.toByteArray()));
//size() int 返回缓冲区的当前大小。
System.out.println(baos.size());
//reset() void 将此 byte 数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有输出。
baos.reset();
//writeTo(OutputStream out) void 将此 byte 数组输出流的全部内容写入到指定的输出流参数中，这与使用 out.write(buf, 0, count) 调用该输出流的 write 方法效果一样。
baos.writeTo(new FileOutputStream("E:\\Test7.txt"));
//flush() void 刷新此输出流并强制写出所有缓冲的输出字节。
baos.flush();
//close() void 关闭此输出流并释放与此流有关的所有系统资源
baos.close();
}
}
输出
aabcdefghijklmnopqrstuvwxyzabcdefghijklm
aabcdefghijklmnopqrstuvwxyzabcdefghijklm
40
FileOutputStream
public class Test
{
public static void main(String[] args) throws IOException
{
FileOutputStream fos = new FileOutputStream("E:\\Test7.txt");
byte[] bytes1 = new byte[26];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
//write(byte[] b) void 将 b.length 个字节从指定 byte 数组写入此文件输出流中。
fos.write(bytes1);
//write(int b) void 将指定字节写入此文件输出流。
fos.write(97);
//write(byte[] b, int off, int len) void 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
fos.write(bytes1, 0, 13);
//getChannel() FileChannel 返回与此文件输出流有关的唯一 FileChannel 对象。
fos.getChannel();
//getFD() FileDescriptor 返回与此流有关的文件描述符。
fos.getFD();
//flush() void 刷新此输出流并强制写出所有缓冲的输出字节。
fos.flush();
//close() void 关闭此输出流并释放与此流有关的所有系统资源。
fos.close();
}
}
BufferedOutputStream
public class Test
{
public static void main(String[] args) throws IOException
{
FileOutputStream fos = new FileOutputStream("E:\\Test7.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos,1024);
byte[] bytes1 = new byte[26];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
//write(byte[] b) void 将 b.length 个字节从指定 byte 数组写入此文件输出流中。
bos.write(bytes1);
//write(int b) void 将指定字节写入此文件输出流。
bos.write(97);
//write(byte[] b, int off, int len) void 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
bos.write(bytes1, 0, 13);
//flush() void 刷新此缓冲的输出流。
bos.flush();
//close() void 关闭此输出流并释放与此流有关的所有系统资源。
bos.close();
}
}
ObjectOutputStream
public class Test
{
public static void main(String[] args) throws IOException, IOException
{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\Test5.txt"));
//writeObject(Object obj) void 将指定的对象写入 ObjectOutputStream。
oos.writeObject(new Date());
//reset() void 重置将丢弃已写入流中的所有对象的状态。
oos.reset();
byte[] bytes1 = new byte[26];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
//write(byte[] buf) void 写入一个 byte 数组。 void 写入一个 byte数组。
oos.write(bytes1);
//write(byte[] buf, int off, int len) void 写入字节的子数组。
oos.write(bytes1, 0, 26);
//write(int val) void 写入一个字节。
oos.write(97);
//writeBoolean(boolean val) void 写入一个 boolean值。
oos.writeBoolean(true);
//writeByte(int val) void 写入一个 8 位字节。
oos.writeByte(97);
//writeBytes(String str) void 以字节序列形式写入一个 String。
oos.writeBytes("Hello World");
//writeChar(int val) void 写入一个 16 位的 char值。 v
oos.writeChar(97);
//writeChars(String str) void 以 char 序列形式写入一个 String。
oos.writeChars("Hello World");
//writeDouble(double val) void 写入一个 64 位的 double 值。
oos.writeDouble(1024);
//writeFloat(float val) void 写入一个 32 位的 float 值。
oos.writeFloat(1024f);
//writeInt(int val) void 写入一个 32 位的 int值。
oos.writeInt(1024);
//writeLong(long val) void 写入一个 64 位的 long 值。
oos.writeLong(1024l);
//writeShort(int val) void 写入一个 16 位的 short 值。
oos.writeShort(26);
//writeUnshared(Object obj) void 将“未共享”对象写入 ObjectOutputStream。
oos.writeUnshared(new Date());
//writeUTF(String str) void 以 UTF-8 修改版格式写入此 String 的基本数据。
oos.writeUTF("你好，世界");
//flush() void 刷新该流的缓冲。
oos.flush();
//close() void 关闭流。
oos.close();
}
}
DataOutputStream
public class Test
{
public static void main(String[] args) throws IOException
{
DataOutputStream dos1 = new DataOutputStream(new FileOutputStream("E:\\Test6.txt"));
byte[] bytes1 = new byte[26];
for(int i = 0;i < bytes1.length;i++)
{
bytes1[i] = (byte) ('a' + i%26);
}
//write(byte[] b, int off, int len) void 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入基础输出流。
dos1.write(bytes1, 0, 13);
//write(int b) void 将指定字节（参数 b 的八个低位）写入基础输出流。
dos1.write(97);
//writeBoolean(boolean v) void 将一个 boolean 值以 1-byte 值形式写入基础输出流。
dos1.writeBoolean(true);
//writeByte(int v) void 将一个 byte 值以 1-byte 值形式写出到基础输出流中。
dos1.writeByte(98);
//writeBytes(String s) void 将字符串按字节顺序写出到基础输出流中。
dos1.writeBytes("Hello World");
//writeChar(int v) void 将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。
dos1.writeChar(99);
//writeChars(String s) void 将字符串按字符顺序写入基础输出流。
dos1.writeChars("Hello World");
//writeDouble(double v) void 使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
dos1.writeDouble(99.9);
//writeFloat(float v) void 使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
dos1.writeFloat(99.8f);
//writeInt(int v) void 将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
dos1.writeInt(100);
//writeLong(long v) void 将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
dos1.writeLong(101l);
//writeShort(int v) void 将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。
dos1.writeShort(102);
//writeUTF(String str) void 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
dos1.writeUTF("你好，世界");
//size() int 返回计数器 written 的当前值，即到目前为止写入此数据输出流的字节数。
System.out.println("size():" + dos1.size());
//flush() void 清空此数据输出流。
dos1.flush();
//write(byte[] b) void 将 b.length 个字节写入此输出流。
dos1.close();
//close() void 关闭此输出流并释放与此流有关的所有系统资源。
}
}