JavaSE基础（12）——文件、递归、IO流

1、IO流

Input：输入，写数据，数据从磁盘加载到内存（程序）中。

Output：输出，读数据，数据从内存（程序）存储到磁盘中。

流：不管是读还是写，都要对数据进行传输，传输的方式就是流

2、File类

数据的读写离不开文件，File类是可以对文件和目录（文件夹）级别，而不是内容本身进行增删改查的类。

File类的API

//传递完整路径(文件或目录)
public File(String pathname)
//父级目录(字符串类型)和子级目录创建新File实例
public File(String parent, String child)
//父级目录(File类型)和子级目录创建新File实例
public File(File parent, String child)
//URI类型的路径创建实例
public File(URI uri)

常用方法

1.创建修改删除功能

1、createNewFile() 文件不存在，创建一个新的空文件并返回 true ，文件存在，不创建文件并返回 false 。

2. *static createTempFile() 根据前缀和后缀名在指定目录下生成不重名的临时文件

3. mkdir() 创建一层目录

4. mkdirs() 创建多层目录

5. renameTo(new File("")) 修改文件名

6. delete() 删除文件或空目录

2.判断功能的方法

1. exists() 判断文件是否存在 
2. isFile() 是否是文件
3. isDirectory() 是否是一个目录 
4. canRead() 是否可读
5. canWrite() 是否可写

3.获取功能的方法

1. getAbsolutePath() 获得绝对路径
2. getParentFile() 获得父路径
3. getName() 获得文件名
4. length() 获得文件长度(字节)
5. lastModified() 最后修改时间的毫秒值

4.目录的遍历

1. String[ ] list() 返回一个String数组，表示该File目录中的所有子文件或目录。
2. File[ ] listFiles() 返回一个File数组，表示该File目录中的所有的子文件或目录。

3、递归

在方法体内部调用自己本身方法的方法就是递归调用
递归比较适合解决同一段代码需要根据每次执行结果调用多次的情况（大问题化小）
注意：递归方法一定要有结束条件，否则找不到出口会报内存溢出(OOM)异常

import java.io.File;
//递归遍历文件夹下所有的文件
public class RecursionDirectory {
    public static void main(String[] args) {
        File file=new File("D:\\java专属IO测试");
        Recursion(file);
    }
    public static void Recursion(File file){
        //1、判断传入的是否是目录
        if(!file.isDirectory()){
        //不是目录直接退出
        return;
        }
        //已经确保了传入的file是目录
        File[] files = file.listFiles();
        //遍历files
        for (File f: files) {
        //如果该目录下文件还是个文件夹就再进行递归遍历其子目录
            if(f.isDirectory()){
                //递归
                Recursion(f);
            }else {
                //如果该目录下文件是个文件，则打印对应的名字
                    System.out.println(f.getName());
            }
        }
    }
}

4、IO流的分类

1、按照方向分：   输入流（数据从其他设备读取/加载到内存）

                              输出流（数据从内存存储到其他设备中）

2、按照传输内容分：字节（byte）流、字符(char)流，1字节（byte）=8位（bit）

3、按照功能分为：节点流（）、增强流（具有额外功能的增强流）

3、四个顶层的流（节点流）
        1. InputStream 字节输入流
        2. OutputStream 字节输出流
        3. Reader 字符输入流
        4. Writer 字符输出流

5、字节流—用于处理任意文件

        一切文件数据(文本、图片、视频等)都是以二进制形式存储，数据传输时一样以二进制形式传输。字节流可以传输任意文件数据。无论使用什么样的流对象，底层传输的始终为二进制数据。

字节流读取中文字符时，可能不会显示完整的字符，那是因为一个中文字符占用多个字节存储。

字节输出流（OutputStream）

以下方法是字节输出流都具有的方法，由父类OutputStream定义提供，子类都会共享这些方法

//将 b.length个字节从指定的字节数组写入此输出流。
public void write(byte[] b)
//从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
//也就是说从off个字节数开始读取一直到len个字节结束
public void write(byte[] b, int off, int len)
//将指定的字节输出流。
public abstract void write(int b)
//刷新此输出流并强制任何缓冲的输出字节被写出。
public void flush()
//关闭此输出流并释放与此流相关联的任何系统资源。
public void close()

 FileOutputStream

写出字节的 write 方法

public void write(int b)        //写出一个字节的数据
public void write(byte[] b)    //写出字节数组中的数据
public void write(byte[] b,int off,int len) //写出从 off 索引开始，len 个字节的数据

追加内容和换行

    // 回车符(\r)：回到一行的开头（return）。
    // 换行符(\n)：下一行（newline）
    FileOutputStream fos = new FileOutputStream("fos.txt");
    fos.write("\r\n".getBytes());

字节输入流（InputStream）

java.io.InputStream 抽象类是表示字节输入流的所有类的超类（父类），可以读取字节信息到
内存中。它定义了字节输入流的基本共性功能方法。

FileInputStream

读字节数据 read 的方法

    //可以读取一个字节的数据，读取到文件末尾，返回-1（int）
    public void read()
    //读取b的长度个字节到数组中,返回读取到的有效字节个数，读取到末尾时，返回 -1    
    public void read(byte[] b)    
    //读出从 off 索引开始，len 个字节的数据
    public void read(byte[] b,int off,int len)

示例代码：以字节数组读取文本内容 

public class FISRead {
    public static void main(String[] args) throws IOException{
    // 使用文件名称创建流对象.
        FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
    // 定义变量，作为有效个数
        int len ；
    // 定义字节数组，作为装字节数据的容器
        byte[] b = new byte[2];
    // 循环读取
        while (( len= fis.read(b))!=-1) {
    // 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));// len 每次读取的有效字节个数
        }
    // 关闭资源
        fis.close();
    }
}
/*读取结果：
ab
cd
e
*/

字节流复制图片/音频/视频等文件 

public class Copy {
    public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 指定数据源
    FileInputStream fis = new FileInputStream("D:\\test.jpg");
// 1.2 指定目的地
    FileOutputStream fos = new FileOutputStream("test_copy.jpg");
// 2.读写数据
// 2.1 定义数组
    byte[] b = new byte[1024];
// 2.2 定义长度
    int len;
// 2.3 循环读取
    while ((len = fis.read(b))!=-1) {
// 2.4 写出数据
        fos.write(b, 0 , len);
    }
// 3.关闭资源
    fos.close();
    fis.close();
    }
}

6、字符流—用于处理文本文件

        因为数据编码(ASCII、Unicode、GBK、UTF-8)的不同，字节流处理字符比较麻烦
字符流本质其实就是基于字节流读取时，去查了指定的码表（字符流 = 字节流 +编码表 ）
如果处理纯文本的数据优先考虑字符流，其他情况就只能用字节流了（图片、视频等），而字节流直接读取中文文本数据会有乱码的问题

字符输出流（Writer）

java.io.Writer 抽象类是字符输出流的所有类的超类（父类），将指定的字符信息写出到目的地。它同样定义了字符输出流的基本共性功能方法。

基本共性方法

//写入单个字符。
void write(int c)
//写入字符数组。
void write(char[] cbuf)
//写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
abstract void write(char[] cbuf, int off, int len)
//写入字符串。
void write(String str)
//写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
void write(String str, int off, int len)
//刷新该流的缓冲
void flush()
//关闭此流，但要先刷新它。
void close()

FileWriter 

使用FileWriter进行写文件时，需要使用flush()方法将数据从缓冲区保存到文件

关闭close和刷新flush

        flush ：刷新缓冲区，流对象可以继续使用。
        close : 先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

        因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们想写出数据，同时继续使用流，就需要 flush 方法。
        flush() 这个函数是清空的意思，用于清空缓冲区的数据流，进行流的操作时，数据先被读到内存中，然后再用数据写到文件中，那么当你数据读完时，我们如果这时调用 close() 方法关闭读写流，这时就可能造成数据丢失，为什么呢？因为，读入数据完成时不代表写入数据完成，一部分数据可能会留在缓存区中，这个时候 flush() 方法就格外重要了。

字符输入流（Reader）

        java.io.Reader 抽象类是字符输入流的所有类的超类（父类），可以读取字符信息到内存中。它 定义了字符输入流的基本共性功能方法。

基本共性功能方法

//关闭此流并释放与此流相关联的任何系统资源
public void close()
//从输入流读取一个字符
public int read()
//从输入流中读取一些字符，并将它们存储到字符数组 cbuf中
public int read(char[] cbuf)

FileReader

读取数据的Read方法

        1. 读取字符： read 方法，每次可以读取一个字符的数据，返回为int类型，读取到文件末尾，返回 -1。

        2. 使用字符数组读取： read(Char[] b) ，每次读取b的长度个字符到数组中 返回读取到的有效字符个数，读取到末尾时，返回 -1。

文本复制
字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile {
    public static void main(String[] args) throws IOException {
//创建输入流对象
    FileReader fr=new FileReader("F:\\新建文件夹\\aa.txt");//文件不存在会抛出java.io.FileNotFoundException
//创建输出流对象
    FileWriter fw=new FileWriter("C:\\copyaa.txt");
/*创建输出流做的工作：
* 1、调用系统资源创建了一个文件
* 2、创建输出流对象
* 3、把输出流对象指向文件
* */
//文本文件复制，一次读一个字符
    copyMethod1(fr, fw);
//文本文件复制，一次读一个字符数组
    copyMethod2(fr, fw);
    fr.close();
    fw.close();
    }
    public static void copyMethod1(FileReader fr, FileWriter fw) throws IOException {
        int ch;
        while((ch=fr.read())!=-1) {//读数据
            fw.write(ch);//写数据
        }
        fw.flush();
    }
    public static void copyMethod2(FileReader fr, FileWriter fw) throws IOException {
        char chs[]=new char[1024];
        int len=0;
        while((len=fr.read(chs))!=-1) {//读数据
            fw.write(chs,0,len);//写数据
        }
        fw.flush();
    }
}

7、数组流

        FileInputStream、FileOutputStream、FileReader、FileWriter是操作存储在硬盘上数据的工具类。
        硬盘上的资源java虚拟机是无权直接访问的，必须借助操作系统，java虚拟机借助完了之后要通知操作系统释放资源。
        把操作源头换成电脑上的一块内存（字节数组），java 就可以直接访问，因为是 java 虚拟机的一块内存，不用关闭(释放)。
        转化成字节数组的量要小，否则内存很容易过多。任何数据都可以转化成字节数组。

8、处理流