Java输入输出流(一)#

虾米姐 阅读:535 2021-06-02 17:34:53 评论:0

 


Android 是基于 Java 语言编写的,在安卓程序的很多时候会用到有关 I/O 操作,要在 Adroid 中使用 I/O 操作就必须学会 JavaI/O 操作。

首先要知道的是,Java 中输入和输出的概念都是对于程序来说的。就是 外部往程序输入,程序向外部输出。外部往程序输入,则程序必须去 取外部,程序向外部输出,则程序必须去 给外部。在外部和程序之间,Java 分别通过 输入流InputStream输出流OutStream 进行联系。

流的示意图如下

Java.io 的结构树##

本人才疏学浅,对于Java I/O也是初学阶段,因此本着与读者一同探讨的心态,按照结构树从上至下逐个去看一下每一个类的使用方法。

字节流与字符流##

从结构树我们可以看到位于树的顶端是字节流和字符流。

  1. 字节流 :表示以字节为单位从 stream 中读取或往 stream 中写入信息,即 io 包中的 inputstream 类和 outputstream 类的派生类。通常用来读取二进制数据,如图象和声音。
  2. 字符流 :以 Unicode 字符为导向的 stream,表示以 Unicode 字符为单位从 stream 中读取或往 stream 中写入信息。 区别: ReaderWriter 要解决的,最主要的问题就是国际化。原先的 I/O 类库只支持8位的字节流,因此不可能很好地处理16位的 Unicode 字符流。Unicode 是国际化的字符集(更何况 Java 内置的 char 就是16位的 Unicode 字符),这样加了 ReaderWriter 之后,所有的 I/O 就都支持 Unicode 了。

InputStream与OutputStream##

对于字节流,它有两个抽象类:InputStreamOutputStream,在这两个抽象类里面没有具体的实现方法,它的具体实现需要它的 子类 来实现,在它里面定义了一些函数用以 子类 的去实现。

1 InputStream###

我们打开 InputStream 源码看到里面定义一些方法:

  • public abstract int read() :读取 input stream 的下一个字节,返回值为下一个字节
  • public int read(byte b[]) : 读取 input stream ,并将其存在数组 b 中,以b[0]开始存储,最多能读取 b.length 个字节
  • public int read(byte b[], int off, int len) :读取 input stream ,读取的长度为 len ,以 b[off] 开始存储,read(byte b[]) 的实现就是调用该方法: read(b,0,b.length)
  • public long skip(long n) :跳过 input stream 的 n 个字节
  • public int available() :粗略估计 input stream 可以读取的字节,返回估计值,不一定准确。不会阻塞调用 input stream 的下一个方法
  • public void close() : 关闭 input stream, 释放与input stream 相关的系统资源
  • public synchronized void mark(int readlimit) :标记input stream当前 (mark()被调用的这一刻 )位置,参数 readlimit 用来告诉系统,当之后读取的字节数超过 readlimit 后,mark 失效
  • public synchronized void reset() :退回到最后一次 input stream 调用 mark()方法地方,之后读取字节的时候就会从 mark 处开始。当 mark() 调用的时候 input stream 就会记住从这一刻开始读入的所有字节,当 reset() 被调用的时候,就会准备好提供这些字节,而如果读入的字节数超过了 readlimit,reset()还没有被调用,那么 input stream 就不会继续记录,也就是 mark 失效了
  • public boolean markSupported() :测试该 IO 类是否支持 mark() 和 reset()方法

2 OutputStream###

同样我们打开 OutputStream 的源码,可以看到里面有这些方法:

  • public abstract void write(int b) :往 output stream 写出一个字节,这个字节是 b 的低八位,b 的高24位会被忽略
  • public void write(byte b[]) :往 output stream 写出 b.length 长度的字节,通过调用 write( b, 0, b.length) 来实现
  • public void write(byte b[], int off, int len) :写出长度为 len 的字节,第一个写出的是 b[off],
  • public void flush() :清空当前 output stream以及强制输出所有缓冲数据
  • public void close() :关闭 output stream, 释放与input stream 相关的系统资源

InputStreamOutputStream 两个抽象类定义了输入流和输出流应该具备什么功能,但是具体却没有实现。她们的具体实现是通过继承于它们的子类来实现的

1.1 FileInputStream###

对文件进行写入的类。对 file 类没有了解的读者可以查阅相关资料,这里给出一个网址以供产考:

IT虾米网

首先看看它的构造方法:

  • FileInputStream(File file) :通过传入一个 file 类对象,来创建 file input stream
  • FileInputStream(FileDescriptor fdObj) :通过 file descriptor fdObj 来创建一个 file input stream
  • FileInputStream(String name) :通过传入一个 file 在系统中的名字(或者路径)来创建 file input stream,实际上他是通过调用 FileInputStream(name != null ? new File(name) : null) 来实现的

再来看看它的方法:

  • int available() :粗略估计 input stream 可以读取的字节,返回估计值,不一定准确。不会阻塞调用 input stream 的下一个方法
  • void close() :关闭 input stream ,释放与之相关的系统资源
  • protected void finalize() :确保 input stream 已经关闭如果没有,则继续调用 close()
  • int read() :读取 input stream 的下一个字节。这个方法是Java的原始类,底层是用C/C++来实现的
  • int read(byte[] b) :读取 b.length 长度的字节并存到 b 中
  • int read(byte[] b, int off, int len) :读取 input stream ,读取的长度为 len ,以 b[off] 开始存储,read(byte b[]) 的实现就是调用该方法: read(b,0,b.length)
  • long skip(long n) :跳过 input stream 的 n 个字节

代码举例:

FileInputStream fileInput = null; 
    byte [] b = new byte[2097152];//用来存放读取输入流的数据 File file = new File("C:/Users/加盐/Desktop/logo.jpg"); try { //try catch 是用来捕获异常 fileInput = new FileInputStream(file);//通过传递file参数来新建file input stream 对象 } catch (FileNotFoundException e) { e.printStackTrace(); } try { fileInput.read(b); //读取数据,并存到b中 fileInput.close(); } catch (IOException e) { e.printStackTrace(); } 

要注意的是在 windows 和 Linux 系统中,"/"表示分割符,在 windows 中还可以用 "",但是由于java中 ""表示转义符号,因此要用 "\",例如:C:\\Users\\加盐\\Desktop\\logo.jpg

1.1.1 BufferedInputStream###

如果传输的文件比较大,直接利用 FileInputStream 时,是程序直接与硬盘进行访问,我们知道硬盘的存取速度是最慢的,因此这样就会比较耗时。如果我们先把要存储的数据放到内存中,等到内存区满了之后,我们再把内存的数据写到硬盘中,这样速度就会快很多。因为首先计算机对内存的访问速度比访问硬盘要快,其次,由于是每次指定的内存区满了之后,再把数据写到硬盘,这样就减少了对硬盘的访问次数,节省了很多时间。

BufferedInputStream 又称为包装流,因为它能将其他的 InputStream 封装成 BufferedInputStream,这一点从它的构造函数就可以看到:

BufferedInputStream(InputStream in) :创建一个 BufferedInputStream ,并把它的参数 in 保存起来,用以后续的使用
BufferedInputStream(InputStream in, int size) :创建一个BufferedInputStream ,并把它的参数 in 保存起来,用以后续的使用,而且 size 指定了这个缓冲区的大小,也就是输入设备一次往缓冲区写入 size 字节大小的数据。待程序读取完,缓冲区为空后,再次输入设备再向缓冲区写入数据。若没有指定 size ,系统默认为8192。

它的方法:

  • int available()
  • void close()
  • void mark(int readlimit)
  • boolean markSupported()
  • int read()
  • int read(byte[] b, int off, int len)
  • void reset()
  • long skip(long n)

以上所有的方法与前面所讲的 InputStream 类的同名方法的作用一样的,下面来看例子:

在IO.txt中


现在利用 BufferedInputStream(InputStream in) 将它读入 ,并显示到控制台
public static void main(String[] arg) FileInputStream fileInput = null; BufferedInputStream bufferInput = null; int len = 0; byte [] b = new byte[1024]; File file = new File("C:/Users/加盐/Desktop/IO.txt"); try { fileInput = new FileInputStream(file); bufferInput = new BufferedInputStream(fileInput); //把FileInputStream包装成 BufferInputStream } catch (FileNotFoundException e) { e.printStackTrace(); } try { len = bufferInput.read(b); bufferInput.close(); fileInput.close(); } catch (IOException e) { e.printStackTrace(); } for(int i=0;i<len;i++){ System.out.print((char) b[i]+""); } } } 

运行结果如上图所示

现在我们来用一下 mark()方法:

public static void main(String[] arg) throws IOException{ FileInputStream fileInput = null; BufferedInputStream bufferInput = null; int len = 0; byte [] b = new byte[1024]; File file = new File("C:/Users/加盐/Desktop/IO.txt"); fileInput = new FileInputStream(file); bufferInput = new BufferedInputStream(fileInput); bufferInput.read(b, 0, 3);//先让bufferInput被读取3个字节 bufferInput.mark(10); //然后进行标记 for(int i = 1;i<10;i++){ int a = 3*i; bufferInput.read(b,a,3); //然后在往后读取三个字节后 bufferInput.reset(); //然后重置,也就是回到bufferInput的被标记的位置 } //下一次读取bufferInput的时候又从标记点开始 //所以我们可以猜想,最后一定会第四个字节和第六个字节重复出现九次 bufferInput.close(); fileInput.close(); for(int i=0;i<b.length;i++){ if(b[i]==0)break; System.out.print((char) b[i]+""); } } } 

运行结果如上图,符合我们的猜想

1.1.2 DataInputStream###

前面我们看到,进入 input stream 的基本单位都是字节,尽管底层确实是以字节作为传输单位,但是有些时候就显得不太方便,,比如说我知道要传输的都是 int 类型的数据,那么我们是否可以直接以 int 类型的数据进行传输单位呢?

DataInputStream 类就解决了这个问题,允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据(请稍微注意这一句话)。

下面来看它的构造函数:

  • DataInputStream(InputStream in) :通过传入 InputStream 来构造 DataInputstream

方法:

  • int read(byte[] b) :与前面 InputStream 的同名方法一样
  • int read(byte[] b, int off, int len) :与前面 InputStream 的同名方法一样
  • boolean readBoolean() :读取一个字节,若该字节为非零,则返回 true ,若为零,则返回 false
  • byte readByte() :读取一个字节
  • char readChar() :读取两个字节并返回一个 char 类型数据
  • double readDouble() :读取八个字节并返回一个 double 类型的数据
  • float readFloat() :读取四位字节并返回一个 float 类型的数据
  • void readFully(byte[] b) :与 int read(byte[] b) 类似,只是没有返回值
  • void readFully(byte[] b, int off, int len) :与int read(byte[] b, int off, int len)类似,返回值为零,从源码中可以看到,这个方法有一个机制保证一定能读取到 len 长度的字节数
  • int readInt() :读取四个字节并返回一个 int 类型的数据
  • long readLong() :读取八个字节,并返回一个 long 类型的数据
  • short readShort() :读取两个字节,并返回一个 short 类型的数据
  • int readUnsignedByte() :读取一个字节,返回一个无符号类型的字节,实际上就是把读取到的数据转成 int 类型输出
  • int readUnsignedShort() :读取梁个字节,返回一个无符号类型的 short 数据,实际上就是把读取到的数据转成 int 类型输出
  • String readUTF() :读取用UTF-8编码的字符串
  • int skipBytes(int n) :跳过 n 个字节

下面我们来看例子:

    public static void main(String[] arg) throws IOException{ FileInputStream fileInput = null; DataInputStream dataInput = null; byte [] b = new byte[1024]; File file = new File("C:/Users/加盐/Desktop/IO.txt"); fileInput = new FileInputStream(file); dataInput = new DataInputStream(fileInput); System.out.print(dataInput.readBoolean()); dataInput.close(); fileInput.close(); } } 

一个简单的例子,从输入流中读取一个字节,并在控制台输出:输入流在文件中读取一个字符“6”,底层变成相应的字节,然后将文件输入流包装成数据输入流,调用数据输入流读取这个字节,返回一个 Boolean 类型的值


更多的方法不一一展示,读者可自行回去尝试,值得一提的是,。通过查看 DataInputStream 类的源码我们可以发现,对于返回不同数据类型的方法,其实现方法大体相同:

  1. 首先调用 read() 方法,read()的方法读取一个字节,然后为高位补零,返回一个 int 类型值
  2. 根据数据类型的所占用的字节数,相应调用几次 read()方法
  3. 然后进行移位操作,最后把几个字节拼接起来,返回对应的数据类型

下面以 readShort()为例,为大家演示一下,假设底下的字节数为无符号数,并且以原码形式存放(底下并非如此,但是为了方便说明,故如此假设)

代码:

public final short readShort() throws IOException { int ch1 = in.read(); int ch2 = in.read(); //如果到了文件尾返回-1 if ((ch1 | ch2) < 0) //如果如果没有读够两个字节,则抛出异常 throw new EOFException(); return (short)((ch1 << 8) + (ch2 << 0));//第一个字节(实际上是一个高24为0的 //int)左移动8位成为高8位,节不动, //然后拼接成为一个新数据,在把它强制 //类型转换变成 short 类型 } 

假设输入流有两个字节为:00000001和00000002,那么ch1就为00000000000000000000000000000001,ch2为00000000000000000000000000000001
,ch1左移8位:00000000000000000000000100000000,最后拼接起来就是:00000000000000000000000100000002,强制类型转换后变成0000000100000002

2.1 FileOutputStream###

2.1.1 BufferedOutputStream###

2.1.2 DataOutputStream###

2.1.3 PrintStream###




标签:java
声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

关注我们

一个IT知识分享的公众号