在日常的开发中，经常会遇到对本地文件进行操作的功能，例如将数据库中的数据导出成Excel并保存在本地，或者将本地的文本文件读入程序中，再或者在本地新建目录删除目录等等。这些都需要对本地文件进行读写。

Java为开发者提供了File类用于操作本地的文件，File类是java.io包下代表与平台无关的文件和目录，也就是说，如果希望在程序中操作文件和目录，都可以通过File类来完成。值得指出的是，不管是文件还是目录都是使用File来操作的，File能新建、删除、重命名文件和目录，File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

访问文件和目录

File类可以使用文件路径字符串来创建File实例，该文件路径字符串既可以是绝对路径，也可以是相对路径。一旦创建了File对象后，就可以调用File对象的方法来访问，File类提供了很多方法来操作文件和目录，下面列出一些比较常用的方法。

访问文件名

方法

描述

String getName()

返回File对象的文件名或者路径名

String getPath()

返回File对象对应的路径名

File getAbsoluteFile()

返回File对象的绝对路径

String getAbsolutePath()

返回File对象的绝对路径名

String getParent()

返回File对象的父目录

boolean renameTo(File newName)

重命名文件

下面通过示例来学习以上方法的使用：

package cn;import java.io.File;public class bytecollege {    public static void main(String[] args) {        String path = "E:/ByteCollege/study/Node.exe";        File file = new File(path);        File newFile = new File("E:/ByteCollege/study/Code.exe");        //返回File对象的文件名或者路径名        System.out.println(file.getName());        //返回File对象对应的路径名        System.out.println(file.getPath());        //返回File对象的绝对路径        System.out.println(file.getAbsoluteFile());        //返回File对象的绝对路径名        System.out.println(file.getAbsolutePath());        //返回File对象的父亲目录        System.out.println(file.getParent());        //重命名文件        file.renameTo(newFile);    }}

运行后的结果为：

14.1.2 文件检测相关方法

方法

描述

boolean exists()

判断File对象所对应的文件或目录是否存在

boolean canWrite()

判断文件和目录是否可写

boolean canRead()

判断文件和目录是否可读

boolean isFile()

判断是否是文件

boolean isDirectory()

判断是否是目录

boolean isAbsolute()

判断是否是绝对路径

boolean isHidden()

判断文件是否隐藏

下面通过示例来学习以上方法的使用：

package cn.bytecollege.IODemo;import java.io.File;public class FileDemo {    public static void main(String[] args) {        File file = new File("D:/BYTE/study/Node.txt");        //判断File对象所对应的文件或目录是否存在        System.out.println(file.exists());        //判断文件和目录是否可写        System.out.println(file.canWrite());        //判断文件和目录是否可读        System.out.println(file.canRead());        //判断是否是文件        System.out.println(file.isFile());        //判断是否是目录        System.out.println(file.isDirectory());        //判断是否是绝对路径        System.out.println(file.isAbsolute());        //判断文件是否隐藏        System.out.println(file.isHidden());    }}

方法

描述

long lastModified()

最后一次修改时间，返回值为修改时间的毫秒数

long length()

获取文件长度，单位为字节

下面通过示例来学习以上方法的使用：

package cn.bytecollege.IODemo;import java.io.File;public class FileDemo2 {    public static void main(String[] args) {        File file = new File("D:/BYTE/study/Node.txt");        System.out.println(file.lastModified());        System.out.println(file.length());    }}

运行后的结果为：

目录操作

方法

描述

boolean mkdir()

创建新目录

boolean mkdirs()

创建多层目录

String[] list()

列出File对象子文件名和路径名，返回String数组

File[] listFiles()

列出File对象的索引子文件和路径

static File[] listRoots()

获取系统根路径

boolean delete()

删除文件或者路径，如果有多层路径，调用1次只删除最后一层目录，并且目录必须为空

下面通过示例来学习以上方法的使用：

package cn.bytecollege.IODemo;import java.io.File;public class FileDemo3 {    public static void main(String[] args) {        File file = new File("D:/BYTE/study/Node.txt");        File file2 = new File("D:/BYTE/study/code");        //创建新目录        file2.mkdir();        //创建多层目录        file2.mkdirs();        //列出File对象子文件名和路径名，返回String数组        file2.list();        //列出File对象的索引子文件和路径        file.listFiles();        //获取系统根目录        file.listRoots();    }}

方法

描述

long getTotalSpace()

获取分区大小

long getFreeSpace()

获取分区空闲大小

long getUsableSpace()

获取分区可用大小

package cn.bytecollege.IODemo;import java.io.File;public class FileDemo4 {    public static void main(String[] args) {        String path = "D:/";        File file = new File(path);        //获取分区大小        System.out.println(file.getTotalSpace());        //获取分区空闲大小        System.out.println(file.getFreeSpace());        //获取分区可用空间大小        System.out.println(file.getUsableSpace());    }}

运行后的结果为：

Java中的I/O流

Java中I/O流是实现输入/输出的基础，可以方便的实现输入和输出操作，Java中把不同的输入/输出源抽象表述为“流”，通过流的方式运行Java程序使用相同的方式来访问不同的输入/输出源，这里的流可以理解为字节序列，通俗一点说就是一串0和1。

流的分类

流的分类可以从以下两个角度划分：

流向：按照流的流向来分可以分为输入流和输出流，其中输入流只能从中读取数据，而不能向其写入数据；输出流只能向其写入数据，而不能从中读取数据。读取单元：按照读取单元划分，流可以分为字节流和字符流，顾名思义所谓字节流就是输入和输出的基本单位都是字节，而字符流输入输出的基本单元都是字符。

上面提到的输入和输出都涉及到方向的问题，这里的输入和输出都是从程序运行所在的内存角度划分的，也就是说从硬盘或者网络读取到程序运行内存中的流叫做输入流，反之从内存中写入硬盘的流则叫做输出流，换句话说，输入流和输出流都是以当前程序运行的内存作为参照物。

Java中输入流主要使用InputStream和Reader作为基类，而输出流主要使用OutputStream和Writer作为基类，它们都是一些抽象类，无法直接创建实例。

流的概念模型

Java把所有设备里的有序数据抽象成流模型，简化了输入/输出处理，理解了流的概念模型也就了解了Java IO。

Java中有关IO流的类都是从如下4个抽象类中派生的。

InputStream/Reader：所有输入流的基类，前者是字节输入流，后者是字符输入流。OutputStream/Writer：所有输出流的基类，前者是字节输出流，后者是字符输出流。

对于InputStream和Reader而言，它们把输入设备抽象成一个“水管”，这个水管里的每个“水滴”依次排列，如下图所示：

字节流和字符流的处理方式其实非常相似，只是它们处理的输入/输出单位不同而已。输入流使用隐式的记录指针来表示当前正准备从哪个“水滴”开始读取，每当程序从InputStream或Reader里取出一个或多个“水滴”后，记录指针自动向后移动；除此之外，InputStream和Reader里都提供一些方法来控制记录指针的移动。

对于OutputStream和Writer而言，它们同样把输出设备抽象成一个“水管”，只是这个水管里没有任何水滴。

当执行输出时，程序相当于依次把“水滴”放入到输出流的水管中，输出流同样采用隐式的记录指针来标识当前水滴即将放入的位置，每当程序向OutputStream或Writer里输出一个或多个水滴后，记录指针自动向后移动。

字节流InputStream

InputStream是输入流的基类，读取的最小单元是字节。由于InputStream是抽象类，所以其本身并不能创建实例来执行输入。但它们将成为所有输入流的模板，所以它们的方法是所有输入流都可使用的方法。

InputStream里包含如下方法：

int read()：从输入流中读取单个字节（相当于从如图所示的水管中取出一滴水），返回所读取的字节数据（字节数据可直接转换为int类型）。int read(byte[]b)：从输入流中最多读取b.length个字节的数据，并将其存储在字节数组b中，返回实际读取的字节数。int read(byte[]b,int off,int len)：从输入流中最多读取len个字节的数据，并将其存储在数组b中，放入数组b中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字节数。

InputStream有个子类用于读取文件的输入流：FileInputStream，下面的程序将示范FileInputStream的使用。

package cn.bytecollege.IODemo;import java.io.File;import java.io.FileInputStream;import java.io.IOException;public class FileDemo5 {    public static void main(String[] args) {        String path = "D:/BYTE/study/Node.txt";        FileInputStream fileInputStream = null;        File file = new File(path);        try{            fileInputStream = new FileInputStream(file);            byte[] ch = new byte[1024];            int length;            while ((length = fileInputStream.read(ch)) != -1){                System.out.println(new String(ch));            }        } catch (IOException e) {            e.printStackTrace();        }    }}

运行后的结果为：

OutputStream

OutputStream是输出流的基类，输入的最小单元是字节。它提供了如下方法：

void write(int c)：将指定的字节输出到输出流中，其中c既可以代表字节，也可以代表字符。void write(byte[] buf)：将字节数组中的数据输出到指定输出流中。void write(byte[] buf,int off,int len)：将字节数组中从off位置开始，长度为len的字节/字符输出到输出流中。

同样OutputStream也有子类用于输入文件流：FileOutputStream，下面的程序将示范FileOutputStream的使用。

package cn.bytecollege.IODemo;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;public class FileDemo6 {    public static void main(String[] args) {        File file = new File("D:/BYTE/study/byte.txt");        try{            //创建文件            file.createNewFile();        } catch (IOException  e) {            e.printStackTrace();        }        try{            //实例化FileOutputStream            FileOutputStream  fileOutputStream = new FileOutputStream(file);;            String str = "Bulid Your Technical Excellence";            for (int i = 0;i<str.length();i++) {                int b = (int)str.charAt(i);                fileOutputStream.write(b);            }        } catch (Exception e) {            e.printStackTrace();        }    }}

接下来，同时使用输入流和输出流来复制文件。

package cn.bytcollege.io.test;import java.io.*;public class CopyUtil {    public static void main(String[] args) {            String input = "D:/BYTE/study/Node.txt";            String output = "F:/Node.txt";            System.out.println("----------------copy  start-----------------------");            long start = System.currentTimeMillis();            copy(input,output);            long end = System.currentTimeMillis();            System.out.println("-----------------copy over!-----------------------");            System.out.println("------------------"+(end-start)+"-----------------");        }        public static void copy(String input,String output) {            try{                FileInputStream fis = new FileInputStream(input);                FileOutputStream fos = new FileOutputStream(output);                BufferedInputStream bis = new BufferedInputStream(fis);                BufferedOutputStream bos = new BufferedOutputStream(fos);                byte[] bytes = new byte[1024*10];                int i = 0;                while ((i=bis.read(bytes))>-1){                    bos.write(bytes);                }                bis.colse();                bos.close();            } catch (FileNotFoundException e) {                e.printStackTrace();            } catch (IOException e) {                e.printStackTrace();            }        }}

使用Java的IO流执行输出时，不要忘记关闭输出流，关闭输出流除了可以保证流的物理资源被回收之外，可能还可以将输出流缓冲区中的数据flush到物理节点里（因为在执行close()方法之前，自动执行输出流的flush()方法）

字符流Reader

在Reader里包含如下3个方法：

int read()：从输入流中读取单个字符（相当于如图所示的水管中取出一滴水），返回所读取的字符数据（字符数据可直接转换为int类型）。int read(char[]cbuf)：从输入流中最多读取cbuf.length个字符的数据，并将其存储在字符数组cbuf中，返回实际读取的字符数。int read(char[]cbuf,int off,int len)：从输入流中最多读取len个字符的数据，并将其存储在字符数组cbuf中，放入数组cbuf中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字符数。

对比InputStream和Reader所提供的方法，就不难发现这两个基类的功能基本是一样的，只是InputStream读取的最小单位是字节，而Reader读取的最小单位是字符。

Reader也有一个子类FileReader用于实现字符的读取，下面通过示例来学习FileReader的用法：

package cn.bytecollege.IODemo;import java.io.*;public class ReadDemo {    public static void main(String[] args) throws IOException {        Reader reader = new FileReader("d:/BYTE/study/Node.txt");        int i = 0;        char[] chars = new char[8];        while((i=reader.read(chars))>-1){            System.out.println(new String(chars,0,i));        }    }}

Writer抽象类中的方法和OutputStream方法类似，只需要将方法参数中的byte[]更换成char[]即可，字符流直接以字符作为操作单位，所以Writer可以用字符串来代替字符数组，即以String对象作为参数。Writer里还包含如下两个方法。

void write(String str)：将str字符串里包含的字符输出到指定输出流中。void write(String str,int off,int len)：将str字符串里从off位置开始，长度为len的字符输出到指定输出流中。

同样Writer也有一个子类FileWriter用于实现字符的输出，下面通过示例来学习Writer的子类FileWirter的用法。

package cn.bytecollege.IODemo;import java.io.*;public class WriterDemo {    public static void main(String[] args) throws IOException {        Reader reader = new FileReader("d:/BYTE/study/Node.txt");        Writer writer = new FileWriter("F:/2.txt");        int i = 0;        char[] chars = new char[8];        while((i=reader.read(chars))>-1){            writer.write(chars);        }        writer.close();    }}

对象序列化的目标是将对象保存到磁盘中，或允许在网络中直接传输对象。对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，通过网络将这种二进制流传输到另一个网络节点。其他程序一旦获得了这种二进制流（无论是从磁盘中获取的，还是通过网络获取的），都可以将这种二进制流恢复成原来的Java对象。

序列化机制允许将实现序列化的Java对象转换成字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以备以后重新恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。对象的序列化（Serialize）指将一个Java对象写入IO流中，与此对应的是，对象的反序列化（Deserialize）则指从IO流中恢复该Java对象。

如果需要让某个对象支持序列化机制，则必须让它的类是可序列化的（继承serializable接口，该接口是一个标记接口，实现该接口无须实现任何方法，它只是表明该类的实例是可序列化的）

使用Serializable来实现序列化非常简单，主要让目标类实现Serializable标记接口即可，无须实现任何方法。

一旦某个类实现了Serializable接口，该类的对象就是可序列化的，程序可以通过如下两个步骤来序列化该对象。

创建一个ObjectOutputStream调用ObjectOutputStream对象的writeObject()方法输出可序列化对象

下面通过示例来学了对象的序列化和反序列化：

package cn.bytecollege.IODemo;import java.io.Serializable;public class Student implements Serializable {}

package cn.bytecollege.IODemo;import java.io.*;public class Test {    public static void main(String[] args) throws IOException, ClassNotFoundException {        File file = new File("student.txt");        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));        Student student = new Student();        oos.writeObject(student);        oos.close();        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));        Student newStudent = (Student)ois.readObject();        ois.close();        System.out.println(newStudent);    }}

注意：

1.如果修改类是仅修改了方法，则反序列化不受任何影响。不需要修改serialVersionUID的值

2.如果修改类时仅仅修改了静态变量或者transient实例变量，则反序列化不受任何影响。不需要修改serialVersionUID的值。

3.如果修改类时修改了非瞬时的实例变量，则可能导致序列化版本不兼容。如果对象流中的对象和新类中包含同名的实例变量，而实例变量类型不同，则反序列化失败，类定义应该更新serialVersionUID类变量的值。如果对象流中的对象比新类中包含更多的实例变量，则多出的实例变量值被忽略，序列化版本可以兼容，类定义可以不更新serialVersionUID的值。如果新类比对象流中的对象包含更多的实例变量，则序列化版本也可以兼容，类定义可以不更新serialVersionUID的值。但反序列化的对的新对象中多出的实例变量值都是null。