亲宝软件园·资讯

展开

io流函数略解(java_input流)[二]

族语 人气:0

背景

在写这篇随笔之前,已经写了io流函数略解(java_File)(一),主要是总结了File的一些操作,以及一些源码介绍。
在Io实际应用中,实际上运用在如果会操作File,实际上很难写出一点能实际应用的code,因为操作文件嘛,更多的是操作流,也就是steam。
下面将简单总结一些流的概念,以及流的一些基本理论,同时也会贴出源码来略看。

实践

io之所以叫io,i的意思是input,o的意思是output,也就是一个输入一个输出,分别对应read与write。

inputsteam

inputsteam 在java 中是一个abstract class。那么它和接口是不一样的,抽象类是可以有具体方法的甚至构造函数。
inputsteam是read操作,那么看下在inputsteam有什么read的函数吧。

/**
 * Reads the next byte of data from the input stream. The value byte is
 * returned as an <code>int</code> in the range <code>0</code> to
 * <code>255</code>. If no byte is available because the end of the stream
 * has been reached, the value <code>-1</code> is returned. This method
 * blocks until input data is available, the end of the stream is detected,
 * or an exception is thrown.
 *
 * <p> A subclass must provide an implementation of this method.
 *
 * @return     the next byte of data, or <code>-1</code> if the end of the
 *             stream is reached.
 * @exception  IOException  if an I/O error occurs.
 */
public abstract int read() throws IOException;

read 没有实现,是一个抽象的方法。但是告诉了我们很有用的信息。
如下:

  1. 返回的是一个字节,返回是0-255。为什么是0-255呢?因为一个字节是8位,11111111不就是255嘛。

  2. 如果没有了,则返回-1,为什么会返回-1,因为-1最高效。解释起来很复杂,可以关注我后面总结的数据结构。

  3. 如果错误会返回一个IOException 异常。

同样,我找到了另外一个read

public int read(byte b[], int off, int len) throws IOException {
//判断参数是否符合,比如说byte是否为空,然后off与len的一些基本要求,比如说一个正常的off肯定要>0,然后len>0,len还有大于b.length-off
//在看到 b.length - off的时候就可以确定off是针对b[]的,冲off开始,给b[]写入或者替换数据。
    if (b == null) {
        throw new NullPointerException();
    } else if (off < 0 || len < 0 || len > b.length - off) {
        throw new IndexOutOfBoundsException();
    } else if (len == 0) {
        return 0;
    }
//为什么要单独写一个呢?一个是优化,不需要构造for循环,第二个是可以提前检查read错误
    int c = read();
    if (c == -1) {
        return -1;
    }
    b[off] = (byte)c;
//for 循环读取,然后read -1则说明到底了。
    int i = 1;
    try {
        for (; i < len ; i++) {
            c = read();
            if (c == -1) {
                break;
            }
            b[off + i] = (byte)c;
        }
    } catch (IOException ee) {
    }
    return i;
}

这个我就不贴注释了,有源码看啥注释。一些关键点,我也给了自己的一些看法。

然后还有一个是:

public int read(byte b[]) throws IOException {
    return read(b, 0, b.length);
}

其实就是调用read(byte b[], int off, int len);
至此,read部分就基本在这了,当然有其他函数了,不可能一一来说明,用到的时候自然就ok的。

FileInputStream

我们在inputsteam有了一个大体的框架,然而呢,read没有实现。那么来看看到底是如何读取文件的吧,FileInputStream。
依然我们来看read:

public int read() throws IOException {
        return read0();
}
private native int read0() throws IOException;

出现了native,这表示是调用外部库。native解释起来有一丢丢麻烦,就是去调用不是java写的库了,例如调用c语言写的函数库,后面也写一片总结吧。
好吧,read只能暂时介绍到这里,操作一下吧。

 try(InputStream inputStream= new FileInputStream("xxxx"))
 {
     int n;
     while ((n=inputStream.read())!=-1) {
        System.out.println(n);

    }
 }catch (Exception e) {
    // TODO: handle exception
}

ps:

try(InputStream inputStream= new FileInputStream("xxxx"))这样写自动在finally中帮我们调用close方法,因为InputStream 继承了java.lang.AutoCloseable 接口。
为什么要close呢?因为要释放资源啊,用完就放,轻装前行。

ByteArrayInputStream

这个从字面意思是字节数组输入流?意思就是把字符数组转换成InputStream。
例如:

public void ByteArrayInputStreamTest() throws IOException  {
  byte[] data={11,12,15,16};
  try(InputStream inputStream=new ByteArrayInputStream(data))
  {
      int n;
      while ((n = inputStream.read()) != -1) {
      }
  }
}

来看看源码实现吧:

  1. 看看它的超类
ByteArrayInputStream extends InputStream

这就解释了为什么可以这样写:

InputStream inputStream=new ByteArrayInputStream(data)
  1. 实例化:
public ByteArrayInputStream(byte buf[]) {
    this.buf = buf;
    this.pos = 0;
    this.count = buf.length;
}

在这里我们可以想到read(byte b[], int off, int len),其实就是模拟把文件中所有的字节都读出来了,然后给了里面的一个buf 缓存属性。

Reader

InputStream 关于字节流的,Reader 是关于字符流的。
我们知道字节是byte,字符是char,两者存在千丝万缕的关系,他们中间的桥梁是编码。编码又是一个相当难以用一两句话解释的东西了,后续会添加一篇编码的随笔。
总之,看下Reader 到底干什么的吧。

// 读取单个字符
public int read() throws IOException {
    char cb[] = new char[1];
    if (read(cb, 0, 1) == -1)
        return -1;
    else
        return cb[0];
}
// 抽象没得实现
abstract public int read(char cbuf[], int off, int len) throws IOException;
//调用了抽象read(char cbuf[], int off, int len)
public int read(char cbuf[]) throws IOException {
    return read(cbuf, 0, cbuf.length);
}

好吧,没有什么具体的实现,那么就去看看InputStreamReader吧,它的一个实现类。

InputStreamReader

根据上文,我们迫切需要知道的是abstract public int read(char cbuf[], int off, int len) throws IOException的实现方法。

public int read(char[] cbuf,
    int offset,
    int length) throws IOException 

{
        int off = offset;
        int len = length;
        synchronized (lock) {
            ensureOpen();
            if ((off <  0) || (off  > cbuf.length) || (len <  0) ||
                ((off + len)  > cbuf.length) || ((off + len) <  0)) {
                throw new IndexOutOfBoundsException();
            }
            if (len == 0)
                return 0;
            int n = 0;
            if (haveLeftoverChar) {
                // Copy the leftover char into the buffer
                cbuf[off] = leftoverChar;
                off++; len--;
                haveLeftoverChar = false;
                n = 1;
                if ((len == 0) || !implReady())
                    // Return now if this is all we can produce w/o blocking
                    return n;
            }
            if (len == 1) {
                // Treat single-character array reads just like read()
                int c = read0();
                if (c == -1)
                    return (n == 0) ? -1 : n;
                cbuf[off] = (char)c;
                return n + 1;
            }
            return n + implRead(cbuf, off, off + len);
        }
}

关键部分:

int c = read0();
if (c == -1){
  return (n == 0) ? -1 : n;
}
cbuf[off] = (char) c;

上文中提及到read0()是读取一个字节,然后把字节转换成字符。
ok,那么我们就知道原理了。
实践一下吧:

public void readFile() throws IOException {
    try (Reader reader = new FileReader("xxxx")) {
        char[] buffer = new char[1000];
        int n;
        while ((n = reader.read(buffer)) != -1) {
        }
    }
}

CharArrayReader与StringReader

简单说明一下他们俩吧。

char[] test={'a','b'};
try (Reader reader = new CharArrayReader(test)) {
}
try (Reader reader = new StringReader("xxx")) {
}

就是把字符数组或者字符串专成了Reader。
以CharArrayReader为例:

  1. 继承:
    public class CharArrayReader extends Reader
  2. 实例化
public CharArrayReader(char buf[]) {
    this.buf = buf;
    this.pos = 0;
    this.count = buf.length;
}
  1. 读取
public int read() throws IOException {
    synchronized (lock) {
        ensureOpen();
        if (pos >= count)
            return -1;
        else
            return buf[pos++];
    }
}

就是模拟了假如全部的读取文件中的所有数据,然后转换成了char[],缓存起来。

总结

1.不管是一次性读取byte[]还是一个一个读byte,原理上都是一个一个读的,只是byte[] 存储起来了。
2.读取字符流其实是在读取字节后转换的。
3.避免忘记close,推荐使用try(){}这种语法。
4.对于像ByteArrayInputStream 这样的转换,其实是假设数据全部读取出来了,然后进行操作。

加载全部内容

相关教程
猜你喜欢
用户评论