IO流——字节流、字符流

在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。

流的分类

①   流按其流向分为“输入流”和“输出流”。

②   流按数据传输单位分为“字节流”和“字符流”。

　　a) “字节流”用来读写8位二进制的字节。

　　b)“字符流”用来读写16位二进制字符。

③   流按功能分为“节点流”和“过滤流”。

　　a) “节点流”用于直接操作目标设备的流。例如：磁盘或一块内存区域。

　　b) “过滤流”是对一个已存在的流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能。

一、字节流

1、字节输出流OutputStream

OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。

输出流中定义都是写write方法：

write(byte[] b,int off,int len)方法，b表示要写入的字符数组，off表示开始写入的数组下标，len表示写入长度

1.1、FileOutputStream类、文件输出流

FileOutputStream是OutputStream的子类，可用来写入数据到文件。

构造方法：

可直接创建一个File类，也可创建String字符串，文件路径

例：

//需求：将数据写入到文件中。
public static void main(String[] args) throws IOException {
//创建存储数据的文件。
  File file = new File("c:\\file.txt");
  //创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
  //输出流目的是文件，文件不存在，会自动创建。如果文件存在，则覆盖。
  FileOutputStream fos = new FileOutputStream(file);
　//填入字符串地址
　//FileOutputStream fos = new FileOutputStream("c:\\file.txt");
     //调用父类中的write方法。
//字符串String 的getBytes()方法，将字符串转换成字符数组
    byte[] data = "abcde".getBytes();
    fos.write(data);
        //关闭流资源。
        fos.close();
    }

1.2、给文件中续写和换行

当我们直接new FileOutputStream(file)这样创建对象，写入数据时，会覆盖原有的文件，

如果我们只想在原有文件中续写呢？

FileOutputStream的另一构造方法：

在创建对象时，在后面加一个布尔值append,当为true时，会在文件末尾继续添加

 换行符："\r\n"

在要写入的字符串前后加入换行符，文件内会换行

例：

public static void main(String[] args) throws Exception {
//明确目标文件
        File file = new File("c:\\file.txt");
        FileOutputStream fos = new FileOutputStream(file, true);
//在"aaa"前添加换行符
        String str = "\r\n"+"aaa";
        fos.write(str.getBytes());
//关闭资源流
        fos.close();
    }

1.3、IO的异常处理

在实际开发中，io异常的处理

public class IODemo {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try{
            //明确目标文件
            fos=new FileOutputStream("e:\\test\\demo.txt");
            //写入字符
            fos.write(100);
        }catch(IOException ex){
            ex.printStackTrace();
            throw new RuntimeException("文件写入失败");

        }finally{
            //关闭资源，全部放在finally中
            try {
                if(fos!=null)
                //关闭资源流异常处理
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException("文件写入失败");
            }
        }
    }
}

2、字节输入流 InputStream

InputStream此抽象类，是表示字节输入流的所有类的超类。，定义了字节输入流的基本共性功能方法。

定义了字节输入流的基本共性功能方法。

read():读取一个字节并返回，没有字节返回-1.

read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。

2.1 、FileInputStream类

FileInputStream是InputStream的子类，可用来读取文件内容。

其构造方法：

2.2、FileInputStream类读取数据read方法

在读取文件中的数据时，调用read方法，实现从文件中读取数据

例：

public static void main(String[] args) throws IOException {
　　//明确读取文件
　　//创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。

　　FileInputStream fis=new FileInputStream("e:\\test\\test.txt");
　　//读取数据。使用 read();一次读一个字节。
　　/*int a=fis.read();
　　//(char)，强制转换为字符类型
　　//不转换类型，输出为int类型，ASCii表
　　System.out.println((char)a);
　　 int b=fis.read();
　　System.out.println((char)b);
　　 int c=fis.read();
　　System.out.println((char)c);
　　 int d=fis.read();
　　System.out.println((char)d);
　　int e=fis.read();
　　System.out.println((char)e);
　　int f=fis.read();
　　System.out.println((char)f); System.out.println(a+b+c+d+e+f);*/
　　 int len=0;
　　//循环读取，读取前判断fis.read()是否为-1
　　while((len=fis.read())!=-1){
　　 System.out.println((char)len); 
　　} 
　　fis.close();
 }

2.3读取数据 read( byte [ ] ) 方法

在读取文件中的数据时，调用read方法，每次只能读取一个，太麻烦了，于是我们可以定义数组作为临时的存储容器，这时可以调用重载的read方法，一次可以读取多个字符。

一般定义数组的长度为1024的倍数

public static void main(String[] args) throws IOException
        /*
         * 演示第二个读取方法， read(byte[]);
         */
        File file = new File("c:\\file.txt");
        // 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
        FileInputStream fis = new FileInputStream(file);
        //创建一个字节数组。
        byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。
        int len = 0;
        while((len=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
        fis.close();
    }

2.4字节流练习

需求：复制文件

原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。

public static void main(String[] args) throws IOException {
        //明确数据源
        FileInputStream fis=new FileInputStream("e:\\sqlyog_x64.zip");
        //明确目的地
        FileOutputStream fos=new FileOutputStream("e:\\test\\sqlyog_x64.zip");
        //复制
        int len=0;
        while((len=fis.read())!=-1){
            //写入目标文件
            fos.write(len);
        }
        //释放资源
        fis.close();
        fos.close();
    }

二、字符流

字节流可以针对英文、数字进行读写操作，当我们操作的文件中有中文字符时，就需要用到字符流。

1、用字节流处理字符的问题

public static void main(String[] args) throws IOException {
        //给文件中写中文
        writeCNText();
        //读取文件中的中文
        readCNText();
    }
  //写中文
    public static void writeCNText() throws IOException {
        FileOutputStream fos = new FileOutputStream("c:\\cn.txt");
//写入中文字符
        fos.write("欢迎你".getBytes());
        fos.close();
    }
  //读取中文
    public static void readCNText() throws IOException {
        FileInputStream fis = new FileInputStream("c:\\cn.txt");
        int ch = 0;
//读取中文字符
        while((ch = fis.read())!=-1){
            System.out.println(ch);
        }
    }

利用字节流操作复制文件后，得到的文件中并没有具体文字，看到的只是数字。

 2、字符编码表

计算机中储存的信息都是用二进制数表示的；而我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。

编码表：其实就是生活中字符和计算机二进制的对应关系表。

3、 字符输入流Reader

读取字符流的抽象超类。用法类似字节流的字节输入流 InputStream

read():读取单个字符并返回int，结束后返回-1

read(char[]):将数据读取到数组中，并返回读取的个数。

 3.1 FileReader类

用来读取字符文件的便捷类。

构造方法

4 字符输出流Writer

Writer是写入字符流的抽象类，用法类似字节流的字节输出流 OutputStream

4.1 FileWriter类

用来写入字符文件的便捷类

构造方法：

5、字符流练习

需求：复制文本文件。

    public static void main(String[] args) throws IOException {
        copyTextFile();
    }
    public static void copyTextFile() throws IOException {
        //1,明确源和目的。
        FileReader fr = new FileReader("c:\\cn.txt");
        FileWriter fw = new FileWriter("c:\\copy.txt");
        //2,为了提高效率。自定义缓冲区数组。字符数组。
        char[] buf = new char[1024];
        int len = 0;
        while((len=fr.read(buf))!=-1){
            fw.write(buf,0,len);
        }
        /*2,循环读写操作。效率低。
        int ch = 0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        */
        //3,关闭资源。
        fw.close();
        fr.close();
    }

6、 flush()和close()的区别？

在执行完读取写入操作后，字符并没有马上存入目标文档，字符内容暂存在缓存区，需要用flush()，刷新一下，刷新后，流还可以继续使用。

close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。

如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。