深入理解Java——IO

文件类

java.io.File类是文件和目录路径名的抽象表示。以下是有关文件的要点：

• 实例表示实际的文件系统对象，如文件或目录。如果是这样表示这样一个对象，然后该对象位于一个分区。分区是存储为文件系统的操作系统的特定部分。
• 文件系统可以实现限制某些操作的实际文件系统对象，如读，写，和执行上。这些限制统称为访问权限。
• File类的实例是不可变的;也就是说，一旦创建，由一个File对象表示的抽象路径名是不会改变的。

类的声明

以下是声明 java.io.File 类：

public class File
    extends Object
        implements Serializable, Comparable<File>

字段

• static String pathSeparator – 这是系统相关的路径分隔符，表示为一个字符串以方便使用。
• static char pathSeparatorChar – 这是依赖于系统的路径分隔符。
• static String separator – 这是与系统有关的默认名称分隔符，表示为一个字符串以方便使用。
• static char separatorChar – 这是与系统有关的默认名称分隔符。

public class FileExample {

    public static void createFile() {
        System.out.println(File.pathSeparator);  
        System.out.println(File.pathSeparatorChar);
        System.out.println(File.separator);
        System.out.println(File.separatorChar);
    }
}

输出结果：

;
;
\
\

示例

package io;

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

/**
 * Created by JoJo on 2016/8/11.
 */
public class FileExample {

    public static void main(String[] args) throws IOException {
        createFile();
    }

    public static void createFile() throws IOException {
        File file = new File("D:/software/1.txt");
        System.out.println(file.canExecute()); // 表示是否可以执行表示此抽象路径的文件
        System.out.println(file.canRead()); // 表示是否可以读取表示此抽象路径的文件
        System.out.println(file.canWrite()); // 表示是否可以修改表示此抽象路径名的文件

        if (!file.exists()) { // 表示此抽象路径名与给定对象是否相等
            file.createNewFile(); // 表示此文件不存在时创建一个新的文件
        }
        System.out.println(file.getName()); // 返回由此抽象路径名表示的文件或目录的名称。
        System.out.println(file.getParent()); // 返回此抽象路径名的父路径名的字符串格式，或者null，如果此路径名没有指定父目录。
        System.out.println(file.list()) // 若此file为目录，则返回文件夹中的文件数组对象
        System.out.println(file.getParentFile()); // 返回此抽象路径名的父抽象路径名，或者null，如果此路径名没有指定父目录。
        System.out.println(file.getTotalSpace()/(1024*1024*1024) + "G"); // 返回此抽象路径名的分区的大小，单位为k,本例为 D盘分区
    }
}

实例1

将一个文件夹下的多个文本文件拷贝到另外一个文件夹下

将D:/file1 中的1.txt和2.txt拷贝到D:/file2下

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;



public class FileCopy {
    public static void main(String[] args) {
        File file = new File("D:/file1");
        File file2 = new File("D:/file2");

        String[] list = file.list();
        for (int i = 0; i < list.length; i++) {
            File childFile = new File(file.getPath() + "/" + list[i]);
            FileInputStream fileInputStream = null;
            InputStreamReader inputStreamReader = null;
            BufferedReader bufferedReader = null;

            FileOutputStream fileOutputStream = null;
            OutputStreamWriter outputStreamWriter = null;
            BufferedWriter bufferedWriter = null;
            try {
                // 通过一个实际文件的连接来创建文件字节流
                fileInputStream = new FileInputStream(childFile);

                // 字节流和字符流之间的桥梁，而且可以在构造其中表明编码格式
                inputStreamReader = new InputStreamReader(fileInputStream,"gbk");

                // 将字节流转换为缓冲字符流，读取效率高
                bufferedReader = new BufferedReader(inputStreamReader);

                // 同上
                fileOutputStream = new FileOutputStream(file2 + "/" + list[i]);
                outputStreamWriter = new OutputStreamWriter(fileOutputStream, "gbk");
                bufferedWriter = new BufferedWriter(outputStreamWriter);

                String readLine = null;
                while ((readLine = bufferedReader.readLine()) != null) {
                    bufferedWriter.write(readLine);
                    bufferedWriter.newLine();
                    // bufferedWriter.flush(); 手动调用该方法可以刷新缓冲区，并将数据写进文件，若不调用，在执行bufferedWriter.close()的时候也会自动调用该方法
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (bufferedWriter != null) {
                    try {
                        bufferedWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (outputStreamWriter != null) {
                    try {
                        outputStreamWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fileOutputStream != null) {
                    try {
                        fileOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStreamReader != null) {
                    try {
                        inputStreamReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fileInputStream != null) {
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}