Java IO 流

IO介绍

什么是IO流

Java中提供了IO接口,主要用于读写,输入输出操作。IO是以流为基础进行操作的,流相当于是连续的
数据流。可以从数据流中读取数据,也可以往流中写数据。

Java IO 流_第1张图片

IO分类

  • 按流向分:输入流和输出流
  • 按数据类型分:字节流和字符流
  • 按功能类型分:管道流、文件流、数组流、缓冲流、对象流、转换流、基本数据类型流
  • 按照角色类型:节点流和处理流

    • 节点流:从源直接读取数据
    • 处理流:对一个已经存在的流连接和封装,通过所封装的流的功能读写数据,处理流的构造方法都有一个 节点流参数

Java IO 流_第2张图片

IO的设计模式

javaIO中有两个设计模式:装饰者模式适配器模式

  • 装饰者模式

    给一个对象增加一个些新的功能,而且是动态的,要求装饰对象和被装饰对象实现同一个接口,处理流装饰节点流。

  • 适配器模式

    适配器负责将一个类的接口转换成另外一个接口,一般是指节点流,比如StringReader继承了Reader同时有一个String对象,将String对象的接口适配成Reader类型的接口。在调用Readerread()方法,实际上是在调用String对象的方法。

IO体系

IO流的顶层抽象类可以分为四种:字节输入流InputStream,字节输出流OutputStream,字符输入流Reader,字符输出流Writer

字节输入流

概述

字节输入流InputStream是一个抽象类,用于字节的输入。字节输入流可以读取一个字节或者一个字节数组。字节输入流读取字节之后,返回的是字节的ASCII码,如果读取的是字节数组,就将字节的ASCII存放到数组当中,然后返回字节数组的长度。

public abstract class InputStream implements Closeable

实现类

Java IO 流_第3张图片

方法

/**
 * 从数据流中读取一个字节数据,返回的是字节的ASCII码
 */
public abstract int read();

/**
 * 从数据流中读取一个字节数组长度的字节数据,并将字节数据放到字节数组中,返回读取的字节数据个数
 */
public int read(byte b[]);

/**
 * 从数据流中读取len长度的字节数据,并从字节数组的off位置开始放数据,返回读取的字节数据个数
 */
public int read(byte b[], int off, int len);

/**
 * 从数据流中跳过n长度的字节
 */
public long skip(long n);

/**
 * 在不阻塞的情况下数据流中有多少个字节可以读取
 */
public int available();

字节输出流

概述

字节输出流OutputStream是一个抽象类,用于输出字节数据,它实现了Flushable接口,用于刷新流,但是flush并不是强制的,而是针对有缓冲区的。

public abstract class OutputStream implements Closeable, Flushable

实现类

Java IO 流_第4张图片

方法

/**
 * 向数据流中写一个字节数据
 */
public abtract void write(int b);

/**
 * 向数据流中写一个字节数组的字节数据
 */
public void write(byte b[]);

/**
 * 向数据流中写一个字节数组的字节数据,从字节数组off位置开始,len长度
 */
public void write(byte b[], int off, int len);

字符输入流

概述

字符输入流Reader是一个抽象类,用于读取字符。

public abstract class Reader implements Readable, Closeable

实现类

Java IO 流_第5张图片

方法

/**
 * 用于同步此流上的操作对象
 */
protected Object lock;

/**
 * 空构造方法,同步锁是当前流对象
 */
protected Reader();

/**
 * 构造方法,指定对象为同步锁
 */
protected Reader(Object lock);

/**
 * 读取一个字符,并返回ascii码
 */
public int read();

/**
 * 读取一个字符数组,并返回字符数组的长度
 */
public int read(char cbuf[]);

/**
 * 读取len长度的字符,并从字符数组的off位置处放到字符数组中
 */
abstract public int read(char cbuf[], int off, int len);

/**
 * 在字符流中标记一个位置
 */
public void mark(int readAheadLimit);

/**
 * 回到mark的位置
 */
public void reset();

字符输出流

概述

字符输出流Writer是一个抽象类,用于写字符,它实现了Appendable用于追加字符。

public abstract class Writer implements Appendable, Closeable, Flushable

实现类

Java IO 流_第6张图片

方法

/**
 * 往字符数组中写一个ascii码表示的字符
 */ 
public void write(int c);

/**
 * 把cbuf中的元素写到字符数组中
 */ 
public void write(char cbuf[]);

/**
 * 从字符数组cbuf的off位置开始,写len长度到字符数组中
 */ 
abstract public void write(char cbuf[], int off, int len);

/**
 * 把字符串写入到字节数组中
 */ 
public void write(String str);

/**
 * 从字符串的off开始写len长度到字符数组中
 */ 
public void write(String str, int off, int len);

/**
 * 把字符序列csq加到字符数组元素的末尾
 */ 
public Writer append(CharSequence csq);

/**
 * 从字符序列start到end位置的字符加到字符数组元素的末尾
 */ 
public Writer append(CharSequence csq, int start, int end);

/**
 * 把字符加到字符数组的末尾
 */ 
public Writer append(char c);

文件流

概述

文件流包含了字节文件流和字符文件流两种类型,其中字节文件流是节点流,字符文件流是处理流。

  • FileInputStream
  • FileOutputStream
  • FileReader
  • FileWriter

数据流向

字节文件流

字节流数据是从文件到输入输出程序。

Java IO 流_第7张图片

字符文件流

字符流数据是先流向字节流再流向字符流。

Java IO 流_第8张图片

源码解析

字节文件输入流

  • 构造方法

    字节输入流常用的构造方法有两种,能接受文件和字符串的参数,字符串构造也是创建一个文件。

// 字符串构造,也是创建一个文件
public FileInputStream(String name) throws FileNotFoundException {
    this(name != null ? new File(name) : null);
}
// 文件构造方法
public FileInputStream(File file) throws FileNotFoundException {
    String name = (file != null ? file.getPath() : null);
    // 创建一个文件描述符
    fd = new FileDescriptor();
       // 将文件描述符加入到otherPath集合中,释放的时候可以一起释放
    fd.attach(this);
    path = name;
    // 调用native的open方法
    open(name);
}
  • 读取数据

    读取数据是调用native方法读取数据,可以每次读取一个字节,也可以读取一个字节数组的数据

字节文件输出流

  • 构造方法

    字节输出常用的构造方法和字节输入类似,只不过是多了一个布尔类型的append参数,这个参数决定是在文件里面追加内容,还是从头开始写,默认是覆盖从头开始。

  • 写数据

    写数据也是调用的native方法,可以写一个字节的数据,也可以写一个字节数组的数据。除此之外写方法也有一个append参数,表示是追加写还是覆盖写。

FileDescriptor:是一个文件描述符,打开一个文件或者套接字,操作系统内核都会返回一个文件描述符,文件描述符有三个值:0-标准输入,1-标准输出,2-标准错误输出

字符文件输入流

字符文件输入流只有构造方法,对数据的操作是借助转换流InputStreamReader来完成的,字符输入流的构造方法是创建一个字节文件输入流

字符文件输出流

字符文件输出流只有构造方法,对数据的操作是借助转换流OutputStreamWriter来完成的,字符输出流的构造方法是创建一个字节文件输出流

示例

  • 字节文件流
/**
 * 字节输入流
 */
FileInputStream fis = new FileInputStream("./file");
byte[] bytes = new byte[2];
int len;
// 可以一次读取一个字节或者多个字节
while((len = fis.read(bytes)) != -1) {
    System.out.println(new String(bytes, 0, len));
}
fis.close();

/**
 * 字节输出流
 */
FileOutputStream fos = new FileOutputStream("./file");
fos.write("helloio".getBytes());
fos.close();

内存流

概述

内存流包含了字节数组流和字符数组流

  • ByteArrayInputStream
  • ByteArrayOutputStream
  • CharArrayReader
  • CharArrayWriter

数据流向

内存流是从内存到输入输出程序

Java IO 流_第9张图片

源码分析

字节数组输入流

  • 构造方法

    字节数组输入流有两个构造方法,初始化一个字节数组,同时可以指定字节数组的起始位置和长度

    // 初始化一个字节数组,读取的时候从0的位置开始读取
    public ByteArrayInputStream(byte buf[]) {
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
    }
    // 初始化一个字节数组,读取的时候从pos的位置开始读取
    public ByteArrayInputStream(byte buf[], int offset, int length) {
        this.buf = buf;
        this.pos = offset;
        this.count = Math.min(offset + length, buf.length);
        this.mark = offset;
    }
  • 读取数据

    读取数据可以每次读取一个字节,也可以读取一个字节数组,底层采用System.arraycopy方法将字节数组的数据复制到传入的字节数组中

字节数组输出流

  • 构造方法

    字节数组输出流构造方法主要是创建一个字节数组,可以指定字节输入的长度,不指定的时候默认是32.

    // 默认长度32
    public ByteArrayOutputStream() {
        this(32);
    }
    public ByteArrayOutputStream(int size) {
        buf = new byte[size];
    }
  • 数组扩容

    字节数组输入流,可以支持动态扩容,每次扩容为左移一位,相当于增加一倍。

  • 输出数据

    输出数据是将字节数据放到字节数组输出流的字节数组里面

字符数组输入流

  • 构造方法

    字符数组输入流构造方法创建一个字符数组

    public CharArrayReader(char buf[]) {
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
    }
  • 读取数据

    读取数据是返回字符数组中的元素

字符数组输出流

  • 构造方法

    创建一个指定长度的字符数组,默认是32位

    // 默认32位
    public CharArrayWriter() {
        this(32);
    }
    public CharArrayWriter(int initialSize) {
        buf = new char[initialSize];
    }
  • 输出数据

    输出数据就是将字符放到字符数组中

示例

字节数组内存流

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("helloid".getBytes(StandardCharsets.UTF_8));
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
int len;
while ((len = byteArrayInputStream.read()) != -1) {
    byteArrayOutputStream.write(len);
}
System.out.println(byteArrayOutputStream);

字符数组内存流

CharArrayReader charArrayReader = new CharArrayReader("helloio".toCharArray());
CharArrayWriter charArrayWriter = new CharArrayWriter();
int len;
while ((len = charArrayReader.read()) != -1) {
    charArrayWriter.write(len);
}
System.out.println(charArrayWriter);

缓冲流

概述

缓冲流包含了字节缓冲流和字符缓冲流

  • BufferedInputStream
  • BufferedOutputStream
  • BufferedReader
  • BufferedWriter

数据流向

字节缓冲流

字节缓冲流是处理流,是在节点流的基础上操作的

Java IO 流_第10张图片

字符缓冲流

字符缓冲流是处理流,是在节点流的基础上操作的

Java IO 流_第11张图片

源码解析

字节输入缓冲流

  • 变量

    // 字节数组的元素数量,范围是[0, buf.length]
    protected int count;
    
    // 下一个读取字符的索引,范围是[0, count]
    protected int pos;
    
    /**
     * 开启重复读取数据的变量
     */
    // 这个值是上次调用mark方法后pos的值,范围是[-1, pos]
    protected int markpos = -1;
    // 限制可重复度的最大长度
    protected int marklimit;
  • 构造方法

    字节输入缓冲流,在创建一个字节输入流对象的同时,也会初始化一个默认长度为8192的字节数组

    public BufferedInputStream(InputStream in) {
        this(in, 8192);
    }
    public BufferedInputStream(InputStream in, int size) {
        super(in);
        // 初始化一个字节数组
        buf = new byte[size];
    }
  • 读取数据

    public synchronized int read() throws IOException {
        // 当索引的位置大于字节数组的元素个数,相当于字节数组中的元素已经读取完了
        if (pos >= count) {
            // 从数据源中读取数据填充到字节数组中
            fill();
            if (pos >= count)
                return -1;
        }
        // 从字节数组中返回元素
        return getBufIfOpen()[pos++] & 0xff;
    }
    private void fill() throws IOException {
        // 获取字节数组对象
        byte[] buffer = getBufIfOpen();
        // 没有使用过mark标记,直接将pos指向字节数组的首位,就是将字节数组后面的元素直接丢弃
        if (markpos < 0)
            pos = 0;
        // 已经读取到字节数组的最大长度了,及pos已经指向字节数组的最后一个元素了
        else if (pos >= buffer.length) {
            // 调用过mark方法,将markpos位置开始的元素移动到前面,markpos前面的数据直接丢弃,后面的不           // 能丢弃所以要移动到前面
            if (markpos > 0) {
                int sz = pos - markpos;
                System.arraycopy(buffer, markpos, buffer, 0, sz);
                pos = sz;
                markpos = 0;
            // 因为:pos >= buffer.length, 这里相当于无效mark,因为已经重复读取过数据了
            } else if (buffer.length >= marklimit) {
                markpos = -1;   
                pos = 0; 
            // 字节数组不断扩容之后,已经达到最大了,抛出异常
            } else if (buffer.length >= MAX_BUFFER_SIZE) {
                throw new OutOfMemoryError("Required array size too large");
            } else {
                // 2倍的pos,MAX_BUFFER_SIZE 最小值作为新的字节数组的长度
                int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
                    pos * 2 : MAX_BUFFER_SIZE;
                // 如果比marklimit大,直接扩容到marklimit
                if (nsz > marklimit)
                    nsz = marklimit;
                byte nbuf[] = new byte[nsz];
                System.arraycopy(buffer, 0, nbuf, 0, pos);
                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                    
                    throw new IOException("Stream closed");
                }
                buffer = nbuf;
            }
        }
        count = pos;
        // 从文件中继续读取数据放到字节数组中
        int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
        if (n > 0)
            count = n + pos;
    }
  • 重复读取数据

    // 标记一下markPos的位置为现在pos的位置,并且设置可重复读的最大长度
    public synchronized void mark(int readlimit) {
        marklimit = readlimit;
        markpos = pos;
    }
    // 重置的时候将pos又还原到最开始的索引处
    public synchronized void reset() throws IOException {
        getBufIfOpen();
        if (markpos < 0)
            throw new IOException("Resetting to invalid mark");
        pos = markpos;
    }

字节输出缓冲流

  • 构造方法

    字节输出缓冲流的构造方法是创建一个字节输出流对象,同时维护一个8192长度的字节数组缓冲区

    public BufferedOutputStream(OutputStream out) {
        this(out, 8192);
    }
    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        buf = new byte[size];
    }
  • 写数据

    写数据是先写到字节数组中,如果字节数组的元素达到了字节数组的长度,就写到文件里面去

    public synchronized void write(int b) throws IOException {
        if (count >= buf.length) {
            flushBuffer();
        }
        buf[count++] = (byte)b;
    }
    public BufferedReader(Reader in, int sz) {
        super(in);
        this.in = in;
        cb = new char[sz];
        nextChar = nChars = 0;
    }

字符输入缓冲流

  • 构造方法

    字符缓冲流的构造方法和字节缓冲流类似,在创建一个流的同时,内部也维护了一个默认为8192长度的字符数组。

    public BufferedReader(Reader in) {
        this(in, 8192);
    }
    public BufferedReader(Reader in, int sz) {
        super(in);
        this.in = in;
        cb = new char[sz];
        nextChar = nChars = 0;
    }
  • 读数据

    读取数据是从字符数组中读取,读取完了之后从流中获取数据填充到字符数组中

    public int read() throws IOException {
        synchronized (lock) {
            ensureOpen();
            for (;;) {
                // 下一个要读取的 大于 字符数据中的元素个数,就填充数据
                if (nextChar >= nChars) {
                    fill();
                    if (nextChar >= nChars)
                        return -1;
                }
                if (skipLF) {
                    skipLF = false;
                    if (cb[nextChar] == '\n') {
                        nextChar++;
                        continue;
                    }
                }
                return cb[nextChar++];
            }
        }
    }
    private void fill() throws IOException {
        int dst;
        if (markedChar <= UNMARKED) {
            // 未调用mark方法,直接舍弃数据,读取数据的指针索引指向字符数组第一位
            dst = 0;
        } else {
            int delta = nextChar - markedChar;
            // 标记的数据已经读取过了,直接舍弃字符数组的数据
            if (delta >= readAheadLimit) {
                /* Gone past read-ahead limit: Invalidate mark */
                markedChar = INVALIDATED;
                readAheadLimit = 0;
                dst = 0;
            } else {
                if (readAheadLimit <= cb.length) {
                    // 将要读取的位置到标记的位置的字符串,这是没有读取的,移动到前面
                    System.arraycopy(cb, markedChar, cb, 0, delta);
                    markedChar = 0;
                    dst = delta;
                } else {
                    // 标记位置大于缓冲区大小,重新调整缓冲区大小,并将将要读取的位置到标记位置的
                    // 字符串移动到前面
                    char ncb[] = new char[readAheadLimit];
                    System.arraycopy(cb, markedChar, ncb, 0, delta);
                    cb = ncb;
                    markedChar = 0;
                    dst = delta;
                }
                nextChar = nChars = delta;
            }
        }
        // 读取数据放到字符数组中
        int n;
        do {
            n = in.read(cb, dst, cb.length - dst);
        } while (n == 0);
        // 有读取到数据,重新设置将要读取的索引和字符数组中元素的个数
        if (n > 0) {
            nChars = dst + n;
            nextChar = dst;
        }
    }

字符输出缓冲流

  • 构造方法

    字符输出缓冲流构造方法是新建一个输出流和一个字符缓冲数组

    public BufferedWriter(Writer out) {
        this(out, 8192);
    }
    public BufferedWriter(Writer out, int sz) {
        super(out);
        this.out = out;
        cb = new char[sz];
        nChars = sz;
        nextChar = 0;
    }
  • 写数据

    写输入是先往字符数组中写,字符数组满了之后往流里面写

示例

字节缓冲流

/**
 * 字节输入缓冲流
 */
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("./file"));
int len;
while ((len = bufferedInputStream.read()) != -1) {
    System.out.println((char) len);
}
/**
 * 字节输出缓冲流
 */
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("./file"));
bufferedOutputStream.write(97);
bufferedOutputStream.flush();
bufferedOutputStream.close();

字符缓冲流

/**
 * 字符输入缓冲流
 */
BufferedReader bufferedReader = new BufferedReader(new FileReader("./file"));
String str;
while ((str = bufferedReader.readLine()) != null) {
    System.out.println(str);
}
bufferedReader.close();
/**
 * 字符输出缓冲流
 */
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("./file"));
bufferedWriter.write("helloio");
bufferedWriter.flush();
bufferedWriter.close();

对象流

概述

对象流主要是用于序列化对象,包含了对象输入流ObjectInputStream和对象输出流ObjectOutputStream

数据流向

Java IO 流_第12张图片

示例

/**
 * 对象输入流
 */
ObjectOutputStream  objectOutputStream = new ObjectOutputStream (new FileOutputStream("./file"));
User user = new User("helloobject");
objectOutputStream.writeObject(user);
objectOutputStream.flush();
objectOutputStream.close();

/**
 * 对象输出流
 */
ObjectInputStream  objectInputStream = new ObjectInputStream (new FileInputStream("./file"));
User user = (User)objectInputStream.readObject();
System.out.println(JSONObject.toJSONString(user));
objectInputStream.close();

/**
 * 对象
 */
class User implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    public User(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

转换流

概述

转换流是将字节和字符相互转换

  • InputStreamReader
  • OutputStreamRead

数据流向

Java IO 流_第13张图片

示例

/**
 * 转换输入流
 */
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("./file"));
int len;
while ((len = inputStreamReader.read()) != -1) {
    System.out.println((char) len);
}

/**
 * 转换输出流
 */
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("./file"));
outputStreamWriter.write("helloio");
outputStreamWriter.flush();
outputStreamWriter.close();

你可能感兴趣的:(java)