十六、File文件流和JDK1.7新特性之IO简化关流

1. File文件流的概述

文件和目录路径名的抽象表示形式。

封装一个磁盘路径字符串，对这个路径可以执行一次操作。

可以用来封装文件路径、文件夹路径、不存在的路径。

2. 创建对象

File(String pathname)

通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

3. 常用方法

文件、文件夹属性

length()：文件的字节量

exists()：是否存在，存在返回true

isFile()：是否为文件，是文件返回true

isDirectory()：是否为文件夹，是文件夹返回true

getName()：获取文件/文件夹名

getParent()：获取父文件夹的路径

getAbsolutePath()：获取文件的完整路径

创建、删除

createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false

mkdirs()：新建多层不存在的文件夹\a\b\c

mkdir()：新建单层不存在的文件夹\a

delete()：删除文件，删除空文件夹

文件夹列表

list()：返回String[]，包含文件名

listFiles()：返回File[]，包含文件对象

4. 案例测试常用方法

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
 
import org.junit.Test;
 
//测试文件类
public class TestFile {
       //Junit单元测试方法：
       //@Test + public + void + 没有参数
       @Test
       public void show() throws IOException {
              //1，创建File对象，读取了指定位置的文件
              File f = new File("D:\\teach\\a");
             
              //文件夹列表list() listFiles()
              String[] names = f.list();
              System.out.println(Arrays.toString(names));
             
              File[] files = f.listFiles();//推荐，更常见
              System.out.println(Arrays.toString(files));
             
             
              //TODO常用方法
              System.out.println(f.createNewFile());//新建文件，文件夹不存在会异常，文件已经存在返回false
              System.out.println(f.mkdir());//新建单层不存在的文件夹
              System.out.println(f.mkdirs());//新建多层不存在的文件夹
              System.out.println(f.delete());//删除文件，删除空文件夹
             
              System.out.println();
             
              System.out.println(f.length());//文件的字节量
              System.out.println(f.exists());//是否存在，存在返回true
              System.out.println(f.isFile());//是否为文件，是文件返回true
              System.out.println(f.isDirectory());//是否为文件夹，是文件夹返回true
              System.out.println(f.getName());//获取文件/文件夹名
              System.out.println(f.getParent());//获取父文件夹的路径
              System.out.println(f.getAbsolutePath());//获取文件的完整路径
             
       }
}

5. 案例递归求目录总大小

递归：不断的调用方法本身。

递归：统计文件大小，删除文件
求目录的总大小：
1、把指定目录封装成File对象
2、把文件夹列表列出来
3、判断，如果是文件，直接把f.length()相加
4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加…
5、如果是文件夹，递归调用方法本身的业务逻辑

import java.io.File;
import org.junit.Test;
//递归求目录总大小
public class TestFile {
       public static void main(String[] args) {
//           1、把指定目录封装成File对象
              File file = new File("D:\\teach\\a");
              int size =count(file);
              System.out.println(size);
       }
     
       private static int count(File file) {
//           2、把文件夹列表列出来
              File[] files = file.listFiles();
             
              //2.1 遍历数组里的每个资源
              int sum = 0;//记录文件的大小
              for (int i = 0; i < files.length; i++) {
//           3、判断，如果是文件，直接把f.length()相加
// files[i]表示每次遍历到的资源
                      if(files[i].isFile()) {
                            sum += files[i].length();//求文件的和
                      }else if(files[i].isDirectory()){
//           4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加......
//           5、如果是文件夹，递归调用方法本身的业务逻辑
                            sum += count(file[i]);//把当前遍历到的文件夹继续循环判断求和
                      }
              }       
              return sum ;
       }
      
      
}

6. JDK1.7新特性之IO关流

try( ){ }catch(){ }

private static void customBufferStreamCopy(File source, File target) {
    InputStream fis = null;
    OutputStream fos = null;
    try {
        fis = new FileInputStream(source);
        fos = new FileOutputStream(target);
 
        byte[] buf = new byte[8192];
 
        int i;
        while ((i = fis.read(buf)) != -1) {
            fos.write(buf, 0, i);
        }
    }
    catch (Exception e) {
        e.printStackTrace();
    } finally {
        close(fis);
        close(fos);
    }
}
 
private static void close(Closeable closable) {
    if (closable != null) {
        try {
            closable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 
上述代码对于异常处理十分复杂，
对于资源的关闭也很麻烦，那么可以和下面的进行对比：
private static void customBufferStreamCopy(File source, File target) {
    try (InputStream fis = new FileInputStream(source);
        OutputStream fos = new FileOutputStream(target)){
 
        byte[] buf = new byte[8192];
 
        int i;
        while ((i = fis.read(buf)) != -1) {
            fos.write(buf, 0, i);
        }
    }
    catch (Exception e) {
        e.printStackTrace();
    }
}