IO流-字节流，字符流随笔

IO流

IO流用来处理设备之间的数据传输，如上传文件和下载文件,文件的读取写入等操作

概述

Java对数据的操作是通过流的方式,Java用于操作流的对象都在IO包中

按照数据流向：

• 输入流 读入数据 从操作系统上读入文件到内存中
• 输出流 写出数据 就是将文件从编译器中编写到操作系统上

按照数据类型：

• 字节流 由于我们的文件存储的基本单元都是字节，所以这个很早出现了
• 字符流 为了方便处理某些数据，则出现字符流

如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流，否则用字节流。如果不知道是什么文件，就用字节流。

字节流：

字节输入流：

• InputStream
• FileInputStream

    //InputStream是最基础的字节输入流的接口
    //FileInputStream是最基础的文件操作字节输入流对象
    /*使用try-catch进行捕获异常
    1、声明输入流对象
    2、定义每次读入的字节数大小
    3、每次读取一个字节数组的大小，读取的内容都在字节数组中，直到字节数组返回的大小等于-1，则表示已经读取完毕
    4、必须关闭输入流
    */
     try(FileInputStream fis = new FileInputStream(READ_FILE_PATH)){
                byte[] bytes = new byte[1024];
                while (fis.read(bytes) != -1) {
                    String str = new String(bytes);
                    System.out.println(str);
                }
                fis.close();
            }

字节缓冲输入流：

BufferedInputStream
成员方法：

int read() 一次读取一个字节
int read(byte [] bytes) 一次读取一个字节数组

    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(READ_FILE_PATH))) {
                byte[] bytes = new byte[1024];
                while (bis.read(bytes) != -1) {
                    String str = new String(bytes);
                    System.out.println(str);
                }
                bis.close();
            }

字节输出流：

OutputStream
FileOutStream

    /*输出流的构造方法可以定义是否续写
    即new FileOutputStream(WRITE_FILE_PATH,true);支持续写，不会覆盖之前文件中的内容
    */
    //定义当前系统下的换行符
      public static final String LINE_SEPARATOR = System.getProperty("line.separator");
      try (FileOutputStream fos = new FileOutputStream(WRITE_FILE_PATH)) {
                for (int i = 0; i < 100; i++) {
                    String s = "HELLO" + (int) (Math.random() * 100 + 1) + LINE_SEPARATOR;
                    fos.write(s.getBytes());
                }
                fos.close();
            }

字节缓冲输出流：

BufferedOutputStream

成员方法：

void write() 一次写入一个字节
void write(byte [] bytes , int off , int len) 一次写入一个字节数组，从off开始，长度为len

    /*
    缓冲输出流必须使用flush()方法将缓冲区中的数据强制输出完
    */
    try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(WRITE_FILE_PATH))) {
                for (int i = 0 ; i < 10000000 ; i++) {
                    String str = i + "";
                    bos.write(str.getBytes(Charset.forName("UTF-8")));
                    bos.flush();
                }
            }

缓冲流仅仅只是对字节流的优化，所以最好的定义方式是传递一个输入流/输出流对象

字节数组输入流/输出流

字节数组输入流

• ByteArrayInputStream

    public String readFromArray(byte[] bytes) {
            StringBuffer sb = new StringBuffer();
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            int tmp;
            while ((tmp = bais.read()) != -1) {
                sb.append(Integer.toHexString(tmp));
            }
            return sb.toString();
        }
    
        public void readMarkAndReset(byte[] bytes,int mark) {
            StringBuffer sb = new StringBuffer();
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            bais.mark(mark);
    
            bais.skip(mark + 1);
            int tmp;
            while ((tmp = bais.read()) != -1) {
                sb.append(Integer.toHexString(tmp));
            }
    
            System.out.println("越过标记后的字符串");
            System.out.println(sb.toString());
    
            bais.reset();
            sb.setLength(0);
    
            int m;
            while ((m = bais.read()) != -1) {
                sb.append(Integer.toHexString(m));
            }
    
            System.out.println("重置之后的字符串");
            System.out.println(sb.toString());
        }
    

字节数组/输出流

• ByteArrayOutputStream

    try (InputStream is = new FileInputStream("D://read_file.txt")) {
                ByteArrayOutputStream output = new ByteArrayOutputStream();
                byte[] bytes = new byte[1024];
                while (is.read(bytes) != -1) {
                    output.write(bytes);
                }
    
                String data = output.toString("UTF-8");
                System.out.println(data);
    
            }

字符流（转换流）：

字符流 = 字节流 + 编码集

字符输入流：

• Reader
• FileReader

/*
1、定义FileReader()对象
2、定义字符数组
3、读取数组大小的内容
4、返回的读取长度为-1表示读完
*/
try (FileReader reader = new FileReader(READ_FILE_PATH)) {
          char[] chars = new char[1024];
          while (reader.read(chars) != -1) {
              System.out.println(chars);
          }
      }

• InputStreamReader

    /*
    定义InputStreamReader对象，传递一个FileInputStream对象作为参数
    */
     try (Reader reader = new InputStreamReader(new FileInputStream(READ_FILE_PATH))) {
                char[] chars = new char[1024];
                while (reader.read(chars) != -1){
                    System.out.print(new String(chars));
                }
            }

字符缓冲输入流：

• BufferedReader:

特殊用法：

String readLine() 一次读取一行数据，但不包括换行符【\n】

    try(BufferedReader reader = new BufferedReader(new FileReader(READ_FILE_PATH))){
                String str;
                while ((str = reader.readLine()) != null) {
                    System.out.println(str);
                }
            }

字符输出流：

• Writer
• FileWriter

     try (FileWriter writer = new FileWriter(WRITE_FILE_PATH)) {
                for (int i = 0 ; i< 1000000;i++) {
                    writer.write("我是byhieg");
                }
            }

• OutputStreamWriter

    try (Writer writer = new OutputStreamWriter(new FileOutputStream(WRITE_FILE_PATH))) {
                for (int i = 0 ; i < 100;i++) {
                    writer.write("我是中国人" +Math.random()*100+1);
                    writer.write("\r\n");
                }
                System.out.println("输出流");
            }

字符缓冲输出流：

• BufferedWriter:

特殊用法:

void newLine() 写入一个行分隔符【\n】，适用于各个系统

    try (BufferedWriter bw = new BufferedWriter(new FileWriter(READ_FILE_PATH))) {
                for (int i = 0 ;i < 100000;i++) {
                    String str = "asd";
                    bw.write(str);
                }
            }