[Java知识库]Day_22【Java基础】File类和I/O流【附源码】

一.File类

I/O流可以对文件的内容进行操作，但对文件本身的一些常规操作无法通过I/O流实现，如文件的创建、删除、重命名等操作，判断硬盘上某个文件是否存在等操作，为此JDK在java.io包下提供了一个FIle类，该类封装了一个路径，并提供了一系列方法：
1.常用构造方法

File file = new File("File.txt");//相对路径（相对于当前module）
System.out.println(file);//File.txt
File file1 = new File("E:\\java\\javaSenior\\Day_08\\hello.txt");//绝对路径：从计算机盘符开始
System.out.println(file1);//E:\java\javaSenior\Day_08\hello.txt
File file2 = new File("E:\\java\\javaSenior", "Day_08");
System.out.println(file2);//E:\java\javaSenior\Day_08
File file3 = new File(file2, "java.txt");
System.out.println(file3);//E:\java\javaSenior\Day_08\java.txt

路径分隔符：在java中"\ “需要转译，因此java程序中表示路径会多出来一个”\ "。

2.常用方法
（1）File类的获取功能

@Test
//File类的获取功能--->常见方法
public void test01(){
    File file = new File("hello.txt");
    File file1 = new File("E:\\java\\javaSenior\\he.txt");
    System.out.println(file.getAbsoluteFile());//public String getAbsoluteFile()：获取绝对名称
    System.out.println(file.getAbsolutePath());//public String getAbsolutePath()：获取绝对路径
    System.out.println(file.getPath());//public String getPath()：获取相对路径
    System.out.println(file.getParent());//public String getParent()：获取上层目录路径，若无，返回null
    System.out.println(file.getName());//public String getName()：获取名称
    System.out.println(new Date(file.lastModified()));//public long lastModified()：获取最近修改的时间
    System.out.println(file.length());//public long length()：获取文件长度（返回字节数)
    System.out.println("**********************************");
    System.out.println(file1.getAbsoluteFile());//public String getAbsoluteFile()：获取绝对名称
    System.out.println(file1.getAbsolutePath());//public String getAbsolutePath()：获取绝对路径
    System.out.println(file1.getPath());//public String getPath()：获取相对路径
    System.out.println(file1.getParent());//public String getParent()：获取上层目录路径，若无，返回null
    System.out.println(file1.getName());//public String getName()：获取名称
    System.out.println(new Date(file1.lastModified()));//public long lastModified()：获取最近修改的时间
    System.out.println(file1.length());//public long length()：获取文件长度（返回字节数)
    File file2 = new File("E:\\java\\javaSenior");
    String[] list = file2.list();//public String[] list：获取指定目录下的所有文件或者文件目录的名称数组
    for(String s : list){
        System.out.println(s);
    }
    System.out.println("---------------------------------");
    File[] files = file2.listFiles();//public File[] listFiles：获取指定目录下的所有文件或者文件目录的File数组
    for(File f : files){
        System.out.println(f);
    }
}

（2）File的重命名功能

@Test
//File的重命名功能，执行完以后，dest文件被创建，内容是file文件的内容，file文件本身被删除
public void test02(){
    File file = new File("E:\\java\\javaSenior\\hello.txt");
    File file1 = new File("E:\\JAVA EE\\java.txt");
    //public boolean renameTo(File dest)：把文件重命名为指定的文件路径，想返回true，文件fiel存在，dest文件不存在
    boolean b = file.renameTo(file1);
    System.out.println(b);
}

（3）File的判断功能

@Test
//File类的判断功能
public void test03(){
    File file = new File("E:\\JAVA EE\\java.txt");
    System.out.println(file.exists());//public boolean exits()：文件/目录是否存在
    System.out.println(file.isFile());//public boolean isFile()：文件/目录是否是文件
    System.out.println(file.isDirectory());//public boolean isDirectory()：文件/目录是否是目录
    System.out.println(file.canRead());//public boolean canRead()：文件/目录是否可读
    System.out.println(file.canWrite());//public boolean canWrite()：文件/目录是否可写
    System.out.println(file.isHidden());//public boolean isHidden()：文件/目录是否隐藏
}

（4）File类的创建、删除功能

@Test//文件的创建和删除
public void test04() throws IOException {
    File file = new File("E:\\JAVA EE\\java_EE.txt");
    if(file.exists()){
        file.delete();//public boolean delete()：删除文件（不经过回收站）
        System.out.println("创建时文件存在，已被删除...");
    }else{
        file.createNewFile();//public boolean createNewFile()：创建文件
        System.out.println("创建时文件不存在，现已创建...");
    }
}

@Test//创建文件目录
public void test05(){
    File file = new File("E:\\JAVA EE\\IeaProjeect\\11\\22");
    boolean mkdir = file.mkdir();//public boolean mkdir()：创建单层文件目录（只创建一层情况）
    if(mkdir){
        System.out.println("mkdir创建成功...");
    }
    boolean mkdirs = file.mkdirs();//public boolean mkdirs()：创建多层文件目录
    if(mkdirs){
        System.out.println("mkdirs创建成功...");
    }
}

注意：创建时文件的路径会因为是单元测试或main()方法而不同。

public class FileReaderTest {
    public static void main(String[] args) {//main()方法是相对于整个项目而言的
        File file = new File("Day_09\\Hello.txt");//
        System.out.println(file.getAbsolutePath());//E:\java\javaSenior\Day_09\Hello.txt
        File file1 = new File("Hello.txt");
        System.out.println(file1.getAbsolutePath());//E:\java\javaSenior\Hello.txt
    }
    @Test
    public void test01(){//单元测试是相对于module而言的
        File file = new File("Hello.txt");
        System.out.println(file.getAbsolutePath());
    }
}

二.I/O流

I/O流（Input/Output）流，即输入输出流，是Java中输入输出的基础，用于处理设备之间的数据传输。如：读/写文件，网络通讯等。

对于文本文件（.txt，.java，.c，.cpp等），使用字符流处理。文本文件的复制也可使用字节流。
对于非文本文件（.jpg，.mp3 ，.mp4，.avi，.doc , .ppt等），使用字节流处理。

三.字符流的使用

1.FileReader字符流读入数据
读入时的目标文件必须创建，不存在时会报错。

@Test
//FileReader读入数据
public void test01(){//单元测试是相对于module而言的
    //1.实例化需要操作的的文件对象
    File file = new File("Hello.txt");
    FileReader fileReader = null;
    try{//选择try-catch捕获异常而不是抛出异常，原因是若因为异常导致程序异常终止，文件相关的流操作没有关闭会浪费JVM内存资源
        //2.指定操作文件的流的实例化
        fileReader = new FileReader(file);
        //3.读入数据
        int len = 0;
        while ((len = fileReader.read())!=-1){//读取至数据末尾时返回-1
            System.out.print((char)len);
        }
    }catch (Exception e){
        System.out.println(e.getMessage());
    }finally {
        if(fileReader!=null){
            try {
                //4.关闭流
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

以上操作效率太低，对该方法改进如下：

@Test
//FileReader读入数据改进
public void test02() {
    File file = new File("Hello.txt");
    FileReader fileReader = null;
    try{//选择try-catch捕获异常而不是抛出异常，原因是若因为异常导致程序异常终止，文件相关的流操作没有关闭会浪费JVM内存资源
        fileReader = new FileReader(file);
        //read(char[] cbuff)：返回每次读入cbuff中的字符个数。
        char[] buffer = new char[1024];
        int len = 0;
        while((len=fileReader.read(buffer))!=-1){
            //方式1
            for(int i=0;i<len;i++){
                System.out.print(buffer[i]);
            }
            System.out.println();
            //方式2
            java.lang.String s = new java.lang.String(buffer, 0, len);
            System.out.print(s);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        if(fileReader != null){
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.FileWirter字符流写出数据
写出时的目标文件不存在也可以，会自动创建。

@Test
public void test03(){
    //1.创建File对象指明要操作的文件
    File file = new File("HelloWorld.txt");
    //2.创建FileWriter对象
    FileWriter fileWriter = null;
    try{//选择try-catch捕获异常而不是抛出异常，原因是若因为异常导致程序异常终止，文件相关的流操作没有关闭会浪费JVM内存资源
        fileWriter = new FileWriter(file,true);//true表示追加操作，false表示覆盖
        //3.写入数据
        fileWriter.write("I have a dream!\n");
        fileWriter.write(97);
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        //4.关闭流
        if(fileWriter!=null){
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.FileWriter和FileReader实现文件的复制操作

@Test
public void copytest(){
	//1.创建需要操作的文件
    File file = new File("HelloWorld.txt");
    File file1 = new File("copyHelloWorld.txt");
    //2.创建FileReader和FileWriter读写对象
    FileWriter fw = null;
    FileReader fr = null;
    try{
        fw = new FileWriter(file1);
        fr = new FileReader(file);
         //3.先读取数据，后写入数据
        char[] cbuffer = new char[1024];
        int len = 0;
        while((len = fr.read(cbuffer))!=-1){
            fw.write(cbuffer,0,len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
    //4.关闭对应的流（顺序不管）
        try{
            fw.close();
        }catch (IOException e){
            e.printStackTrace();
        }
//            finally//方式2：写在finally中也对
//            {
            try{
                fr.close();
            }catch (IOException e){
                e.printStackTrace();
            }
//            }
    }
}

四.字节流的使用

使用FileInputStream和FileOutputStream实现非文本的复制：

@Test
public void test03() {
    String file1 = "C:\\Users\\Administrator\\Desktop\\面向对象\\代理模式.png";
    String file2 = "C:\\Users\\Administrator\\Desktop\\面向对象\\代理模式1.png";
    long start = System.currentTimeMillis();
    InputOutputStreamCopy(file1,file2);
    long end = System.currentTimeMillis();
    System.out.println("复制用时："+(end-start));
}
//InputOutputStreamCopy(String file1, String file2)：文件的复制操作（可以是文本或非文本的文件）
public void InputOutputStreamCopy(String file1, String file2){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try{
        fis = new FileInputStream(file1);
        fos = new FileOutputStream(file2);
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        try{
            fos.close();
        }catch (IOException e){
            e.printStackTrace();
        }
        try{
            fis.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

五.缓冲流的使用

字节流、字符流的操作效率不高，缓冲流可以提高对文件读取、写入的速度。
原因：内部提供了一个缓冲区
BufferedOutputStream和BufferedWriter还有个flush()方法，执行此方法，缓冲区的内容将被清空。
1.字节缓冲流实现文件的复制操作

@Test
public void test03(){
    String file = "E:\\java\\javaSenior\\Day_09\\HelloWorld.txt";
    String file1 = "E:\\java\\javaSenior\\Day_09\\HelloWorld03.txt";
    long start = System.currentTimeMillis();
    copyWithBuffer(file,file1);
    long end = System.currentTimeMillis();
    System.out.println("复制用时："+(end-start));
}
public void copyWithBuffer(String file1, String file2){
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try{
        //2.创建流
        //2.1创建字节流
        FileInputStream fis  = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);
        //2.2创建缓冲流
        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);
        //3.实现复制操作
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len=bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {//关闭外层流时内层流也会默认关闭
        if(bos!=null){
            try{
                bos.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        if(bis!=null){
            try{
                bis.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

2.字符缓冲流实现文件的复制
里面有一个特有的readLine()方法（不换行），newLine()可用于换行。

@Test
//字符缓冲流实现文件的复制
public void test01(){
    BufferedReader br = null;
    BufferedWriter bw = null;
    try{
        br = new BufferedReader(new FileReader(new File("E:\\java\\javaSenior\\Day_09\\壁纸.jpg")));
        bw = new BufferedWriter(new FileWriter(new File("E:\\java\\javaSenior\\Day_09\\壁纸02.jpg")));
        int len = 0;
        //方式1：使用字符数组
//        char[] buffer = new char[1024];
//        while ((len = br.read(buffer))!=-1){
//            bw.write(buffer,0,len);
//        }
        //方式2：使用String
        String data;
        while ((data=br.readLine())!=null){//readLine()默认不换行输出
            bw.write(data+"\n");//方式1换行
            bw.write(data);
//            bw.newLine();//方式2换行
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        if(bw!=null){
            try{
                bw.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        if(br!=null){
            try{
                bw.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

六.转换流

转换流属于字符流。目的是提供字节流和字符流的转换。
InputStreamReader：将一个字节输入流转换为字符输入流
OutputStreamWriter：将一个字节输出流转换为字符输出流
解码：字节、字节数组—>字符串、字符数组
编码：字符串、字符数组—>字节、字节数组

@Test
//字节的输入流转换为字符额输入流
public void test02(){
    //1.创建字节输入流对象
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(new File("E:\\java\\javaSenior\\Day_09\\Hello.txt"));
        //2.将字节输入流对象转换为字符输入流对象
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");//此时的编码格式是文件的格式，否则会乱码，在本次测试中，若使用gbk的编码格式，中文就会乱码
        char[] buffer = new char[1024];
        int len;
        while ((len=isr.read(buffer))!=-1){
            String str = new String(buffer,0,len);
            System.out.println(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis!=null){
            try{
                fis.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
} 

@Test
//转换流实现文件的复制
public void InputStreamReaderTest(){
    InputStreamReader isr = null;
    OutputStreamWriter osw = null;
    try {
        FileInputStream fis = new FileInputStream(new File("E:\\java\\javaSenior\\Day_09\\HelloWorld01.txt"));
        FileOutputStream fos = new FileOutputStream(new File("E:\\java\\javaSenior\\Day_09\\HelloWorld04.txt"));
        isr = new InputStreamReader(fis,"utf-8");
        osw = new OutputStreamWriter(fos,"utf-8");
        char[] buffer = new char[1024];
        int len ;
        while((len=isr.read(buffer))!=-1){
            osw.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(isr!=null){
            try {
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(osw!=null){
            try {
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习

@Test
//文件的加密操作，解密也是如此
public void testSecret(){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try{
        fis = new FileInputStream(new File("E:\\java\\javaSenior\\Day_09\\壁纸.jpg"));
        fos = new FileOutputStream(new File("E:\\java\\javaSenior\\Day_09\\加密壁纸.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            for(int i=0;i<len;i++){
                buffer[i] = (byte) (buffer[i] ^ 5);//异或操作，加密和解密一样，无需修改
            }
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally{
        if(fis!=null){
            try{
                fis.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
        if(fos!=null){
            try{
                fos.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}