一、File类

File类介绍：它是文件和目录路径名的抽象表示，文件和目录是可以通过File封装成对象的

1、File类的构造方法

File类的构造方法

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

    private static void method1() {
        //File(String pathname)        通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
        String path = "C:\\itheima\\a.txt";
        File file = new File(path);
    }
    
    private static void method2() {
        //File(String parent, String child)    从父路径名字符串和子路径名字符串创建新的File实例
        String path1 = "C:\\itheima";
        String path2 = "a.txt";
        File file = new File(path1,path2);//把两个路径拼接.
        System.out.println(file);//C:\itheima\a.txt
    }
    
    private static void method3() {
        //File(File parent, String child)      从父抽象路径名和子路径名字符串创建新的File实例
        File file1 = new File("C:\\itheima");
        String path = "a.txt";
        File file = new File(file1,path);
        System.out.println(file);//C:\itheima\a.txt
    }

绝对路径和相对路径
- 绝对路径：是一个完整的路径,从盘符开始
- 相对路径：是一个简化的路径,相对当前项目下的路径

import java.io.File;

public class FileDemo2 {
    public static void main(String[] args) {
        //这个路径固定不变了.
       File file = new File("D:\\itheima\\a.txt");

       //当前项目下的a.txt
       File file2 = new File("a.txt");

       //当前项目下 --- 指定模块下的 a.txt
       File file3 = new File("filemodule\\a.txt");
    }
}

2、File类的成员方法

File类创建功能

方法名	说明
public boolean createNewFile()	当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir()	创建由此抽象路径名命名的目录
public boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

    private static void method1() throws IOException {
        //注意点:
        //1.如果文件存在,那么创建失败,返回false
        //2.如果文件不存在,那么创建成功,返回true
        //3.createNewFile方法不管调用者有没有后缀名,只能创建文件
        File file1 = new File("C:\\itheima\\aaa");
        boolean result1 = file1.createNewFile();
        System.out.println(result1);
    }

    private static void method2() {
        //1.只能创建单级文件夹,不能创建多级文件夹
        //2.不管调用者有没有后缀名,只能创建单级文件夹
        File file = new File("C:\\itheima\\aaa.txt");
        boolean result = file.mkdir();
        System.out.println(result);
    }

    private static void method3() {
        //1,可以创建单级文件夹,也可以创建多级文件夹
        //2.不管调用者有没有后缀名,只能创建文件夹
        File file = new File("C:\\itheima\\aaa.txt");
        boolean result = file.mkdirs();
        System.out.println(result);
    }

File类删除功能：public boolean delete() -> 删除由此抽象路径名表示的文件或目录（只能删除文件和空文件夹）
- 不会进入回收站
- 如果删除的是文件,那么直接删除.如果删除的是文件夹,那么能删除空文件夹
- 如果要删除一个有内容的文件夹,只能先进入到这个文件夹,把里面的内容全部删除完毕,才能再次删除这个文件夹

import java.io.File;

public class FileDemo4 {
    public static void main(String[] args) {
        //method1();
        File file = new File("C:\\itheima");
        boolean result = file.delete();
        System.out.println(result);
    }

    private static void method1() {
        File file = new File("C:\\itheima\\a.txt");
        boolean result = file.delete();
        System.out.println(result);
    }
}

File类判断方法

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

    private static void method1() {
        File file = new File("C:\\itheima\\a.txt");
        boolean result1 = file.isFile();
        boolean result2 = file.isDirectory();
        System.out.println(result1);
        System.out.println(result2);
    }

    private static void method2() {
        File file = new File("C:\\itheima");
        boolean result1 = file.isFile();
        boolean result2 = file.isDirectory();
        System.out.println(result1);
        System.out.println(result2);
    }

    private static void method3() {
        File file = new File("a.txt");
        boolean result = file.exists();
        System.out.println(result);
    }

File类获取方法

getName()注意点
- 如果调用者是文件,那么获取的是文件名和后缀名
- 如果调用者是一个文件夹,那么获取的是文件夹的名字
listFiles：进入文件夹,获取这个文件夹里面所有的文件和文件夹的File对象,并把这些File对象都放在一个数组中返回，包括隐藏文件和隐藏文件夹都可以获取
- 当调用者是一个文件时：返回null
- 当调用者是一个空文件夹时：长度为0的数组
- 当调用者是一个有内容的文件夹时：返回所有的文件夹及文件夹的File对象数组包括隐藏文件和隐藏文件夹
- 当调用者是一个有权限才能进入的文件夹时：返回null

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

    public static void main(String[] args) {
        File file = new File("a.txt");
        String name = file.getName();
        System.out.println(name);

        File file1 = new File("C:\\itheima");
        String name2 = file1.getName();
        System.out.println(name2);

       	File file = new File("D:\\aaa");
        File[] files = file.listFiles();//返回值是一个File类型的数组
        System.out.println(files.length);
        for (File path : files) {
            System.out.println(path);
        }
    }

3、File类的案例

案例1：在当前模块下的aaa文件夹中创建一个a.txt文件

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        //注意点:文件所在的文件夹必须要存在.
        File file = new File("filemodule\\aaa");
        if(!file.exists()){
            //如果文件夹不存在,就创建出来
            file.mkdirs();
        }
        File newFile = new File(file,"a.txt");
        newFile.createNewFile();
    }
}

案例2：删除一个多级文件夹

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        File src = new File("C:\\Users\\apple\\Desktop\\src");
        deleteDir(src);
    }

    private static void deleteDir(File src) {
        //1.进入 --- 得到src文件夹里面所有内容的File对象.
        File[] files = src.listFiles();
        //2.遍历 --- 因为我想得到src文件夹里面每一个文件和文件夹的File对象.
        for (File file : files) {
            if(file.isFile()){
                //3.判断 --- 如果遍历到的File对象是一个文件,那么直接删除
                file.delete();
            }else{
                deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
            }
        }
        //最后再删除这个文件夹
        src.delete();
    }
}

案例3：统计一个文件夹中每种文件的个数并打印
- 打印格式如下：txt:3个，doc:4个，jpg:6个

import java.io.File;
import java.util.HashMap;

public class Test3 {
    public static void main(String[] args) {
        File file = new File("filemodule");
        HashMap<String, Integer> hm = new HashMap<>();
        getCount(hm, file);
        System.out.println(hm);
    }

    private static void getCount(HashMap<String, Integer> hm, File file) {
        File[] files = file.listFiles();
        for (File f : files) {
            if(f.isFile()){
                String fileName = f.getName();
                String[] fileNameArr = fileName.split("\\.");
                if(fileNameArr.length == 2){
                    String fileEndName = fileNameArr[1];
                    if(hm.containsKey(fileEndName)){
                        //将已经出现的次数获取出来
                        Integer count = hm.get(fileEndName);
                        //这种文件又出现了一次.
                        count++;
                        //把已经出现的次数给覆盖掉.
                        hm.put(fileEndName,count);
                    }else{
                        //不存在
                        //表示当前文件是第一次出现
                        hm.put(fileEndName,1);
                    }
                }
            }else{
                getCount(hm,f);
            }
        }
    }
}

二、字节流

1、IO流概述

IO流介绍：
- IO：输入/输出(Input/Output)
- 流：是一种抽象概念,是对数据传输的总称.也就是说数据在设备间的传输称为流,流的本质是数据传输
- IO流就是用来处理设备间数据传输问题的；常见的应用：文件复制、文件上传、文件下载
IO流的分类
- 按照数据的流向
  - 输入流：读数据
  - 输出流：写数据
- 按照数据类型来分
  - 字节流：字节输入流、字节输出流
  - 字符流：字符输入流、字符输出流
IO流的使用场景
- 如果操作的是纯文本文件，优先使用字符流（能使用记事本打开不会乱码的才是纯文本文件）
- 如果操作的是图片、视频、音频等二进制文件，优先使用字节流
- 如果不确定文件类型，优先使用字节流，字节流是万能的流

2、字节输出流

字节输出流：FileOutputStream(String name) -> 创建文件输出流以指定的名称写入文件

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

public class OutputDemo2 {
    public static void main(String[] args) throws IOException {
        //1.创建字节输出流的对象
             //注意点:如果文件不存在,会帮我们自动创建出来
             //       如果文件存在,会把文件清空
        FileOutputStream fos = new FileOutputStream("C:\\itheima\\a.txt");
        //2,写数据：传递一个整数时,那么实际上写到文件中的,是这个整数在码表中对应的那个字符
        fos.write(98);
        //3,释放资源
        fos.close(); //告诉操作系统,我现在已经不要再用这个文件了
    }
}

字节流写数据的三种方式

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

public class OutputDemo3 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
        fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.close();
    }
}

public class OutputDemo4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
        byte [] bys = {97,98,99};
        fos.write(bys); //write(byte[] b)
        byte [] bys = {97,98,99,100,101,102,103};//write(byte[] b, int off, int len)
        fos.write(bys,1,2);
        fos.close();
    }
}

字节流写数据如何实现换行
- windows:\r\n
- linux:\n
- mac:\r
字节流写数据如何实现追加写入
- public FileOutputStream(String name,boolean append)：创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

public class OutputDemo5 {
    public static void main(String[] args) throws IOException {
        //第二个参数就是续写开关,如果没有传递,默认就是false,
        //表示不打开续写功能,那么创建对象的这行代码会清空文件.
        //如果第二个参数为true,表示打开续写功能
        //那么创建对象的这行代码不会清空文件
        FileOutputStream fos = new FileOutputStream("bytestream\\a.txt",true);
        fos.write(97);
        //能加一个换行
        fos.write("\r\n".getBytes());
        fos.write(98);
        fos.write("\r\n".getBytes());
        fos.write(99);
        fos.write("\r\n".getBytes());
        fos.close();
    }
}

字节流写数据加异常处理

public class OutputDemo6 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //System.out.println(2/0);
            fos = new FileOutputStream("D:\\a.txt");
            fos.write(97);
        }catch(IOException e){
           e.printStackTrace();
        }finally {
            //finally语句里面的代码,一定会被执行
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3、字节输入流

字节输入流：FileInputStream(String name) -> 通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名

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

public class OutputDemo7 {
    public static void main(String[] args) throws IOException {
        //如果文件存在,那么就不会报错.
        //如果文件不存在,那么就直接报错.
        FileInputStream fis = new FileInputStream("bytestream\\a.txt");
        int read = fis.read();
        //一次读取一个字节,返回值就是本次读到的那个字节数据.
        //也就是字符在码表中对应的那个数字.
        //如果我们想要看到的是字符数据,那么一定要强转成char
        System.out.println((char)read);
        //释放资源
        fis.close();
    }
}

字节输入流读取多个字节
- 文件读取到结束返回-1，也就是说-1是文件结束标记

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

public class OutputDemo8 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("bytestream\\a.txt");
        //1,文件中多个字节我怎么办?
        /*while(true){
            int i1 = fis.read();
            System.out.println(i1);
        }*/
        int b;
        while ((b = fis.read())!=-1){
            System.out.println((char) b);
        }
        fis.close();
    }
}

案例：文件复制

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

public class OutputDemo9 {
    public static void main(String[] args) throws IOException {
        //创建了字节输入流,准备读数据.
        FileInputStream fis = new FileInputStream("C:\\itheima\\a.avi");
        //创建了字节输出流,准备写数据.
        FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");
        int b;
        while((b = fis.read())!=-1){
            fos.write(b);
        }
        fis.close();
        fos.close();
    }
}

案例：文件复制效率优化
- 上面的文字复制案例，读1个字节写1个字节，如果是大文本的拷贝，效率非常慢
- 优化：每次读写多个字节，提高拷贝效率

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

public class OutputDemo9 {
    public static void main(String[] args) throws IOException {
        //创建了字节输入流,准备读数据.
        FileInputStream fis = new FileInputStream("C:\\itheima\\a.avi");
        //创建了字节输出流,准备写数据.
        FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");
		//读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }
        fis.close();
        fos.close();
    }
}

三、字节缓冲流

字节缓冲流介绍：提高读写的效率
- lBufferOutputStream：该类实现缓冲输出流.通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
- lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组.当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
字节缓冲流构造方法
- 字节缓冲流仅仅提供缓冲区（提高效率），而真正的读写数据还是基本的字节流对象实现的
方法名说明
BufferedOutputStream(OutputStream out) 创建字节缓冲输出流对象
BufferedInputStream(InputStream in) 创建字节缓冲输入流对象
字节缓冲流一次读写一个字节

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

      //字节缓冲流一次读写一个字节
      public static void method1() throws IOException {
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
          int by;
          while ((by=bis.read())!=-1) {
              bos.write(by);
          }
          bos.close();
          bis.close();
      }

字节缓冲流一次读写一个字节数组

      //字节缓冲流一次读写一个字节数组
      public static void method2() throws IOException {
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
          byte[] bys = new byte[1024];
          int len;
          while ((len=bis.read(bys))!=-1) {
              bos.write(bys,0,len);
          }
          bos.close();
          bis.close();
      }