社区微信群开通啦,扫一扫抢先加入社区官方微信群
社区微信群
io 流主要提供四个接口
InputStream
: 输入字节流OutputStream
: 输出字节流Reader
: 输入字符流Writer
: 输出字符流InputStream
输入字节流,关注字节的读取,io 包提供如下 InputStream 的实现
ByteArrayInputStream
: 字节数组输入流FileInputStream
: 文件字节输入流PipedInputStream
: 管道输入流,可和其他的 PipedOutStream 连接,通常用于线程间通信DataInputStream
: 二进制数据输入流ObjectInputStream
: 对象输入流BufferedInputStream
: 带缓冲 buffer 的字节输入流SequenceInputStream
: 能将多个字节流合并成一个PushbackInputStream
: 能回退的字节流InputStream
提供如下接口:
read
: 从流中读取一个字节read(buffer)
: 从流中读取字节到 buffer 中,返回真实读取的字节数read(buffer, offset, length)
: 从流中读取 length 个字节,写入到 buffer 的 offset 处,返回真实读取的字节数readNBytes(buffer, offset, length)
: 和 read 一样,但是保证读取 length 个字节,除非流中没有数据readAllBytes
: 读取所有字节,返回一个字节数组skip
: 跳过前 n 个字节available
: 剩余字节数mark
: 标记当前读取的位置reset
: 将流指针重置到上次标记的位置close
: 关闭流,释放资源{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
assertEquals(in.read(), '0');
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
byte[] buf = new byte[4];
assertEquals(in.read(buf), 4);
assertArrayEquals(buf, "0123".getBytes());
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
byte[] buf = new byte[20];
assertEquals(in.read(buf), 10);
assertArrayEquals(Arrays.copyOf(buf, 10), "0123456789".getBytes());
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
byte[] buf = new byte[20];
assertEquals(in.read(buf, 1, 4), 4);
assertArrayEquals(Arrays.copyOfRange(buf, 1, 1 + 4), "0123".getBytes());
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
byte[] buf = new byte[20];
assertEquals(in.readNBytes(buf, 1, 4), 4);
assertArrayEquals(Arrays.copyOfRange(buf, 1, 1 + 4), "0123".getBytes());
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
assertArrayEquals(in.readAllBytes(), "0123456789".getBytes());
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
assertEquals(in.skip(2), 2);
assertEquals(in.available(), 8);
assertEquals(in.read(), '2');
assertEquals(in.available(), 7);
in.mark(0);
assertEquals(in.read(), '3');
in.reset();
assertEquals(in.available(), 7);
assertEquals(in.read(), '3');
in.close();
}
{
InputStream in = new ByteArrayInputStream("0123456789".getBytes());
for (int ch = in.read(); ch != -1; ch = in.read()) {
System.out.println(ch);
}
}
OutputStream
输出字节流,关注字节的写入,io 包提供了如下 OutputStream 的实现
ByteArrayOutputStream
: 输出 byte 数组FileOutputStream
: 文件输出流PipedOutputStream
: 管道输出流,可和其他的 PipedInputStream 连接,通常用于线程间通信DataOutputStream
: 二进制数据输出流ObjectOutputStream
: 对象输出流BufferedOutputStream
: 带缓冲 buffer 的输出流SequenceOutputStream
: 能将多个输出流合并成一个OutputStream
提供如下接口:
write
: 写入一个字节write(buffer)
: 写入 buffer 中的数据write(buffer, offset, length)
: 写入 buffer 从 offset 起的 length 个字节的数据flush
: 将缓冲区的数据刷到实际的存储中close
: 关闭流OutputStream out = new ByteArrayOutputStream();
out.write('0');
out.write("123456789".getBytes());
out.write("0123456789".getBytes(), 1, 2);
out.flush();
out.close();
Reader
字符输入流,关注字符的读取,io 包提供如下 Reader
的实现
CharArrayReader
: 字符数组输入流FileReader
: 文件字符输入流PipedReader
: 管道输入流,可以和 PipedWriter
连接,通常用于线程间通信StringReader
: 字符串输入流BufferedReader
: 带缓冲 buffer 的字符输入流LineNumberReader
: 带行号的字符输入流PushbackReader
: 能回退的字符输入流InputStreamReader
: 输入字节流转字符流Reader
提供如下接口:
read
: 从流中读取一个字符read(buffer)
: 从流中读取字符到 buffer 中,返回真实读取的字符数read(buffer, offset, length)
: 从流中读取 length 个字符,写入到 buffer 的 offset 处,返回真实读取的字符数read(CharBuffer
: 从流中读取字符到 CharBuffer 中,返回真实读取的字符数skip
: 跳过前 n 个字符mark
: 标记当前读取的位置reset
: 将流指针重置到上次标记的位置close
: 关闭流,释放资源{
Reader reader = new CharArrayReader("0123456789".toCharArray());
assertEquals(reader.read(), '0');
}
{
Reader reader = new CharArrayReader("0123456789".toCharArray());
char[] buf = new char[4];
assertEquals(reader.read(buf), 4);
assertArrayEquals(buf, "0123".toCharArray());
}
{
Reader reader = new CharArrayReader("0123456789".toCharArray());
char[] buf = new char[20];
assertEquals(reader.read(buf), 10);
assertArrayEquals(Arrays.copyOf(buf, 10), "0123456789".toCharArray());
}
{
Reader reader = new CharArrayReader("0123456789".toCharArray());
char[] buf = new char[20];
assertEquals(reader.read(buf, 1, 4), 4);
assertArrayEquals(Arrays.copyOfRange(buf, 1, 1 + 4), "0123".toCharArray());
}
{
Reader reader = new CharArrayReader("0123456789".toCharArray());
CharBuffer buf = CharBuffer.allocate(20);
assertEquals(reader.read(buf), 10);
}
{
Reader reader = new CharArrayReader("0123456789".toCharArray());
assertTrue(reader.ready());
assertEquals(reader.skip(2), 2);
assertEquals(reader.read(), '2');
reader.mark(0);
assertEquals(reader.read(), '3');
reader.reset();
assertEquals(reader.read(), '3');
reader.close();
}
{
Reader reader = new CharArrayReader("0123456789".toCharArray());
for (int ch = reader.read(); ch != -1; ch = reader.read()) {
System.out.println(ch);
}
}
Writer
字符输出流,关注字符的写入,io 包提供如下 Writer
的实现
CharArrayWriter
: 字符数组输出流FileWriter
: 文件字符输出流PipedWriter
: 管道输出流,可以和 PipedReader
连接,通常用于线程间通信StringWriter
: 字符串输出流BufferedWriter
: 带缓冲 buffer 的字符输出流OutputStreamWriter
: 输出字节流转字符流Writer
提供如下接口:
write(char)
: 写入一个字符write(string)
: 写入一个字符串write(string, offset, length)
: 写入 string 从 offset 起的 length 个字符的数据write(char[])
: 写入字符数组中的数据write(char[], offset, length)
: 写入字符数组从 offset 起的 length 个字符的数据append(ch)
: 写入一个字符,和 write 一样append(CharSequence)
: 写入字符序列的所有数据(String, StringBuilder, StringBuffer 都是 CharSequence 的子类)append(CharSequence, offset, length)
: 写入字符序列从 offset 起的 length 个字符的数据flush
: 将缓冲区的数据刷到实际的存储中close
: 关闭流Writer writer = new CharArrayWriter();
writer.write('0');
writer.write("0123456789");
writer.write("0123456789", 1, 4);
writer.write("0123456789".toCharArray());
writer.write("0123456789".toCharArray(), 1, 4);
writer.append('0');
writer.append(new StringBuilder("0123456789"));
writer.append(new StringBuilder("0123456789"), 1, 4);
writer.flush();
writer.close();
文件字节流关注文件的读取和写入
{
FileOutputStream fout = new FileOutputStream("/tmp/test.txt");
fout.write("No patient who, who has no wisdom".getBytes());
fout.close();
}
{
FileInputStream fin = new FileInputStream("/tmp/test.txt");
assertArrayEquals(fin.readAllBytes(), "No patient who, who has no wisdom".getBytes());
fin.close();
}
缓冲字节流采用装饰者模式,装饰在其他流上,使流拥有了缓存功能,从而提高读写了效率
{
BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("/tmp/test.txt"));
bout.write("People lack the willpower, rather than strength".getBytes());
bout.close();
}
{
BufferedInputStream bin = new BufferedInputStream(new FileInputStream("/tmp/test.txt"));
assertArrayEquals(bin.readAllBytes(), "People lack the willpower, rather than strength".getBytes());
bin.close();
}
二进制字节流关注在基本数据类型的读取和写入,采用装饰者模式,能装饰在其他流上
DataOutputStream
在 OutputStream
的基础上新增了如下接口:
writeBoolean
: 写入一个 boolean 值writeByte
: 写入一个字节writeShort
: 写入一个短整型writeInt
: 写入一个整型writeLong
: 写入一个长整型writeFloat
: 写入一个浮点型writeDouble
: 写入一个双精度浮点型writeChar
: 写入一个字符writeUTF
: 写入一个 unicode 字符串DataInputStream
在 InputStream
的基础上新增了如下接口:
readBoolean
: 读取一个 boolean 值readByte
: 读取一个字节readShort
: 读取一个 shortreadInt
: 读取一个整型readLong
: 读取一个长整型readFloat
: 读取一个浮点型readDouble
: 读取一个双精度浮点型readChar
: 读取一个字符readUTF
: 读取一个 unicode 字符串{
DataOutputStream dout = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("/tmp/test.txt")));
dout.writeBoolean(false);
dout.writeByte('x');
dout.writeShort(123);
dout.writeInt(123456);
dout.writeLong(123456789);
dout.writeFloat((float) 123.456);
dout.writeDouble(123.456);
dout.writeUTF("Rome wasn’t built in one day");
dout.close();
}
{
DataInputStream din = new DataInputStream(new BufferedInputStream(new FileInputStream("/tmp/test.txt")));
assertEquals(din.readBoolean(), false);
assertEquals(din.readByte(), 'x');
assertEquals(din.readShort(), 123);
assertEquals(din.readInt(), 123456);
assertEquals(din.readLong(), 123456789);
assertEquals(din.readFloat(), (float) 123.456);
assertEquals(din.readDouble(), 123.456);
assertEquals(din.readUTF(), "Rome wasn’t built in one day");
din.close();
}
对象字节流关注对象的写入和读取,同时拥有二进制字节流的所有功能,同样采用装饰者模式
ObjectOutputStream
相比 DataOutputStream
新增了如下接口:
writeObject
: 写入任何 Serializable 对象ObjectInputStream
相比 DataInputStream
新增了如下接口:
readObject
: 从流中读取一个对象{
ObjectOutputStream oout = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("/tmp/test.txt")));
oout.writeBoolean(false);
oout.writeByte('x');
oout.writeShort(123);
oout.writeInt(123456);
oout.writeLong(123456789);
oout.writeFloat((float) 123.456);
oout.writeDouble(123.456);
oout.writeUTF("Nothing is impossible to a willing heart");
oout.writeObject(new Point(123, 456));
oout.close();
}
{
ObjectInputStream oin = new ObjectInputStream(new BufferedInputStream(new FileInputStream("/tmp/test.txt")));
assertEquals(oin.readBoolean(), false);
assertEquals(oin.readByte(), 'x');
assertEquals(oin.readShort(), 123);
assertEquals(oin.readInt(), 123456);
assertEquals(oin.readLong(), 123456789);
assertEquals(oin.readFloat(), (float) 123.456);
assertEquals(oin.readDouble(), 123.456);
assertEquals(oin.readUTF(), "Nothing is impossible to a willing heart");
Point point =
版权声明:本文来源CSDN,感谢博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
原文链接:https://blog.csdn.net/hatlonely/article/details/103798313
站方申明:本站部分内容来自社区用户分享,若涉及侵权,请联系站方删除。
如果觉得我的文章对您有用,请随意打赏。你的支持将鼓励我继续创作!