I/O流

I/O概述

I/O是Input/Output的缩写，表示输入输出。对于内存来说，从内存中取出数据写入到磁盘中的操作是输出，也就是写。从磁盘中读取数据到内存中是输入的操作，也就是读。
I/O流根据操作数据的最小单位，分为字符流和字节流。又可以根据是否直接对文件资源进行读写操作，分为节点流和处理流。
下面以java.io包为基础，学习I/O流的内容。

1. 继承结构

2.类的概述

2.1 File类

File类是对文件和目录的抽象。它可以用来表示一个文件或路径。I/O流操作目标就是系统中的文件。

**
 * Description:File类
 * 概述：File类是对文件和路径的抽象。
 * 1.静态成员。
 *      pathSeperator:路径分隔符。windows:分号; linux:冒号:
 *      seperator:名称分隔符。windows：反斜杠/ linux:正斜杠\
 *      作用：用于替代路径中写死的分隔符，使程序更加灵活。
 * 2.构造方法
 * 概述：在创建File对象时，路径可以真实存在也可以不存在；路径可以是相对路径也可以是绝对路径；
 * 路径可以是文件夹结尾也可以是文件结尾；并不影响File对象的创建
 *      2.1 使用指定路径作为参数
 *          File file = new File(String pathName);
 *      2.2 使用2个指定路径，拼接后作为文件路径
 *          File file = new File(String parent,String child);
 *      2.3 使用一个file对象，和一个路径名
 *          File file = new File(file parent,String child);
 * 3.其它方法
 *     3.1 创建功能
 *      3.1.1 创建文件对象
 *          boolean createNewFile();
 *      3.1.2 创建单级文件夹对象
 *          boolean mkDir();
 *      3.1.3 创建多级的文件夹对象
 *          boolean mkDirs();
 *      3.2 删除功能
 *       3.2.1 删除文件。
 *          delete();该方法会从磁盘上直接删除文件，不会进入回收站,只有在文件路径正确时，才会删除。
 *          如果目标问价夹下还有子文件，不会删除。
 *          deleteOnExit():在jvm停止后，才删除文件。
 *      3.3 获取信息（查询）功能
 *       3.3.1 获取文件路径
 *       3.3.2 获取父File的信息
 *       3.3.3 获取文件名称
 *       3.3.4 获取文件夹下的子文件名称
 *       3.3.5 获取子文件File
 *      3.4 判断功能
 *       3.4.1 判断文件是否存在
 *       3.4.2 是文件还是文件夹
 *       3.4.3 判断文件是否可写、可读、隐藏。
 * Date-Of-Create:2020/7/6-9:07
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        //静态变量
        /*sep();*/
        //构造函数
        /*cons();*/
        //创建功能
        /*mk();*/
        //删除文件或者文件夹
        /*delete();*/
        //获取对象信息
        /*getInfo();*/
        //判断功能
        check();
    }

    private static void check() {
        String pathName = "C:\\Users\\aipande\\Desktop\\testDemo\\IO\\abc\\def";
        File file = new File(pathName);
        //判断是否存在
        /*System.out.println(file.exists());
        if(!file.exists()){
            file.mkdirs();
        }*/
        //判断是文件还是文件夹,对于不是实际存在的文件，无法判断是文件还是文件夹，注意不能根据文件路径判断是文件还是文件夹
        System.out.println(file.isDirectory());
    }

    private static void getInfo() throws IOException {
        String pathName = "C:\\Users\\aipande\\Desktop\\testDemo\\IO\\abc\\def";
        File file = new File(pathName);
        //获取文件绝对路径
        System.out.println(file.getAbsolutePath());
        //获取构造时传入的路径
        System.out.println(file.getPath());
        //父路径
        System.out.println(file.getParent());
        //父File对象。在给定一个路径，创建文件的时候，可以先使用该方法获取父File对象，
        //判断是否存在exsit()，如果不存在，再调用mkDirs()方法，避免父File文件夹不存在的问题
        System.out.println(file.getParentFile());
        //获取文件名称
        System.out.println(file.getName());
        //获取规范路径，没啥特别的用处，貌似和获取绝对路径的结果相同
        System.out.println(file.getCanonicalPath());
        //遍历文件夹，这里可以使用FileFilter过滤
        File[] files = file.listFiles();
        String[] fileName = file.list();
    }

    private static void delete() {
        String pathName = "C:\\Users\\aipande\\Desktop\\testDemo\\IO\\abc\\def";
        File file = new File(pathName);
        System.out.println(file.delete());
    }

    private static void mk() throws IOException {
        StringBuffer buffer = new StringBuffer();
        String sep = File.separator;
        buffer.append("C:").append(sep).append("Users").append(sep).append("aipande")
                .append(sep).append("Desktop").append(sep).append("testDemo").append(sep).append("IO").append(sep)
                .append("abc").append(sep).append("def");
        System.out.println(buffer.toString());
        File file = new File(buffer.toString());
        //创建文件,文件之前的所有文件夹必须已存在，否则抛出IO异常:系统找不到指定路径。
        //file.createNewFile();
        //创建单级文件夹,只能创建最后一级文件夹，如果最后一级文件夹的前置文件夹不存在，那么不会创建文件夹
        //file.mkdir();
        //创建多级文件夹，如果最后一级文件夹的前置文件夹不存在，那么也会创建前置文件
        file.mkdirs();
    }


    private static void cons() {
        String path = "C:\\Users\\aipande\\Desktop\\testDemo\\IO";
        File file = new File(path);
        File file1 = new File(path,"abc.txt");
        File file2 = new File(file,"def.txt");

        System.out.println(file);
        System.out.println(file1);
        System.out.println(file2);
    }

    public static void sep(){
        //获取系统路径分隔符
        String pathSep = File.pathSeparator;
        System.out.println(pathSep);
        //获取名称分隔符
        String sep = File.separator;
        System.out.println(sep);

        //用于替换路径中的分隔符
        StringBuffer path = new StringBuffer();
        path.append("C:").append(sep).append("new").append(sep);
        System.out.println(path);
    }

2.2 字节流

所有InputStream的子类都是输入字节流，所有OutputStream的子类都是字节输出流。
InputStream:抽象类，是所有字节输入流的超类。

//关闭流，释放资源
public void close();
//读取单个字节,读取下一个字节，返回该字节的int值（int类型有4个字节，将byte类型前的字节以0补齐的值，返回）
public int read();
//最多读取bytes.length个字节到数组中，返回值为读取的字节个数，如果没有可读字节，返回-1
public int read(byte[] bytes);
//最多读取len个字节，放到数组的指定位置，返回读取的字节个数
public int read(byte[] bytes,int offSet,int len);
//在流中做一个标记，该方法一般配合reset()方法使用
public void mark(int readlimit)
//将流重新定位到上一个标记的地方,可以实现重复读取字节
public void reset()

OutputStream:抽象类，是所有字节输出流的超类。

//关闭流，释放资源
public void close();
//写入一个字节,int类型由4个字节组成，这里只会取i低8位写入文件中。
public void write(int i);
//写入多个字节，将字节数组中的元素都写入文件中。
public void write(byte[] bytes);
//写入多个字节，从off位置开始，写入len个字节到文件中
public void write(byte[] bytes,int off,int len);
//刷新方法。如果输出流有缓冲区，调用该方法，会将缓冲区中的所有数据写入到文件中，注意，有缓冲区的输出流才有必要使用该方法
public void flush();

2.2.1 FileInputStream 和 FileOutputStream

FileInputStream：文件字节输入流，以字节为单位读取文件中的数据。
FileOutputStream：文件字节输出流，以字节为单位写入磁盘上的文件中。

FileInputStream：
1.构造方法

• 因为是读取文件，所以在创建对象时，需要指定源文件（从哪里读），可以使用字符串路径，也可以使用File对象。

•  1.1 FileInputStream fis = new FileInputStream(String pathName);
  

•  1.2 FileInputStream fis = new FileInputStream(File file);
  

  上面两种构造方法，实质是一样的：

  //源码。判断路径是否为空，不为空则创建一个File对象，再调用FileInputStream(File file);
  public FileInputStream(String name) throws FileNotFoundException {
      this(name != null ? new File(name) : null);
  }
  

• 2.其它方法
• 概述：每个字节流再创建的时候，在字节流的头部都有一个指针，调用read方法时，会将指针后移，再次调用read方法会从指针的位置向后读取

•  2.1 public int read();读取下一个字节，返回该字节的int值（int类型有4个字节，将byte类型前的字节以0补齐的值，返回int值）
  

•  2.2 public int read(byte[] bytes);最多读取bytes.length个字节到数组中，返回值为读取的字节个数，如果没有可读字节，返回-1
  

•  2.3 public int read(byte[] bytes,int offSet,int len);最多读取len个字节，放到数组的指定位置，返回读取的字节个数
  

• 3.关闭流，释放资源的方法

•  close();流关闭以后，就不能再读取字节了。
  

FileOutputStream：

• 1.构造方法
• 因为是写入，所以需要知道目标文件的地址，即往哪里写的问题。注意：在创建FileOutputStream对象时，如果目标文件不存在，会先尝试去创建目标文件。但如果目标文件路径表示的是文件夹、或者是文件但是无法创建，会抛出IO异常。
• 1.1 FileOutputStream fos = new FileOutputStream(String pathName,boolean append);

• pathName:指定文件的路径。
  

• append:如果为true，表示在写入时，会将数据添加到原文件中。否则，则会覆盖原文件的内容。
  

• 1.2 FileOutputStream fos = new FileOutputStream(String pathName);

• pathName:指定文件的路径。append默认为false。
  

• 1.3 FileOutputStream fos = new FileOutputStream(File file,boolean append);

• 与第一种构造方法本质是一样的，只是第一种方法执行了一个new File(pathName)的过程。
  

• 1.4 FileOutputStream fos = new FileOutputStream(File file);

• 与第二种方法本质一样。	
  

• 2.其他方法
• 主要是继承自OutputStream的几种方法。参考OutputStream的内容。

小结：
1.flush方法和close方法的区别？
flush方法会将缓冲区中的数据写入文件，但不会关闭流。close方法也会将缓冲区中的内容写到文件中，但是会关闭流。流关闭后，无法再写入数据。

2.2.2 ObjectInputStream和ObjectOutputStream

首先介绍对象的序列化和反序列化：
序列化：将对象转换成字节序列的过程。
反序列化：将字节序列恢复成对象的过程。

ObjectInputStream:对象字节输入流。作用：对象的反序列化，即将字节序列读取到内存中，并恢复成对象。
ObjectOutputStream:对象字节输出流。对象的序列化，将对象以字节的形式保存或传输。

ObjectInputStream：
构造方法：
1.ObjectOutputStream oos = new ObjectOutputStream(OutputStream out);
特殊方法：
public Object readObject();从字节流中读取一个对象。
ObjectOutputStream:
1.ObjectOutputStream oos = new ObjectOutputStream(OutputStream out);
特殊方法：
public void writeObject(Object object);将对象写入文件。
小结：
1.类如果要实现序列化，必须实现Serializable接口。
2.可以使用transient关键字修饰变量，使该变量不会被序列化。（作用类似于static）

2.2.3 BufferedInputStream和BufferedOutputStream

BufferedInputStream:缓冲字节输入流。就是在字节输入流的基础上，加了一个缓冲区，以提高字节读取的效率。
BufferedOutputStream：缓冲字节输出流。同上。
对于缓冲输出流来说，如果想要立即看到写入效果，可以调用flush方法。

BufferedInputStream：
因为是对字节输入流添加缓冲功能，因此，需要一个字节输入流作为构造参数。
构造方法：

• 1.BufferedInputStream bis = new BufferedInputStream(InputStream inputStream);//使用默认大小的直接缓冲数组
• 2.BufferedInputStream bis = new BufferedInputStream(InputStream inputStream,int size);//指定缓冲字节数组的大小

BufferedOutputStream
构造方法：

• 1.BufferedOutputStream bos = new BufferedOutputStream(OutputStream os);
• 2.BufferedOutputStream bos = new BufferedOutputStream(OutputStream os,int size);

2.3 字符流

Reader:所有字符输入流的超类。
Writer:所有字符输出流的超类。