Java BIO

BIO

目录

• BIO
  • 字节流
    • OutputStream
      • FileOutputStream
    • InputStream
      • FileInputStream
  • 字符流
    • Reader
      • FileReader
    • Writer
      • FileWriter
  • 转换流
    • InputStreamReader
    • OutputStreamWriter

IO：input/output

input：从磁盘读到内存

output：从内存存到磁盘

Java中IO分为：字节流和字符流

字节流

一切文件数据在存储时，都是以二进制数字的形式保存

OutputStream

所有的输出流都继承自java.io.OutputStream类，OutputStream是一个抽象类直接继承Java.lang.Object超类

已知直接子类：ByteArrayOutputStream ， FileOutputStream ， FilterOutputStream ， ObjectOutputStream ， OutputStream ， PipedOutputStream

• 公共方法：

void close() 关闭此输出流并释放与此流相关联的任何系统资源。

void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。

void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。

void write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。

abstract void write(int b) 将指定的字节写入此输出流。

FileOutputStream

FileOutputStream文件字节输出流，作用就是将内存中的数据写入磁盘文件

• 构造方法

FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。

FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。如果append为true则在文件末尾写入

FileOutputStream(FileDescriptor fdObj) 创建文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有连接。

FileOutputStream(String name) 创建文件输出流以指定的名称即路径中写入文件。

FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称即路径中写入文件。

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class IO_FileOutputStream {

    FileOutputStream FOS = null;

    /**
     * FOS使用：
     *     1.创建FOS，并传入String path 输出路径，如果路径不存在，文件无法打开等就会抛出FIleNotFoundException
     *     2.FOS.write() 写入数据
     *     3.关闭资源
     * @param path
     * @throws IOException
     */
    void fos( String path ) throws IOException {
        FOS = new FileOutputStream(path);
        //输出结果97--a，因为是以字节输出的
        FOS.write(97);

        /**
         * FOS输入都是字节byte型(-128~127之间），当第一个是负数时则会和后面一个数一起组成一个中文编码默认GBK,GBK-2字节-1中文；UTF-3-1中文
         */
        byte[] bytes = new byte[]{12, 3, 34, 48, 49,126};
        FOS.write(bytes);
        FOS.write(10);//10就是换行符

        /**
         *  换行win：\r\n
         *  linux：/n
         *  ma：/r
        */

        FOS.write("\r\n".getBytes());

        /**
         * 从byte数字的第off位开始读入长度len的byte数据写入
         *
         */
        FOS.write(bytes, 1, 2);
        FOS.write(10);//10就是换行符

        /**
         * 如果是字符串，可以使用String的 byte[] getBytes()方法来转换成byte数组
         */
        byte[] bytes1 = "Hello".getBytes();
        System.out.println(Arrays.toString(bytes1));
        FOS.write(bytes1);

        FOS.close();
    }

    public static void main( String[] args ) throws IOException {
        IO_FileOutputStream fos = new IO_FileOutputStream();
        fos.fos("./src/JavaCore/IO/FOS.txt");
    }
}

InputStream

java.io.InputStream所有输入流的顶层类

方法：

int read()----读取一个字节，返回0到65535（ 0x00-0xffff ）范围内的整数

回，每读取一个指针就往后移一位，如果到达末尾则返回-1

int read(byte[] b)----从输入流中读取一些字节并缓存到b中，到达末尾返回-1，并返回缓冲区b的总字节数

int read(byte[] b,int off,int len)----

void close()----关闭流并释放与流关联的任何系统资源

FileInputStream

与FileOutputStream相对，FileInoutStream将硬盘中的数据读入内存

构造方法

FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

FileInputStream(FileDescriptor fdObj) 创建 FileInputStream通过使用文件描述符 fdObj ，其表示在文件系统中的现有连接到一个实际的文件。

FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

public class IO_FileInputStream {

    FileInputStream FIS = null;

    /**
     * FIS使用：read()
     * 1.新建FIS对象
     * 2.read
     * 3.close
     * @param path
     * @throws IOException
     */
    void fis( String path ) throws IOException {
        FIS = new FileInputStream(path);

        int len;
        while ((len = FIS.read()) != -1) {
            System.out.print((char)len);
        }

        FIS.close();
        System.out.println();
        System.out.println("-------------------------");
        /**
         * 注意循环不能写成下面这样，因为在read时每读取一个指针就会自动往后移，这样读就会跳过很多数据，导致读取不完全
         */
        FileInputStream fis = new FileInputStream("./src/JavaCore/IO/FIS.txt");
        while (fis.read() != -1) {
            System.out.print((char)fis.read());
        }
        fis.close();
    }

    /**
     * 使用byte[]来缓存读取到的字节，int read(byte[])返回的就是读取到的有效字节长度
     * @param path
     * @throws IOException
     */
    void fis_arrayBuff( String path ) throws IOException {
        FIS = new FileInputStream(path);
        byte[] bytes = new byte[1024];
        int len;
        while ((len = FIS.read(bytes)) != -1) {
            //String的构造方法中可以传入一个byte来生成，这里指定了开始位和长度，不然后面会有许多空格，因为1024长度的byte，
            //len长度之后的都是0
            System.out.println(new String(bytes, 0, len));
        }
    }

    public static void main( String[] args ) throws IOException {
        IO_FileInputStream iofis = new IO_FileInputStream();
        iofis.fis_arrayBuff("./src/JavaCore/IO/FIS.txt");

    }
}

字符流

Reader

public abstract class Reader extends Object----所有字符输入流的顶层类

直接的子类：

BufferedReader ， CharArrayReader ， FilterReader ， InputStreamReader ， PipedReader ， StringReader

共有方法：

abstract void close() -----关闭流并释放与之相关联的任何系统资源。

void mark(int readAheadLimit) ------标记流中的当前位置。

boolean markSupported() ----------告诉这个流是否支持mark（）操作。

int read() ---------------读一个字符 返回0到65535（ 0x00-0xffff ）范围内的整数，如果已经达到流的末尾，则为-1

int read(char[] cbuf) ----将字符读入数组cbuf 返回读取的字符数，如果已经达到流的结尾，则为-1

abstract int read(char[] cbuf, int off, int len) ---------将字符读入数组的一部分。

int read(CharBuffer target) ------------- 尝试将字符读入指定的字符缓冲区。

boolean ready() -------------告诉这个流是否准备好被读取。

FileReader

FileReader是用于读取字符流,继承关系：java.lang.Object <-java.io.Reader <-java.io.InputStreamReader <-java.io.FileReader

示例：

public static void main( String[] args ) throws IOException {

        FileReader fr = new FileReader("./src/JavaCore/IO/FOS.txt");

        /**
         * 读取单个字符
         */
//        int len;
//        while ((len = fr.read()) != -1) {
//            System.out.print((char) len);
//        }

        /**
         * 读取多个字符
         */
        char[] cs = new char[1024];
        int len;
        while ((len = fr.read(cs)) != -1) {

            System.out.println(new String(cs,0,len ));
        }

        fr.close();
    }

Writer

public abstract class Writer extends Object implements Appendable, Closeable, Flushable

Writer用于写入字符流的抽象类,是所有输出字符流的父类。 子类必须实现的唯一方法是write（char []，int，int），flush（）和close（）。 然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率，附加的功能或两者

Writer append(char c)

将指定的字符附加到此作者。

Writer append(CharSequence csq)

将指定的字符序列附加到此作者。

Writer append(CharSequence csq, int start, int end)

将指定字符序列的子序列附加到此作者。

abstract void close()

关闭流，先刷新。

abstract void flush()

刷新流。

void write(char[] cbuf)

写入一个字符数组。

abstract void write(char[] cbuf, int off, int len)

写入字符数组的一部分。

void write(int c)

写一个字符

void write(String str)

写一个字符串

void write(String str, int off, int len)

写一个字符串的一部分。

FileWriter

FileWriter的继承关系：

java.lang.Object

java.io.Writer

java.io.OutputStreamWriter

java.io.FileWriter

构造方法：

FileWriter(File file)给一个File对象构造一个FileWriter对象。

FileWriter(File file, boolean append)给一个File对象构造一个FileWriter对象。append为true时则在文件末尾输入

FileWriter(FileDescriptor fd)构造与文件描述符关联的FileWriter对象。

FileWriter(String fileName)构造一个给定文件名的FileWriter对象。

FileWriter(String fileName, boolean append)构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。

构造方法的作用：

1.创建一个FileWriter对象

2.会根据构造方法中传递的文件路径，创建文件

3.将FileWriter指向创建好的文件

字符流的使用：---字符和字节输入流的区别在于，字符不是直接写入文件，而是先写入内存缓冲区

1.创建FileWriter对象，在构造方法中绑定要写入的数据目的地

2.使用 FileWriter中的write()方法，把数据写入内存缓冲区（在这一步，其实会将字符转换为字节因为计算机只认识字节）

3.使用FileWriter中的flush()方法将内存缓冲区的数据，刷新到文件中

4.释放资源（在释放资源时，会自动把内存缓冲区的数据刷新到文件）

public static void main( String[] args ) throws IOException {
        //创建输出流对象
        FileWriter fw = new FileWriter("./src/JavaCore/IO/FOS.txt", true);
        //创建输入流对象
        FileReader fr = new FileReader("./src/JavaCore/IO/FIS.txt");

        //读取输入流并输出到输出流
        char[] cs = new char[1024];
        int len;
        while ((len = fr.read(cs)) != -1) {

            fw.write(new String(cs, 0, len));
            //这里要刷新流，不然字符输出流不会写入文件，而是留在内存缓冲区中
            fw.flush();
        }

        //关闭流，先关闭输出流，再关闭输入流，因为输出流要依赖输入流，所以要后关闭输入流
        fw.close();
        fr.close();
    }

转换流

从字节流到字符流的转化，在字符流FileReader中的构造方法中仍然是继承了字节流

public FileReader(String fileName) throws FileNotFoundException {    super(new FileInputStream(fileName)); }

InputStreamReader

java.lang.Object java.io.Reader java.io.InputStreamReader

InputStreamReader是从字节流到字符流的桥梁：它读取字节，并使用指定的charset将其解码为字符 。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

每个调用InputStreamReader的read（）方法之一可能会导致从底层字节输入流读取一个或多个字节。 为了使字节有效地转换为字符，可以从底层流读取比满足当前读取操作所需的更多字节。

为了最大的效率，请考虑在BufferedReader中包装一个InputStreamReader。 例如： BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

构造方法：

InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader。

InputStreamReader(InputStream in, Charset cs)创建一个使用给定字符集的InputStreamReader。

InputStreamReader(InputStream in, CharsetDecoder dec)创建一个使用给定字符集解码器的InputStreamReader。

InputStreamReader(InputStream in, String charsetName)创建一个使用命名字符集的InputStreamReader。

对象方法：和Reader一致

OutputStreamWriter

public class OutputStreamWriter extends WriterOutputStreamWriter是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节charset 。

使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。每次调用write（）方法都会使编码转换器在给定字符上被调用。 所得到的字节在写入底层输出流之前累积在缓冲区中。 可以指定此缓冲区的大小，但是默认情况下它大部分用于大多数目的。 请注意，传递给write（）方法的字符不会缓冲。

为了最大的效率，请考虑在BufferedWriter中包装一个OutputStreamWriter，以避免频繁的转换器调用。 例如： Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

构造方法：

OutputStreamWriter(OutputStream out)创建一个使用默认字符编码的OutputStreamWriter。

OutputStreamWriter(OutputStream out, Charset cs)创建一个使用给定字符集的OutputStreamWriter。

OutputStreamWriter(OutputStream out, CharsetEncoder enc)创建一个使用给定字符集编码器的OutputStreamWriter。

OutputStreamWriter(OutputStream out, String charsetName)创建一个使用命名字符集的OutputStreamWriter。

对象方法：和Writer一致

本博客为Swagger-Ranger的笔记分享，文章会持续更新

文中源码地址： https://github.com/Swagger-Ranger

欢迎交流指正，如有侵权请联系作者确认删除： liufei32@outlook.com