File类创建删除文件和目录；字节输出流、输入流实现文件复制；字节缓冲输入流和输出流实现文件复制

1. File类

• File将文件或者目录封装为对象，从而对文件或者目录进行创建或删除
• 对于File而言，其封装的仅仅是一个路径名而已。它可以是存在的,也可以是不存在的

1.1 File类的构造方法

绝对路径：是一个完整的路径，从盘符开始

相对路径：是一个简化的路径，相对当前项目下的路径

方法名	说明
File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的 File实例
File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的 File实例

public class MyFileDemo01 {
    public static void main(String[] args) {
        String path1 = "D:\\yulufeng";
        String path2 = "\\aaa.txt";
        //使用两个字符串拼接创建 File实例
        File file = new File(path1, path2);
        //通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
        File file1 = new File(path1);
        //使用字符串和File对象，创建File实例
        File file2 = new File(file1, path2);
        System.out.println(file);//D:\yulufeng\aaa.txt
        System.out.println(file2);//D:\yulufeng\aaa.txt

        //相对路径：是一个简化的路径，相对当前工程下的路径
        String path3 = "day11_exercise\\day11.txt";
        File file3 = new File(path3);
        //获取绝对路径
        System.out.println(file3.getAbsolutePath());
        //F:\employment_class\IdeaProjects\AdvanceCode\day11_exercise\day11.txt
    }
}

1.2 File类的创建功能

方法名	说明
public boolean createNewFile()	当具有该名称的文件不存在时，创建一个新空文件，只能创建文件
public boolean mkdir()	只能创建单级文件夹，只能创建文件夹
public boolean mkdirs()	可以创建单级文件夹和多级文件夹，只能创建文件夹

import java.io.File;
import java.io.IOException;

public class MyFileDemo02 {
    public static void main(String[] args) throws IOException {
        //相对路径：是一个简化的路径，相对当前项目下的路径
        String path1 = "D:\\yulu\\feng";
        File file1 = new File(path1);
        //创建多级文件夹
        boolean result1 = file1.mkdirs();
        System.out.println(result1);//true
        //创建文件aaa.txt
        String path2 = "\\aaa.txt";
        File file2 = new File(file1, path2);
        boolean result2 = file2.createNewFile();
        System.out.println(result2);//true
    }
}

1.3 File类的删除功能和判断获取功能

删除方法：public boolean delete()    删除由此抽象路径名表示的文件或目录

• delete()  方法直接删除，不走回收站
• 如果删除的是文件，直接删除；如果删除的是文件夹必须为空
• 如果文件夹不为空，使用递归删除

判断方法：

方法名	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
public boolean isFile()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否存在

获取方法：

方法名	说明
public String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
public String getPath()	将此抽象路径名转换为路径名字符串
public String getName()	返回由此抽象路径名表示的文件或目录的名称
public File[] listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

案例一：递归删除非空文件夹

import java.io.File;

public class MyFileDemo01 {
    public static void main(String[] args)  {
        //递归删除非空目录
        File src = new File("D:\\yulu\\feng");
        deleteFile(src);
    }

    private static void deleteFile(File src) {
        //得到src文件夹中的所有file对象
        File[] files = src.listFiles();
        //遍历files删除src中的文件和文件夹
        for (File file : files) {
            //判断,如果是文件直接删除
            if (file.isFile()){
                file.delete();
            }
            //判断,如果是目录，调用删除目录方法
            if (file.isDirectory()){
                deleteFile(file);
            }
        }
        //删除src空文件夹
        src.delete();
    }
}

案例二：统计一个文件夹中每种文件的个数并打印

public class Test2 {
    public static void main(String[] args) {
        //统计一个文件夹中,每种文件出现的次数.
        //统计 --- 定义一个变量用来统计. ---- 弊端:同时只能统计一种文件
        //利用map集合进行数据统计,键 --- 文件后缀名  值 ----  次数

        File file = new File("filemodule");
        HashMap<String, Integer> hm = new HashMap<>();
        getCount(hm, file);
        System.out.println(hm);
    }
  
	//1.定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
    private static void getCount(HashMap<String, Integer> hm, File file) {
      	//2.遍历File对象,获取它下边的每一个文件和文件夹对象
        File[] files = file.listFiles();
        for (File f : files) {
          	//3.判断当前File对象是文件还是文件夹
            if(f.isFile()){
              	//如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过
                String fileName = f.getName();
                String[] fileNameArr = fileName.split("\\.");
                if(fileNameArr.length == 2){
                    String fileEndName = fileNameArr[1];
                    if(hm.containsKey(fileEndName)){
                        //出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中
                        Integer count = hm.get(fileEndName);
                        //这种文件又出现了一次.
                        count++;
                        //把已经出现的次数给覆盖掉.
                        hm.put(fileEndName,count);
                    }else{
                        // 没出现过,将这种类型文件的后缀名存入集合中,次数存1
                        hm.put(fileEndName,1);
                    }
                }
            }else{
              //如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象代码实现
                getCount(hm,f);
            }
        }
    }
  
}

2. IO流的概述和分类

IO流介绍：

• IO：输入/输出(Input/Output)
• 流：数据在设备间的传输称为流，流的本质是数据传输
• IO流就是用来处理设备间数据传输问题的。常见的应用: 文件复制; 文件上传; 文件下载

IO流的分类 ：

输入输出都是相对于内存而言：

• 输入流：读数据（内存读入数据）
• 输出流：写数据（内存向磁盘写数据）

按照数据类型来分

• 字节流：字节输入流和字节输出流
• 字符流：字符输入流和字符输出流（字符流：纯文本文件，可以用记事本打开）

IO流的使用场景：

• 如果操作的是纯文本文件，优先使用字符流
• 如果操作的是图片、视频、音频等二进制文件，优先使用字节流
• 如果不确定文件类型，优先使用字节流。字节流是万能的流

 3. 字节流

 3.1 字节输出流（写数据）

使用字节输出流写数据的步骤：

• 创建字节输出流（FileOutputStream）对象，让字节输出流对象指向文件
• 调用字节输出流对象的写数据方法
• 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

输出流写数据的方法分类：

方法名	说明
void write(int b)	将指定的字节写入此文件输出流 一次写一个字节数据
void write(byte[] b)	将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
void write(byte[] b, int off, int len)	将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据

代码示例：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutPutDemo {
    public static void main(String[] args) throws IOException {
        //创建输出流对象fos，参数可以是String或者是File对象
        OutputStream fos = new FileOutputStream("day11_exercise\\aaa.txt");
        byte[] bt = {97,98,99,100,101,102,103,104};
        int a = 97;
        //写数据的三种方法
        //file.write(a);
        //file.write(bt);
        fos.write(bt, 0, 5);
        //释放资源
        fos.close();
    }
}

字节输出流写数据实现换行和不覆盖写入：

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象，第二个参数传入true可以实现数据追加输入
        FileOutputStream fos = new FileOutputStream("day11_exercise\\fos.txt",true);

        /*  写数据实现换行
                - windows:\r\n
                - linux:\n
                - mac:\r
         */
        for (int i = 0; i < 10; i++) {
            //必须以字节类型写入调用getBytes方法，返回的是一个byte型数组
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

3.2 字节输出流写数据的异常处理

异常处理格式：try-catch-finally（被finally控制的语句一定会执行，用于实现资源释放 ）

try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清除操作;
}

示例代码：

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("myByteStream\\fos.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.3 字节输入流（读取数据）

字节输入流，以实际存在文件路径作为参数，创建一个FileInputStream对象，该路径可以是String类型也可以是File类型

字节输入流读取数据的步骤：

• 创建字节输入流对象（FileInputStream）
• 调用字节输入流对象的读数据方法
• 释放资源

 read一次读取一个字节：

import java.io.FileInputStream;
import java.io.IOException;

public class InputDemo {
    public static void main(String[] args) throws IOException {
        //创建一个字节输入流对象fis
        FileInputStream fis = new FileInputStream("day11_exercise\\aaa.txt");
        int b ;//用于记录读入内存的字节
        //若文件读取完毕会返回-1
        while((b = fis.read()) != -1){
            System.out.println((char)b);
        }
        //释放资源
        fis.close();
    }
}

read一次读入一个字节数组：

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        byte[] bys = new byte[1024]; //临时存放读入内存的字节，一次读取1024字节
        int len;//若文件读取完毕返回-1
        //循环读取
        while ((len=fis.read(bys))!=-1) {
            //使用平台的默认字符集解码指定的字节子阵列来构造新的String对象，并打印
            System.out.print(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

3.4 利用字节输入和输出流复制文件

实现步骤：

• 根据数据源地址创建字节输入流对象
• 根据目的地地址创建字节输出流对象
• 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
• 释放资源

实现代码：

import java.io.*;

public class copyDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\网络图片\\05.jpg");
        //创建输入流对象
        FileInputStream fis = new FileInputStream(file);
        //创建输出流对象
        FileOutputStream fos = new FileOutputStream("day11_exercise\\" + file.getName());
        int len;
        byte[] bys = new byte[1024];
        //一次读入一个字节数组
        while((len = fis.read(bys))!=-1){
            //一次写入一个字节数组
            fos.write(bys);
        }
        //释放资源
        fis.close();
        fos.close();
    }
}

4. 字节缓冲流

字节缓冲流介绍：

• lBufferOutputStream：字节缓冲输入流，提高了字节输入流的读取效率

• lBufferedInputStream：字节缓冲输出流，提高了字节输出流的写数据效率

 构造方法：

方法名	说明
BufferedOutputStream(OutputStream out)	创建字节缓冲输出流对象
BufferedInputStream(InputStream in)	创建字节缓冲输入流对象

使用字节缓冲流复制视频：

import java.io.*;

public class CopyDemo03 {
    public static void main(String[] args) throws IOException {
        //字节缓冲输入流对象bis
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("E:\\视频\\夏目友人帐第一季-001.mp4"));
        //字节缓冲输出流bos
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("E:\\视频\\copy夏目友人帐第一季-001.mp4"));
        long l1 = System.currentTimeMillis();
        byte[] bytes = new byte[1024];
        int len;
        //一次读入1024字节
        while((len = bis.read(bytes)) != -1){
            bos.write(bytes, 0, len);
        }
        long l2 = System.currentTimeMillis();
        bos.close();
        bis.close();
        System.out.println(l2-l1);
    }
}

使用字节缓冲流实现文件夹的复制：

import java.io.*;

public class CopyFile1 {
    public static void main(String[] args) throws IOException {
        //将F盘的CSDN材料复制到D盘
        File file1 = new File("F:\\CSDN材料");
        File file2 = new File("D:");

        copyAllFile(file1, file2);
    }

    private static void copyAllFile(File file1, File file2) throws IOException {
                               //D: + CSDN材料
        File parent = new File(file2, file1.getName());
        //创建 D:\\CSDN材料
        parent.mkdirs();
        File[] files = file1.listFiles();
        for (File file : files) {
            if (file.isFile()){

                FileInputStream fis = new FileInputStream(file);
                BufferedInputStream bis = new BufferedInputStream(fis);
                //如果是文件需要得到关联地址 D:\\CSDN材料 + 文件名
                File newf = new File(parent, file.getName());
                FileOutputStream fos = new FileOutputStream(newf);
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                //复制文件
                int b;
                while ((b = bis.read())!=-1){
                    bos.write(b);
                }
                bos.close();
                bis.close();
            }else {
                //如果遇到文件夹，相当于又是一次复制一个文件夹
                copyAllFile(file,parent);
            }

        }
    }
}

如有错误欢迎留言评论，及时更正。 2021年六月七日  羽露风