Io流

概述：

I：Input 表示输入：从其他存储设备读取数据到内存中

O：Output表示输出：从内存中写出数据到其他存储设备中

IO的分类

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从其他设备上读取到内存中的流。

  • 字节输入流:以字节为基本单位,读数据

  • 字符输入流:以字符为基本单位,读数据

• 输出流 ：把数据从内存 中写出到其他设备上的流。

  • 字节输出流:以字节为基本单位,写出数据

  • 字符输出流:以字符为基本单位,写出数据

根据数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流。

  • 字节输入流:以字节为基本单位,读数据

  • 字节输出流:以字节为基本单位,写出数据

• 字符流 ：以字符为单位，读写数据的流。

  • 字符输入流:以字符为基本单位,读数据

  • 字符输出流:以字符为基本单位,写出数据

IO的顶层父类

• 字节输入流:顶层父类 InputStream 抽象类

• 字节输出流:顶层父类 OutputStream 抽象类

• 字符输入流:顶层父类 Reader 抽象类

• 字符输出流:顶层父类 Writer 抽象类

注意事项

• utf8编码一个中文占3个字节,gbk编码一个中文占2个字节

• 如果存储和解析的编码不一致就会乱码

• idea默认编码是utf8

 字节流：

字节输出流：（OutputStream）超类

将指定的字节信息写到目的地

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

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

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

• public abstract void write(int b) ：将指定的字节输出流。

 字节输入流：(InputStream)超类

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

• public abstract int read()： 从输入流读取数据的下一个字节。

• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

package zw.Demo02字节流;

import java.io.*;

/**
 * zw
 * https://www.cnblogs.com/YwhsR0129/
 * 2020/9/20,19:17
 */

public class Test1 extends Exception {
    public static void main(String[] args) throws IOException {
        //创建字节流对象，关联文件
        FileOutputStream f1 = new FileOutputStream("Demo12\aaa\a.txt");
        //字节流一次读写一个字节拷贝文件
        //写
        f1.write(97);
        f1.write(98);
        f1.write(99);
        f1.close();//关闭

        //字节流一次读写一组拷贝文件
        FileOutputStream f2 = new FileOutputStream("Demo12\aaa\b.txt");
        //写
        byte[] b = {97, 98, 99, 100, 101};
        f2.write(b);
        f2.close();

        //字符根据指定长度字节数组读拷贝文件
        FileOutputStream f3 = new FileOutputStream("Demo12\aaa\c.txt");
        byte[] bys = {97, 98, 99, 100};
        f3.write(bys, 1, 2);
        f3.close();

        //数据追加,在末尾加ture，就可以保留原来的数据，系统默认是false所以会清空原数据
        FileOutputStream f4 = new FileOutputStream("Demo12\aaa\c.txt", true);
        f4.write(99);
        f4.close();

        //字节流一次读写一个字节拷贝文件
        //读
        FileInputStream f5 = new FileInputStream("Demo12\aaa\a.txt");
        System.out.println(f5.read());
        f5.close();
        //循环
        FileInputStream f6 = new FileInputStream("Demo12\aaa\b.txt");
        int i;
        while ((i = f6.read()) != -1) {
            System.out.println(i);
        }
        f6.close();

        //字节流一次读一组拷贝文件
        FileInputStream f7 = new FileInputStream("Demo12\aaa\c.txt");
        int j;
        byte[] by = new byte[2];
        while ((j = f7.read() )!= -1) {
            System.out.println(j);
        }
        f7.close();

        //将数组转成字符串
        FileInputStream f8 = new FileInputStream("Demo12\aaa\c.txt");
        byte[] n = new byte[2];
        int len1 = f8.read(n);
        System.out.println("f8数组转为字符串："+new String(n,0,len1));
        f8.close();
        
    }
}

字符流：

 当使用字节流的读取文件的时候，如果遇到中文字符可能就不会显示完整的字符，因为中文字符会占多个字符，所以我们可以使用字符流。

字符输入流（Reader）

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

• public int read()： 从输入流读取一个字符。

• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

 字符输出流：（Writer）

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

• public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。

• public void write(int c) ：写出一个字符。

• public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。

• public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。

• public void write(String str) ：写出一个字符串。

• public void write(String str,int off,int len) ：写出一个字符串的一部分。

package zw.Demo03字符流;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * zw
 * https://www.cnblogs.com/YwhsR0129/
 * 2020/9/21,9:29
 */
public class Test extends Exception{
    public static void main(String[] args) throws IOException {
        //通过循环一次获取一个字符
        FileReader f1 = new FileReader("Demo12\aaa\a.txt");
        int b;
        while ((b = f1.read()) != -1) {
            System.out.println((char)b);

        }
        f1.close();
        //通过数组，一次获取一组字符
        FileReader f2 = new FileReader("Demo12\aaa\a.txt");
        int a;
        char[] i = new char[2];
        while ((a = f2.read(i)) != -1) {
            System.out.println(new String(i,0,a));
            //System.out.println(new String(i));如果后面的字符不够双数，那么就会重复输出最后面的字符
        }
        f2.close();

        //每次写出一个字符数据
        FileWriter f3 = new FileWriter("Demo12\aaa\b.txt");
        f3.write('a');
        f3.write('c');
        f3.write('a');
        f3.write('b');
        f3.close();

        //每次写出一组字符数据
        FileWriter f4 = new FileWriter("Demo12\aaa\c.txt");
        int m;
        //将字符转成数组
        char[]chars="打野李白抢野".toCharArray();
        //写入字符数组
        f4.write(chars);
        //写出从索引2开始，2个字节，索引是‘李’，两个字节，就是‘李白’
        f4.write(chars, 2, 2);
        f4.close();

        //直接写入字符串数据
        FileWriter f5 = new FileWriter("Demo12\aaa\d.txt");
        String msg = "打野李白抢野";
        //写出数组
        f5.write(msg);
        //写出从索引2开始，2个字节，索引是‘李’，两个字节，就是‘李白’
        f5.write(msg, 2, 2);
        f5.close();

        //续写和换行操作
        FileWriter f6 = new FileWriter("Demo12\aaa\d.txt", true);
        f6.write("
");
        f6.write('抢');
        int q;
        char []ca = "宫本".toCharArray();
        f6.write(ca);
        f6.write("
");
        f6.write("给力");
        f6.write("
");
        f6.close();

        //关闭和刷新
        FileWriter f7 = new FileWriter("Demo12\aaa\c.txt");
        f7.write("刷");
        f7.flush();
        f7.write("新");
        f7.close();

    }
}

注： 字符输出必须关闭流，因为字符的存储时按池的方式，不关闭不会写进去

         字节流可以拷贝一切文件，字符流只能拷贝文本文件