java基础(6) IO

IO 流

先给一个基本的概念，如下图，就是说文件IO是使用不同的Stream拼装出来的。理解一下给出的那个例子。

然后是详细介绍，基本分类的按如下所示

首先IO流可以分为字节流和字符流，或者另外一种划分模式。节点流 和 处理流（通常用的比较多的）

术语理解：
注：这里字节流和字符流讲的是最根本的区别，其他区别请自行搜索。

• 字节流：字节流处理的最基本单位为单个字节
• 字符流：字符流处理的最基本的单元是Unicode码元(大小2字节）
• 节点流：就是数据在传输的过程中从哪里接收的，又传输到哪个介质中。故又称介质流。比如说从文件中，从StringBuffer中，从byte[]中，从char[]中,从管道pipe中。
• 处理流：就是数据传输过程中因需求需要进行的一些额外的处理。比如说，加快访问速度，减少访问硬盘次数，可以将数据存放到一个缓存中，就可以加一个bufferxxx（xxx代表inputStream,outputStream,Reader,Writer）. 在一些文章中可能又会被称作装饰流。一般是Objectxxx和Filterxxx及其子类

（摘自狂神说java）

基本上的理论就这些，稍微理解一下。然后根据下图编写代码

先写一个文件的读写功能吧。

代码演示1：

文件读

package com.company;

import java.io.*;

/**
 *  功能实现: 文件的读
 * */

public class Test {
    public static void main(String[] args) throws IOException {
        // 要实现文件的读和写,首先我们要定位到一个文件上,这里使用的是File对象，也可以使用文件路径
        File file = new File("E:\\test.txt");


        // 如果file对象表示的文件不存在,我们创建一个
        if(!file.exists()) {
            file.createNewFile();
        }


        // 根据我们的图片来看,首先创建一个节点流, 这里是从文件的读和写，所以创建关于文件的节点流
        // 字节流还是字符流随自己
        FileInputStream fis = new FileInputStream(file);

        // 文件IO的经典步骤, 需要熟悉
        byte[] buffer = new byte[1024];
        int len = 0;

        // 从这个节点流中读取buffer长度的字节并存储到buffer中,返回所读数据的字节数, -1表示到达文件末尾
        while((len = fis.read(buffer)) != -1) {
            // 当前你文件中要有东西才能读取
            String str = new String(buffer,0,len);
            System.out.println(str);
        }

        // 资源释放
        if(fis != null) {
            fis.close();
        }
    }
}

结果演示

文件写

package com.company;

import java.io.*;

/**
 *  功能实现: 文件的写
 * */

public class Test {
    public static void main(String[] args) throws IOException {
        // 要实现文件的读和写,首先我们要定位到一个文件上,这里使用的是File对象，也可以使用文件路径
        File file = new File("E:\\test.txt");


        // 如果file对象表示的文件不存在,我们创建一个
        if(!file.exists()) {
            file.createNewFile();
        }


        // 根据我们的图片来看,首先创建一个节点流, 这里是从文件的读和写，所以创建关于文件的节点流
        // 字节流还是字符流随自己
        FileOutputStream fos = new FileOutputStream(file);

        // 文件IO的经典步骤, 需要熟悉
        fos.write("路漫漫其修远兮,吾将上下而求索".getBytes());

        // 资源释放
        if(fos != null) {
            fos.close();
        }
    }
}

结果演示

关于这两个代码，重点了解读和写的操作，是基本范式。还是就是要了解read() 和 write() 函数，IO最基本的无外乎就是读和写对不对，你不去了解read() 和 write（） 还去了解什么呢？

上面的是使用字节流进行处理的，现在使用字符流进行读写

3、代码演示3

package com.company;

import java.io.*;

/**
 *  功能实现: 文件的读
 * */

public class Test {
    public static void main(String[] args) throws IOException {
        // 要实现文件的读和写,首先我们要定位到一个文件上,这里使用的是File对象，也可以使用文件路径
        File file = new File("E:\\test.txt");


        // 如果file对象表示的文件不存在,我们创建一个
        if(!file.exists()) {
            file.createNewFile();
        }


        // 根据我们的图片来看,首先创建一个节点流, 这里是从文件的读和写，所以创建关于文件的节点流
        // 字节流还是字符流随自己
        FileReader fileReader = new FileReader(file);

        // 文件IO的经典步骤, 需要熟悉
        char[] buffer = new char[1024];
        int len = 0;
        while((len = fileReader.read(buffer)) != -1)
        {
            String str = new String(buffer, 0, len);
            System.out.println(str);
        }


        // 资源释放
        if(fileReader != null) {
            fileReader.close();
        }
    }
}

结果演示：

4、代码演示4

package com.company;

import java.io.*;

/**
 *  功能实现: 文件的写
 * */

public class Test {
    public static void main(String[] args) throws IOException {
        // 要实现文件的读和写,首先我们要定位到一个文件上,这里使用的是File对象，也可以使用文件路径
        File file = new File("E:\\test.txt");


        // 如果file对象表示的文件不存在,我们创建一个
        if(!file.exists()) {
            file.createNewFile();
        }


        // 根据我们的图片来看,首先创建一个节点流, 这里是从文件的读和写，所以创建关于文件的节点流
        // 字节流还是字符流随自己
        // 设置为追加模式的话
        FileWriter fileWriter = new FileWriter(file,true);


        // 文件IO的经典步骤, 需要熟悉
       fileWriter.write("路漫漫其修远兮,吾将上下而求索!");


        // 资源释放
        if(fileWriter != null) {
            fileWriter.close();
        }
    }
}

结果演示
分析：原本记事本中已经有一句“路漫漫其修远兮，吾将上下而求索”, 我使用的是追加的写，所以会在原来的那句话后面加上一句“路漫漫其修远兮，吾将上下而求索”。

以上代码都是只有节点流，而没有处理流，下面演示加了处理流的读和写

5、代码演示5：使用字节缓冲流对文件进行复制
我们将读出来的数据放在缓冲区中，加快读写速度。

package com.company;

import java.io.*;

/**
 *  功能实现: 文件的复制
 * */


public class Test {
    public static void main(String[] args) throws IOException {
        // 要实现文件的读和写,首先我们要定位到一个文件上,这里使用的是File对象，也可以使用文件路径
        File file = new File("E:\\test.txt");
        File file2 = new File("E:\\test2.txt");


        // 如果file对象表示的文件不存在,我们创建一个
        if(!file.exists()) {
            file.createNewFile();
        }

        if(!file2.exists()) {
            file2.createNewFile();
        }


        // 根据我们的图片来看,首先创建一个节点流, 这里是从文件的读和写，所以创建关于文件的节点流
        // 字节流还是字符流随自己
        FileInputStream fis = new FileInputStream(file);
        // 字节缓冲流, 将读取出来的数据放入缓冲区中
        BufferedInputStream bis = new BufferedInputStream(fis);

        FileOutputStream fos = new FileOutputStream(file2);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        // 文件IO的经典步骤, 需要熟悉
        // 其实我们定义的下面这个代码就是定义一个缓冲区
        // byte[] buffer = new byte[1024];

        int len = 0;
        // 如果参数指定一个数组buffer,从这个节点流中读取buffer长度的字节并存储到buffer中,返回所读数据的字节数, -1表示到达文件末尾
        // 如果是读的单个字节或者字符的话，返回的是unicode编码
        while((len = bis.read()) != -1) {
            bos.write(len);
        }



        // 资源释放
        // 流的关闭顺序: 一般是先打开的后关闭, 后打开的先关闭
        // 有处理流存在的话, 可以只关闭处理流, 再关闭节点流, 处理流关闭的时候, 会调用其处理的节点流的关闭方法
        if(bis != null) {
            bis.close();
        }

        if(bos != null) {
            bos.close();
        }
    }
}

分析代码：

• 输入节点流 —> 输入处理流 —> 输出处理流 —> 输出节点流。
• 就是想表达我画的那副图的意思。
• 这里是字节流，如果是字符流的话，对应的是FileReader —> BufferReader —> BufferWriter —> FileWriter

结果演示:

还有一些常见的流要注意一下
DataInputStream/DataOutputStream ：按照数据本身的类型进行读写
ObjectInputStream / ObjectOutputStream ： 以对象为单位的输入输出流，常用于对象的序列化。

还有上面的图片都是之前学习的时候认为比较好的，通俗的资料裁剪下来的，出处不太记得了，侵删。