文件分为两种：文本文件，非文本文件（二进制文件）。
一般来说，我们的数据存储在两个地方：
程序-内存-变量—》只有程序运行的时候，才存在。
硬盘—》一直存在的，持久的。
把文件从硬盘读取到内存里面-》读取-》读入read-》输入-》Input-》输入流
从内存里面把数据保存到硬盘-》存储-》写入write-》输出-》Output-》输出流

文件和目录操作➝File

Java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。

构造方法

File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

//父目录+子目录
File f = new File(File parent,String child);

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

//完整目录
File f = new File(String pathName);

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

//父目录+子目录
File f = new File(String parent,String child);

通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。

File f = new File(URI uri);

操作方法

创建File对象成功后，可以使用以下列表中的方法操作文件。

常用的一些方法：

------------操作方法------------
boolean createNewFile()//创建文件
boolean mkdir();//创建单个目录（不推荐）
boolean mkdirs();//创建单个或多级目录（推荐）
boolean delete();//删除文件或者文件夹
boolean renameTo(File dest) //重命名文件
------------判断方法------------
boolean isDirectory();//是否是目录
boolean isFile();//是否是文件
boolean exists();//是否存在
boolean canRead();//是否可读
boolean canWrite();//是否可写
boolean isHidden();//是否隐藏
------------获取方法------------
String getAbsolutePath();//获取文件在硬盘上的绝对路径名
String getPath();//获取构造File对象时的文件路径名
String getName();//获取路径表示的文件或目录名
long length();//获取路径名长度
long lastModified();//获取此文件最后被修改的视角
String[] list();//返回目录下所有的文件和文件夹的名字
File[] listFile();//返回目录下所有的文件和文件夹并转换成File数组（方便操作）

文件内容操作➝字节流和字符流

基本内容

文件内容的数据分为两种：文本数据， 二进制（字节）数据。
如果要进行文件内容的操作那么必须依靠数据流完成，而数据流分为两种：
  字节流：InputStream（字节输入流）、OutputStream（字节输出流）
  字符流：Reader（字符输入流）、Writer（字符输出流）

字节流理解配图

字符流理解配图

字节流与字符流操作的本质区别只有一个：字节流是原生的操作，而字符流是经过处理后的操作。

• 在进行网络数据传输、磁盘数据保存所保存所支持的数据类型只有：字节。
• 而所有磁盘中的数据必须先读取到内存后才能进行操作，而内存中会帮助我们把字节变为字符。字符更加适合处理中文。

不管使用的是字节流还是字符流，其基本的操作流程几乎是一样的，以文件操作为例。

1. 创建File类对象 ，主要是指明要操作的文件路径；
2. 根据字节流或字符流的子类实例化父类对象 ；
3. 进行数据的读取或写入操作；
4. 关闭流(close())；

对于IO操作属于资源处理，所有的资源处理操作(IO操作、数据库操作、网络)最后必须要进行关闭。

如前所述，一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。
下图是一个描述输入流和输出流的类层次图。

字节流

计算机中都是二进制数据，一个字节是8个2进制位。字节可以表示所有的数据，比如文本，音频，视频，图片，都是作为字节存在的。也就是说字节流处理的数据非常多。
在文本文件中存储的数据是以我们能读懂的方式表示的。而在二进制文件中存储的数据是用二进制形式表示的。我们是读不懂二进制文件的，因为二进制文件是为了让程序来读取而设计的。例如，Java的源程序(.java源文件)存储在文本文件中，可以使用文本编辑器阅读，但是Java的类(字节码文件)存储在二进制文件中，可以被Java虚拟机阅读。二进制文件的优势在于它的处理效率比文本文件高。
我们已经知道File对象封装的是文件或者路径属性，但是不包含向（从）文件读（写）数据的方法。为了实现对文件的读和写操作需要学会正确的使用Java的IO创建对象。

字节流的抽象基类：
输入流：java.io.InputStream
输出流：java.io.OutputStream

特点：字节流的抽象基类派生出来的子类名称都是以其父类名作为子类名的后缀。如：FileInputStream, ByteArrayInputStream等。
说明：字节流处理的单元是一个字节，用于操作二进制文件（计算机中所有文件都是二进制文件）。

总的来说，字节流主要是操作byte类型数据，以byte数组为准，主要操作类时字节输入流InputStream、字节输出流OutputStream。

字节输入流➝InputStream

InputStream可以实现数据的读取操作，在java中InputStream类的定义如下：

public abstract class InputStream implements Closeable

InputStream类中定义有三个数据的读取操作方法：
1、读取单个字节：public abstract int read() throws IOException;
每次执行此方法将读取当个字节数据，如果已经读取完成了，那么最后返回-1。

2、读取数据到字节数组中：public int read(byte b[]) throws IOException;（最常用方法）
每次将数据读取到数组之中，那么会返回一个读取长度的数据，如果没有数据则返回的长度为-1，可是要考虑两种情况：
要读取的内容大于开辟的数组内容：长度就是整个数组的长度。
要读取的内容小于开辟数组的内容：长度就是全部最后的内容长度，数组装不满。

3、读取部分内容到字节数组中：public int read(byte b[], int off,int len) throws IOException;
每次读取内容到部分字节数组，只允许读取满限制的数组的字节个数。此方法依然会返回读取的长度。

InputStream是一个抽象类，所以要进行文件的读取使用FileInputStream子类。

文件输入流➝FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello");
InputStream input = new FileInputStream(f);

创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作。

示例：

@Test
public void testFileInputStream() {
    FileInputStream input = null;
    try {
        input = new FileInputStream("TestIO/demo01.txt");
//        //1,读取一个字节
//        int a =-1;
//        while( (a = input.read())>-1 ) {
//            System.out.print((char)a);//中文不止占有一个字节，不能拿一个字节来读，会出现乱码
//        }
//        // 2,按照字节数组 1024
//        byte[] data = new byte[4];
//        int length = -1;
//        while ((length = input.read(data)) > -1) {
//            String str = new String(data, 0, length);
//            System.out.print(str);
//        }
//        // 3,按照字节数组 1024（推荐）
//        byte[] data = new byte[1024];
//        int length = input.read(data);
//        String str = new String(data,0,length);
//        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (input != null)
                input.close();// 释放资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节输出流➝OutputStream

字节输出流主要以操作byte数据为主，观察java.io.OutputStream类的定义结构：

public abstract class OutputStream implements Closeable, Flushable

OutputStream类实现了Closeable，Flushable两个接口，这两个接口中的方法：
 1. Closeable: public void close() throws IOException;
 2. Flushable: public void flush() throws IOException;

OutputStream类定义有三个重要的输出操作方法：
1、将给定的字节数组内容全部输出：public void write(byte b[]) throws IOException;
2、将部分字节数组内容输出：public void write(byte b[], int off, int len) throws IOException(重点)
3、输出单个字节：public abstract void write(int b) throws IOException;

OutputStream是一个抽象类，按照抽象类的基本原则来讲，如果想要取得OutputStream类的实例化对象那么一定需要子类，如果要进行文件的操作，可以使用FileOutputStream类来处理。

文件输出流➝FileOutputStream

该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

有两类构造方法可以用来创建 FileOutputStream 对象。
1、接收File类（覆盖）：public FileOutputStream(File file) throws FileNotFoundException
2、接收File类（追加）：public FileOutputStream(File file, boolean append)

使用字符串类型的文件名来创建一个输出流对象（覆盖）：

OutputStream f = new FileOutputStream("C:/java/hello")

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象（覆盖）：

File f = new File("C:/java/hello");
OutputStream out = new FileOutputStream(f);

使用字符串类型的文件名来创建一个输出流对象（追加）：

OutputStream f = new FileOutputStream("C:/java/hello",true)

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象（追加）：

File f = new File("C:/java/hello");
OutputStream out = new FileOutputStream(f,true);

创建OutputStream 对象完成后，就可以使用下面的方法来写入流或者进行其他的流操作。

示例：

@Test
public void testFileOutputStream() {
    FileOutputStream output = null;
    try {
        //output = new FileOutputStream("TestIO/demo02.txt");
        output = new FileOutputStream(new File("TestIO/demo02.txt"));
        // 按照单个字节写入
//        output.write('v');
//        output.write('d');
//        output.write('u');
        // 按照字节数组写入（推荐）
        String str = "hello";
        output.write(str.getBytes(), 1, 4);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (output != null)
                output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节缓冲区输入/输出流(用来做包装)

上述程序中我们为了提高流的使用效率，自定义了字节数组，作为缓冲区，Java其实提供了专门的字节流缓冲来提高效率。
BufferedInputStream和BufferedOutputStream
BufferedOutputStream和BufferedOutputStream类可以通过减少读写次数来提高输入和输出的速度。它们内部有一个缓冲区，用来提高处理效率。查看API文档，发现可以指定缓冲区的大小。其实内部也是封装了字节数组。没有指定缓冲区大小，默认的字节是8192。
显然缓冲区输入流和缓冲区输出流要配合使用。首先缓冲区输入流会将读取到的数据读入缓冲区，当缓冲区满时，或者调用flush方法，缓冲输出流会将数据写出。
注意：当然使用缓冲流来进行提高效率时，对于小文件可能看不到性能的提升。但是文件稍微大一些的话，就可以看到实质的性能提升了。具体看案例。

缓冲区输入流➝BufferedInputStream

使用一个InputStream对象来创建一个缓冲区输入流对象读取文件

InputStream fileInput = new FileInputStream("TestIO\\demo01.txt");
BufferedInputStream input = new BufferedInputStream(fileInput);

使用方法和FileInputStream完全一样。
示例：

@Test
public void testBufferedInputStream() {
    //缓冲区输入流  = 输入流 + 缓冲区(数组)
    BufferedInputStream input = null;
    FileInputStream fileInput;
    try {
        fileInput = new FileInputStream("TestIO\\demo01.txt");
        input = new BufferedInputStream(fileInput);
//        //1,读取一个字节
//        int a =-1;
//        while( (a = input.read())>-1 ) {
//            System.out.print((char)a);//中文不止占有一个字节，不能拿一个字节来读，会出现乱码
//        }
//        // 2,按照字节数组 1024（常用）
//        byte[] data = new byte[1024];
//        int length = input.read(data);
//        String str = new String(data,0,length);
//        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (input != null)
                input.close();// 释放资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲区输出流➝BufferedOutputStream

使用一个OutputStream对象来创建一个缓冲区输出流对象写文件

OutputStream fileOutput = new FileOutputStream("TestIO\\demo03.txt");
BufferedOutputStream output = new BufferedOutputStream(fileOutput);

使用方法和FileOutputStream完全一样。
示例：

@Test
public void testBufferedOutputStream() {
    //缓冲区输出流  = 输出流 + 缓冲区(数组)
    BufferedOutputStream output = null;
    FileOutputStream fileOutput;
    try {
        fileOutput = new FileOutputStream("TestIO\\demo03.txt");
        output = new BufferedOutputStream(fileOutput);
        // 按照单个字节写入
        // 缓冲区里面的数据什么时候会写到硬盘上呢
        // 1,缓冲区满了
        // 2,调用flush
        // 3,调用close
//        output.write('a');
//        output.write('s');
//        output.write('i');
//        output.write('a');
//        output.write('s');
//        output.write('z');
        // 按照字节数组写入
        String str = "hello中国";
        output.write(str.getBytes());
        output.flush();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        try {
            if (output != null)
                output.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

案例

使用文件字节输入/输出流复制文件

按照字节数组进行复制的效率远远高于按照单个字节进行复制。

//使用FileInputStream和FileOutputStream
@Test
public void testCopy() {
    long start = System.currentTimeMillis();
    copyByByte("TestIO\\5m.jpg", "TestIO\\copy01.jpg");
    System.out.println("copyByByte所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByByte所花费的时间：64935ms
    start = System.currentTimeMillis();
    copyByByteArray("TestIO\\5m.jpg", "TestIO\\copy02.jpg");
    System.out.println("copyByByteArray所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByByteArray所花费的时间：72ms
}
//按照字节数组进行复制（推荐）
public static void copyByByteArray(String sourceName,String targetName) {
    FileInputStream input = null;
    FileOutputStream output = null;
    try {
        input = new FileInputStream(sourceName);
        output = new FileOutputStream(targetName);
        byte[] data = new byte[1024];
        int length = -1;
        while( (length = input.read(data))>-1 ) {
            output.write(data,0,length);
        }    
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(input!=null)
                input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(output!=null)
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }
}
//按照单个字节进行复制
public static void copyByByte(String sourceName,String targetName) {
    FileInputStream input = null;
    FileOutputStream output = null;
    try {
        input = new FileInputStream(sourceName);
        output = new FileOutputStream(targetName);
        int data = -1;
        while( (data = input.read())>-1 ) {
            output.write(data);
        }    
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(input!=null)
                input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(output!=null)
                output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲区字节输入/输出流复制文件

两者效率差的不大，但是和文件输入/输出流性能差距还是很明显的，特别是按照单个字节进行复制。

使用BufferedInputStream和BufferedOutputStream
@Test
public void testCopy() {
    long start = System.currentTimeMillis();
    copyByByte("TestIO\\5m.jpg", "TestIO\\copy01.jpg");
    System.out.println("copyByByte所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByByte所花费的时间：44ms
    start = System.currentTimeMillis();
    copyByByteArray("TestIO\\5m.jpg", "TestIO\\copy02.jpg");
    System.out.println("copyByByteArray所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByByteArray所花费的时间：23ms
}
//按照字节数组进行复制（推荐）
public static void copyByByte(String sourceName,String targetName) {
    BufferedInputStream input = null;
    BufferedOutputStream output = null;
    try {
        input = new BufferedInputStream(new FileInputStream(sourceName));
        output = new BufferedOutputStream(new FileOutputStream(targetName));
        int data = -1;
        while( (data = input.read())!=-1 ) {
            output.write(data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(input!=null)
                input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(output!=null)
                output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//按照单个字节进行复制
public static void copyByByteArray(String sourceName,String targetName) {
    BufferedInputStream input = null;
    BufferedOutputStream output = null;
    try {
        input = new BufferedInputStream(new FileInputStream(sourceName));
        output = new BufferedOutputStream(new FileOutputStream(targetName));
        byte[] data = new byte[1024];
        int length = -1;
        while( (length = input.read(data))!=-1 ) {
            output.write(data, 0, length);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(input!=null)
                input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(output!=null)
                output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

字符流：就是在字节流的基础上，加上编码，形成的数据流。
字符流出现的意义：不用编码下，中文字符所占有的字节个数是不一样的。而字节流在操作字符时，可能会有中文导致的乱码，所以由字节流引申出了字符流。

字符流的抽象基类：
输入流：java.io.Reader
输出流：java.io.Writer

总的来说，字符流主要是操作字符类型数据，以char数组为准，主要操作类时字符输入流Reader、字符输出流Writer。

关于编码

编码是用来表示如何把字符使用数字存储起来的。（比如一个字符占几个字节，判断这个字节里面存储的是中文字符还是英文字符）
一个字符对应一个数字。几乎所有由文字和字符的地方，都有编码的存在！
数据一般是转换为字节来存储或者传输，我们拿到字节后，要通过编码来转换成人眼可以识别的字符。
字节和字符之间的转换，需要通过固定的编码来完成。
Java中的编码格式：https://www.cnblogs.com/yuan1164345228/p/6937958.html
常见的有ASCII，GB2312，GBK，UTF-8。Java里面默认的编码为GBK。

在Java的文件操作中，会涉及到三种编码：文件设置的编码，程序读取的编码，程序写入的编码。

字符输入流➝Reader

Reader是进行字符输入操作使用的类，这个类属于抽象类，要进行文件字符流操作，一般使用FileReader。

FileReader

FileReader类从InputStreamReader类继承而来。该类按字符读取流中数据。可以通过以下几种构造方法创建需要的对象。

在给定从中读取数据的 File 的情况下创建一个新 FileReader。

FileReader(File file)

在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

FileReader(FileDescriptor fd)

在给定从中读取数据的文件名的情况下创建一个新 FileReader（最常用）。

FileReader(String fileName)

创建FIleReader对象成功后，可以参照以下列表里的方法操作文件。

关于FileReader的父类InputStreamReader

//构造方法
InputStreamReader(InputStream stream);
InputStreamReader(InputStream stream,String charsetName);
//For example-InputStreamReader
FileInputStream fileinput = new FileInputStream("TestIO\\demo04.txt");
InputStreamReader reader = new InputStreamReader(fileinput);
//For example-FileReader
FileReader reader = new FileReader("TestIO\\demo04.txt");

两者使用方式完全一模一样，不过FileReader对InputStreamReader的构造方法做了一层封装，使用起来更方便。

示例：

@Test
public void testFileReader() {
    FileReader reader = null;
    try {
        reader = new FileReader("TestIO\\demo04.txt");
        //按照字符数组读 1024（常用）
        char[] data = new char[1024];
        int length = reader.read(data);
        String str = new String(data,0,length);
        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    
}

字符输出流➝Writer

Writer是进行字符输出操作使用的类，这个类属于抽象类，要进行文件字符流操作，一般使用FileWriter。

FileWriter

FileWriter 类从 OutputStreamWriter 类继承而来。该类按字符向流中写入数据。可以通过以下几种构造方法创建需要的对象。

在给出 File 对象的情况下构造一个 FileWriter 对象。

FileWriter(File file)

在给出 File 对象的情况下构造一个 FileWriter 对象。

 FileWriter(File file, boolean append)

参数：

• file：要写入数据的 File 对象。
• append：如果 append 参数为 true，则将字节写入文件末尾处，相当于追加信息。如果 append 参数为 false, 则写入文件开始处。

构造与某个文件描述符相关联的 FileWriter 对象。

 FileWriter(FileDescriptor fd)

在给出文件名的情况下构造 FileWriter 对象，它具有指示是否挂起写入数据的 boolean 值（最常用）。

FileWriter(String fileName, boolean append)

创建FileWriter对象成功后，可以参照以下列表里的方法操作文件。

关于FileWriter的父类OutputStreamWriter

//构造方法
OutputStreamWriter(OutputStream stream);
OutputStreamWriter(OutputStream stream,String charsetName);
//For example-OutputStreamWriter
FileOutputStream fileOutput = new FileOutputStream("TestIO\\demo04.txt");
OutputStreamWriter writer = new OutputStreamWriter(fileOutput);
//For example-FileWriter
FileWriter writer = new FileWriter("TestIO\\demo04.txt");

两者使用方式完全一模一样，不过FileWriter对OutputStreamWriter的构造方法做了一层封装，使用起来更方便。

示例：

@Test
public void testFileWriter() {
    //FileWriter按照默认编码 GBK来
    FileWriter writer = null;
    try {
        writer = new FileWriter("TestIO\\demo04.txt");
        writer.write("Hello中国");
        writer.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(writer!=null)
                writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：FileWriter 能调用flush方法，说明其实它也使用到了缓冲区。

字符缓冲区输入/输出流(用来做包装)

同字节缓冲区输入/输出流，字符也有自己的缓冲区输入/输出流。

缓冲区输入流➝BufferedReader

使用一个Reader对象来创建一个缓冲区输入流对象读取文件

FileReader fileReader = new FileReader("TestIO\\demo04.txt");
BufferedReader reader = new BufferedReader(fileReader);

使用方法和FileReader一样。
示例：

@Test
public void testBufferedReader() {
    FileReader fileReader = null;
    BufferedReader reader = null;
    try {
        fileReader = new FileReader("TestIO\\demo04.txt");
        reader = new BufferedReader(fileReader);
        //1,读取一个字符
//        int a =-1;
//        while( (a = reader.read())>-1 ) {
//            System.out.print((char)a);//这里读的是字符不是字节，所以能识别中文。但是程序读取的编码必须和文件设置的编码一致！！
//        }
        // 2,按照字符数组（常用）
//        char[] data = new char[1024];
//        int length = reader.read(data);
//        String str = new String(data,0,length);
//        System.out.println(str);
        /*
         * 3,BufferedReader提供了按行读取方法：
         * String readLine()
         * 连续读取若干字符，直到读取到换行符为止
         * 并将换行符之间读取到的字符以一个字符串返回
         * 若返回值为NULL，则表示读取到末尾。
         * 注意：该字符串不包含最后的换行符。
         * 
         */
//        String line = null;
//        while((line = reader.readLine())!=null){
//            System.out.println(line);
//        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲区输出流➝BufferedWriter

使用一个Writer对象来创建一个缓冲区输出流对象写文件

FileWriter fileWriter = new FileWriter("TestIO\\demo04.txt");
BufferedWriter writer = new BufferedWriter(fileWriter);

使用方法和FileWriter完全一样。
示例：

//字节流的缓冲区流 包装的是 字节流
//字符流的缓冲区流 包装的是 字符流
@Test
public void testBufferedWriter() {
    BufferedWriter writer = null;
    FileWriter fileWriter = null;
    try {
        fileWriter = new FileWriter("TestIO\\demo05.txt");
        writer = new BufferedWriter(fileWriter);
        // 按照单个字符写入
        // 缓冲区里面的数据什么时候会写到硬盘上呢
        // 1,缓冲区满了
        // 2,调用flush
        // 3,调用close
//        writer.write('a');
//        writer.write('s');
//        writer.write('i');
//        writer.write('a');
//        writer.write('s');
//        writer.write('z');
        // 按照字符串写入
        String str = "hello中国";
        writer.write(str);
        writer.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(writer!=null)
                writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

案例

使用文件字符输入/输出流复制文件

按照字符数组进行复制的效率高于按照单个字符进行复制，但没有字节那么夸张。

//使用FileReader和FileWriter
@Test
public void testCopy() {
    long start = System.currentTimeMillis();
    copyByChar("TestIO\\5m.jpg", "TestIO\\copy01.jpg");
    System.out.println("copyByChar所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByChar所花费的时间：421ms
    start = System.currentTimeMillis();
    copyByCharArray("TestIO\\5m.jpg", "TestIO\\copy02.jpg");
    System.out.println("copyByCharArray所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByCharArray所花费的时间：96ms
}
public void copyByChar(String sourceName,String targetName) {
    FileWriter writer = null;
    FileReader reader = null;
    try {
        writer = new FileWriter(targetName);
        reader = new FileReader(sourceName);
        int data = -1;
        while( (data=reader.read())!=-1 ) {
            writer.write(data);
        }
        writer.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(writer!=null)
                writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public void copyByCharArray(String sourceName,String targetName) {
    FileWriter writer = null;
    FileReader reader = null;
    try {
        writer = new FileWriter(targetName);
        reader = new FileReader(sourceName);
        char[] data = new char[1024];
        int length = -1;
        while( (length = reader.read(data))!=-1 ) {
            writer.write(data, 0, length);
        }
        writer.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(writer!=null)
                writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲区字符输入/输出流复制文件

两者效率差不多。

//使用BufferedReader和BufferedWriter
@Test
public void testCopy() {
    long start = System.currentTimeMillis();
    copyByChar("TestIO\\5m.jpg", "TestIO\\copy01.jpg");
    System.out.println("copyByChar所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByChar所花费的时间：221ms
    start = System.currentTimeMillis();
    copyByCharArray("TestIO\\5m.jpg", "TestIO\\copy02.jpg");
    System.out.println("copyByCharArray所花费的时间：" + (System.currentTimeMillis()-start) + "ms");//copyByCharArray所花费的时间：93ms
}
public void copyByChar(String sourceName,String targetName) {
    BufferedReader reader=null;
    BufferedWriter writer = null;
    try {
        reader = new BufferedReader(new FileReader(sourceName));
        writer = new BufferedWriter(new FileWriter(targetName));
        int data = -1;
        while( (data = reader.read())!=-1 ) {
            writer.write(data);
        }
        writer.flush();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        try {
            if(writer!=null)
                writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
public void copyByCharArray(String sourceName,String targetName) {
    BufferedReader reader=null;
    BufferedWriter writer = null;
    try {
        reader = new BufferedReader(new FileReader(sourceName));
        writer = new BufferedWriter(new FileWriter(targetName));
        char[] data = new char[1024];
        int length = -1;
        while( (length = reader.read(data))!=-1 ) {
            writer.write(data, 0, length);
        }
        writer.flush();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        try {
            if(writer!=null)
                writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

读取文本文件里面的内容，按照单行内容，放到集合里面。

@Test
public void test03() {
    ArrayList<String> list = new ArrayList<String>();
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader("TestIO\\demo05.txt"));
        String data = null;
        while( (data=reader.readLine())!=null ) {
            list.add(data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(reader!=null)
                reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    for (String string : list) {
        System.out.println(string);
    }
}

根据两个文件夹名称，将A文件夹内容全部拷贝到B文件夹(不包含A文件夹里面的子文件夹)

@Test
public void test04() {
    File sourceFolder=null;
    File targetFolder=null;
    sourceFolder = new File("D:\\Test");
    targetFolder = new File("D:\\Test2");
    File[] files = sourceFolder.listFiles();
    for(File file : files) {
        if(file.isDirectory())continue;
        File newFile = new File(targetFolder,file.getName());
        try {
            Files.copy(file.toPath(), newFile.toPath());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

复制一个文件夹里面的所有内容到另外一个文件夹，包括里面的子文件夹

@Test
public void test05() {
    copy(new File("d:\\Test"),new File("Test2"));
}
public void copy(File sourceFolder,File targetFolder) {
    if(targetFolder.exists()==false)targetFolder.mkdirs();
    File[] files = sourceFolder.listFiles();
    for(File file : files) {
        if(file.isDirectory()) {
            File newFile = new File(targetFolder,file.getName());
            copy(file,newFile);
        }else {
            File newFile = new File(targetFolder,file.getName());
            try {
                Files.copy(file.toPath(), newFile.toPath());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节流与字符流的区别

字节流在操作的时候本身不用缓存区的，是与文件直接对接的；而字符流操作时需要缓冲区。

使用字节流时，即使流没有关闭，最终也可以输出到文件；
使用字符流时，所有的内容实际上都只是输出到了缓冲区中（内存）。在使用close()方法关闭的时候会将我们缓冲区的数据进行输出，如果没有关闭，那么就将无法进行输出，此时可以利用flush()方法进行强制的输出。
如果处理中文使用字符流，其他的任何数据都使用字节流。