java常用IO流操作

一、概述

1. 流的分类

IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。可以分为:

• 输入/输出流：是以当前程序为中心，程序从外面读数据是输入流，程序把数据保存到外面是输出流
• 字节流/字符流：如果是以字节为单位处理流中的数据就是字节流，如果是以字符为单位处理流中的数据就是字符流
• 节点流/处理流：如果直接操作数据源就是节点流；处理流不直接操作数据源，是对其他流的包装

在java.io包中字节流都是以Stream单词结尾，字符流以Reader/Writer结尾

2. 常用流的继承关系

• 字节输入流：
  
• 字节输出流：
  
• 字符输入流：
  
• 字符输出流：
  

二、File类

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

File对象代表磁盘中实际存在的文件或目录。

1. 构造方法

File(File parent, String child)	通过给定的 父抽象路径名 和 子路径名字符串 创建一个新的File实例
File(String pathname)	通过将 给定路径名字符串 转换成抽象路径名来创建一个新 File 实例
File(String parent, String child)	根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

2. 实例方法

创建File对象成功后，可以使用以下列表中的实例方法操作文件（标注了的比较常用）：

实例方法	返回值类型	说明
getName()	String	返回此File表示的文件或目录的名称。
getParent()	String	返回父路径名字符串，如果不存在，则返回null。
getParentFile()	File	返回父路径名File，如果不存在，则返回null
getPath()	String	将此路径名转换为路径名字符串。
isAbsolute()	boolean	测试这个抽象路径名是否是绝对的。
getAbsoluteFile()	File	返回绝对路径的File。
getAbsolutePath()	String	返回绝对路径的字符串。
canExecute()/canRead()/canWrite()	boolean	测试应用程序是否可以执行/读取/修改此抽象路径名表示的文件。
isDirectory()	boolean	测试此抽象路径名表示的文件是否为目录。
isFile()	boolean	测试此抽象路径名表示的文件是否为普通文件。
createNewFile()	boolean	当文件不存在时，创建一个新的空文件。
mkdir()	boolean	创建目录，不包括父目录。
mkdirs()	boolean	创建目录，包括父目录。
list()	String[]	返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
list(FilenameFilter filter)	String[]	返回一个字符串数组，返回目录中满足过滤器的文件和目录。
listFiles()	File[]	返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
listFiles(FilenameFilter filter)	File[]	返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
lastModified()	long	返回此抽象路径名表示的文件上次修改的时间。
length()	long	返回由此抽象路径名表示的文件的长度。
renameTo(File dest)	boolean	重命名由此抽象路径名表示的文件。
toPath()	Path	返回从此抽象路径构造的java.nio.file.Path对象。
delete()	boolean	删除由此抽象路径名表示的文件或目录。
deleteOnExit()	void	请求在虚拟机终止时删除由此抽象路径名表示的文件或目录。
exists()	boolean	测试此抽象路径名表示的文件或目录是否存在。
setLastModified(long time)	boolean	设置由此抽象路径名所指定的文件或目录的最后一次修改时间。
setReadOnly()	boolean	标记此抽象路径名指定的文件或目录，以便只可对其进行读操作。
compareTo(File pathname)	int	按字母顺序比较两个抽象路径名。
compareTo(Object o)	int	按字母顺序比较抽象路径名与给定对象。
equals(Object obj)	boolean	测试此抽象路径名与给定对象的相等性。
toString()	String	返回此抽象路径名的路径名字符串。

3. 静态方法

静态方法	返回值类型	说明
createTempFile(String prefix, String suffix, File directory)	File	在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
createTempFile(String prefix, String suffix)	File	在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

4. 一些例子

1. 输出指定文件夹下所有的 .txt 文件（包括子文件夹）

   //显示文件夹的内容,包含子文件夹的内容
   private static void listSub(String folder) {
       File file = new File(folder);
   
       File[] files = file.listFiles();
       if (files != null) {
           for (File f : files) {
               //如果f是文件夹, 把f这个子文件夹的内容也显示出来
               if (f.isDirectory()) {
               	//如果是子目录，则递归调用子目录
                   listSub(f.getAbsolutePath());
               } else if (f.getName().endsWith(".txt")) {
               	//如果是文件，且文件名以.txt结尾，则输出
                   System.out.println(f.getAbsolutePath());
               }
           }
       }
   }
   

三、InputStream及其子类

1. InputStream

InputStream 是字节输入流基类，抽象类是表示字节输入流的所有类的超类。

方法	说明
int available()	返回从此输入流中可以读取（或跳过）的剩余字节数的估计值
abstract int read()	从输入流中读取数据的下一个字节，返回读到的下一个字节，如果读不到则返回 -1
int read(byte[] b)	从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中，返回读到的字节个数，读到末尾返回 -1
int read(byte[] b, int off, int len)	将输入流中最多 len 个数据字节读入 byte 数组，返回读到的字节个数，读到末尾返回 -1
long skip(long n)	跳过和丢弃此输入流中数据的 n个字节
void close()	关闭此输入流并释放与该流关联的所有系统资源

在读取文件时，在文件中有一个游标的存在，刚刚打开文件时游标指向最前面，每次读取文件内容后，游标都会向后移动

2. FileInputStream

FileInputStream 是字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。

• 构造方法：

  构造方法	说明
  FileInputStream(File file)	通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
  FileInputStream(String name)	通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

• 实例方法：FileInputStream覆盖和重写了父类的的常用方法。

• 自动释放资源：

  public static void main(String[] args) throws IOException {
      //从JDK7开始,可以自动关闭流，也可以在finally语句块中进行关闭
      //try后面使用一对小括弧,这是try资源块,try资源块可以自动释放
      try (
              FileInputStream fis = new FileInputStream("D:\\course\\03-JavaSE\\file\\abcd.txt");
      ) {
          int cc = -1;
          while ((cc = fis.read()) != -1) {
              System.out.print((char) cc);
          }
      } catch (IOException e) {
          e.printStackTrace();
      }
  }
  

• 将文件中读取的字节存储到字节数组中：

  //将文件中读取的字节存储到字节数组中
  public static void main(String[] args) throws IOException {
      //1)建立流通道
      FileInputStream fis = new FileInputStream("D:\\course\\03-JavaSE\\file\\abc.txt");
      //文件内容:abcdefhehe
  
      //先定义一个字节数组, 在实际应用中,字节数组的大小一般是1024的偶数倍，这里选择8倍
      byte[] bytes = new byte[4];
  
      //通过fis字节流读取文件中的字节,把读取到的字节存储到字节数组中, 返回读取的字节数
      int len = fis.read(bytes);
  
      while (len != -1) {
          //处理从文件中读到的len个字节, 把bytes数组中前len个字节转换为字符串
          System.out.println(new String(bytes, 0, len));
  
          //继续从文件中读取,还保存到bytes数组中
          len = fis.read(bytes);
      }
      
      //上面循环的拆解版，容易看到执行过程
     /* System.out.println(Arrays.toString(bytes));   //[97, 98, 99, 100]
      System.out.println(len);        //4
  
      len = fis.read(bytes);
      System.out.println(Arrays.toString(bytes));     //[101, 102, 104, 101]
      System.out.println(len);        //4
  
      len = fis.read(bytes);
      System.out.println(Arrays.toString(bytes));     //[104, 101, 104, 101]
      System.out.println(len);        //2
  
      len = fis.read(bytes);
      System.out.println(Arrays.toString(bytes));     //[104, 101, 104, 101]
      System.out.println(len);        //-1*/
      fis.close();
  }
  

3. BufferedInputStream

BufferedInputStream 是字节缓冲输入流，提高了读取效率

• 构造方法：

  构造方法	说明
  ufferedInputStream(InputStream in)	创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
  ufferedInputStream(InputStream in, int size)	创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用

• 常用方法同InputStream

public static void main(String[] args) throws IOException {
    //1)先建立字节流
    FileInputStream fis = new FileInputStream("D:\\course\\03-JavaSE\\file\\abc.txt");
    //再创建缓冲流,对字节流进行缓冲
    BufferedInputStream bis = new BufferedInputStream(fis);

    byte[] bs = new byte[20];
    int len = 0;
    while ((len = bis.read(bs)) != -1) {
        System.out.print(new String(bs, 0, len));
    }
    // 关闭流
    bis.close();
}

4. DataInputStream

DataInputStream用于读取在文件中保存的带有数据格式（基本类型和String）的数据

注意：DataOutputStream 与DataInputStream配合使用，而且二者 读写的顺序要一样

• 构造方法：

  构造方法	说明
  DataInputStream(InputStream in)	通过输入流InputStream来创建一个 DataInputStream。

• 常用方法，除了实现父类的方法外，还有如下方法：

  方法	说明
  boolean readBoolean()	读取bollean类型的值
  byte readByte()	读取byte类型的值
  char readChar()	读取char类型的值
  short readShort()	读取short类型的值
  int readInt()	读取int类型的值
  long readLong()	读取long类型的值
  float readFloat()	读取float类型的值
  double readDouble()	读取double类型的值

• 写入文件

  public static void main(String[] args) throws IOException {
      //先建立字节流通道
      FileOutputStream out = new FileOutputStream("D:\\course\\03-JavaSE\\file\\out.txt");
      DataOutputStream dos = new DataOutputStream(out);
  
      //保存数据, 用对应类型的"write类型()"方法
      dos.writeInt(456);
      dos.writeDouble(3.14);
      dos.writeBoolean(false);
      dos.writeChar('G');
  
      dos.close();
  }
  

• 从文件中按顺序读取：

  public static void main(String[] args) throws IOException {
      FileInputStream in = new FileInputStream("D:\\course\\03-JavaSE\\file\\out.txt");
      DataInputStream dis = new DataInputStream(in);
  
  	//读取顺序要与写入顺序一致
      int num = dis.readInt();
      double dd = dis.readDouble();
      boolean bb = dis.readBoolean();
      char cc = dis.readChar();
  
      dis.close();
  }
  

5. ObjectInputStream

使用ObjectInputStream进行反序列化，简单的理解为把文件中的对象读取出来

• 对象序列化就是 把一个对象转换为01二进制序列，存储到文件中，使用ObjectOutputStream
• 对象反序列化就是把一组01二进制序列转换为对象，读取到程序中，使用ObjectInputStream

注意：对象序列化/反序列化的前提是对象的类要实现Serializable接口。Serializable接口是 一个标志接口，没有任何成员，就是告诉编译器可以进行序列化。一般情况下，类实现了Serializable接口后，需要手动的添加一个序列化版本号字段

public class Person implements Serializable {
	private static final long serialVersionUID = -5990283450992650215L;
}

当对象序列化之后，即把对象保存到文件之后，又修改了Person类的结构，比如说增加了一个新的字段，再进行反序列化时会产生 java.io.InvalidClassException类无效异常（通过比较serialVersionUID序列化版本号字段）

• 构造方法：

  构造方法	说明
  ObjectInputStream(InputStream in)	通过输入流InputStream来创建一个 ObjectInputStream。

• 常用方法：

  方法	说明
  Object readObject()	从ObjectInputStream读取一个对象。

• 对象序列化：

  public static void main(String[] args) throws IOException {
  
      //先创建输出字节流
      FileOutputStream out = new FileOutputStream("D:\\course\\03-JavaSE\\file\\obj.txt");
      ObjectOutputStream oos = new ObjectOutputStream(out);
  
      //对象序列化可以简单的看作是把对象保存到文件中
      Person p1 = new Person("lisi", 23);
      oos.writeObject(p1);
  
      oos.close();
  }
  

• 对象的反序列化：

  public static void main(String[] args) throws IOException, ClassNotFoundException {
      FileInputStream in = new FileInputStream("D:\\course\\03-JavaSE\\file\\obj.txt");
      ObjectInputStream ois = new ObjectInputStream(in);
  
      //readObject()方法返回值类型是Object类型, 实际从文件中读取的是Person对象
      Person obj = (Person) ois.readObject();
  	//如果是多个
  	//List list = (List) obj;	    
  
      ois.close();
  
      System.out.println(obj);
  }
  

四、OutputStream及其子类

1. OutputStream

OutputStream 是字节输出流基类，抽象类是表示输出字节流的所有类的超类。

方法	说明
void write(byte[] b)	将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b, int off, int len)	将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
abstract void write(int b)	将指定的字节写入此输出流
void close()	关闭此输出流并释放与此流有关的所有系统资源
void flush()	刷新此输出流并强制写出所有缓冲的输出字节

注意：输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下；输出换行符时一定要写\r\n不能只写\n，因为不同文本编辑器对换行符的识别存在差异性。

2. FileOutputStream

FileOutputStream是字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。

• 构造方法：

  构造方法	说明
  FileOutputStream(File file)	创建文件输出流以写入由指定的 File对象表示的文件。
  FileOutputStream(File file, boolean append)	创建由指定的 File对象表示的文件输出流。Append为true表示以追加的方式写入
  FileOutputStream(String name)	创建文件输出流以指定的名称写入文件。
  FileOutputStream(String name, boolean append)	以指定的名称创建文件输出流，Append为true表示以追加的方式写入。

• 常用方法：FileOutputStream覆盖和重写了父类的的常用方法。

public static void main(String[] args) {
    try (
            //1)在当前程序与文件之间建立流通道,如果文件不存在,系统会创建一个文件,如果文件存在,会覆盖文件中的内容
            //FileOutputStream fos = new FileOutputStream("D:\\course\\03-JavaSE\\file\\def.txt");
            //这里在后面指定了参数true，一个如果文件已存在,把就新的内容追加到文件原有内容的后面,如果文件不存在,系统也会创建一个文件
            FileOutputStream fos = new FileOutputStream("D:\\course\\03-JavaSE\\file\\def.txt", true);
    ) {
        //2)把数据写到文件中
        //2.1一次写一个字节
        fos.write(97);
        fos.write(98);
        fos.write(99);
        //2.2换行, 在Windows操作系统中,换行需要两个字符\r\n
        fos.write('\r');
        fos.write('\n');
        //2.3 把字节数组保存到文件中
        byte[] bytes = "helloworld".getBytes();
        fos.write(bytes);   //把整个字节数组中的字节保存到文件中

        fos.write('\r');
        fos.write('\n');
        fos.write(bytes, 0, 5);     //把bytes数组中从0开始的5个字节保存到文件中
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3. BufferedOutputStream

BufferedOutputStream是字节缓冲输出流，提高了写出效率。

• 构造方法：

  构造方法	说明
  BufferedOutputStream(OutputStream out)	创建一个新的缓冲输出流，以将数据写入指定的底层输出流
  BufferedOutputStream(OutputStream out, int size)	创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流

• 常用方法同OutputStream

public static void write() throws IOException {
    //1)先建立字节流
    FileOutputStream fos = new FileOutputStream("D:\\course\\03-JavaSE\\file\\def.txt");
    //对字节流进行缓冲
    BufferedOutputStream bos = new BufferedOutputStream(fos);

    //2)把数据写到缓冲流的缓冲区中
    bos.write("hello".getBytes());

    //3)调用flush()
    bos.flush();
    bos.close();
}

4. DataOutputStream

DataOutputStream在向文件中保存数据时，可以带有数据格式（基本类型和String），把带有格式的数据保存到文件中之后，打开文件会显示乱码

• 构造方法：

  构造方法	说明
  DataOutputStream(OutputStream out)	创建一个DataOutputStream，以将数据写入指定的底层输出流

• 常用方法：

  方法	说明
  void writeBoolean(boolean v)	写入bollean类型的值
  void writeByte(int v)	写入byte类型的值
  void writeBytes(String s)	将字符串作为字节序列写入
  void writeChar(int v)	写入char类型的值
  void writeChars(String s)	将字符串作为字符数组写入
  void writeDouble(double v)	写入double类型的值
  void writeFloat(float v)	写入float类型的值
  void writeInt(int v)	写入int类型的值
  void writeLong(long v)	写入long类型的值
  void writeShort(int v)	写入short类型的值

使用例子见DataInputStream

5. ObjectOutputStream

ObjectOutputStream将对象序列化到文件中。

• 构造方法：

  构造方法	说明
  ObjectOutputStream(OutputStream out)	创建一个ObjectOutputStream，以将数据写入指定的底层输出流

• 常用方法：

  方法	说明
  void writeObject(Object obj)	将指定的对象写入ObjectOutputStream。

使用例子见ObjectInputStream

6. PrintStream

• 构造方法：

  构造方法	说明
  PrintStream(OutputStream out)	默认编码方式的PrintStream
  PrintStream(OutputStream out, boolean autoFlush)	默认编码方式，autoFlush为true时自动刷新，默认不自动刷新
  PrintStream(OutputStream out, boolean autoFlush, String encoding)	指定编码方式，autoFlush为true时自动刷新
  PrintStream(String fileName)	指定文件名称
  PrintStream(String fileName, String csn)	指定文件名称和字符编码csn
  PrintStream(File file)	指定文件对象
  PrintStream(File file, String csn)	指定文件对象和字符编码csn

• 常用方法：

  方法	说明
  void print(任意类型的形参)	打印
  void println(任意类型的形参)	打印完后终止行

System 类中 out 属性就是一个PringStream对象

public static void main(String[] args) throws FileNotFoundException {
    FileOutputStream out = new FileOutputStream("D:\\course\\03-JavaSE\\file\\log.txt", true);
    PrintStream ps = new PrintStream(out);

    ps.print("hello");
    ps.println("world");//输出到文件

    //System类的out成员就是PrintStream类型的变量,
    //System.out代表系统的标准输出设备,即显示器
    System.out.println("这一行信息显示在屏幕上");
    //System.setOut()可以修改System.out的打印方向
    System.setOut(ps);
    System.out.println("这一行信息不会打印在屏幕上,而是打印到printStream流对应的log.txt文件中");

    //对于异常的捕获处理, 在开发时一般把异常信息打印到屏幕上, 部署后需要把异常信息打印到日志文件中
    try {
        new SimpleDateFormat().parse("dsfaf");
    } catch (ParseException e) {
        //e.printStackTrace();//打印到屏幕上
        e.printStackTrace(ps);//打印到文件
    }

    ps.close();
}

五、Reader及其子类

1. Reader

Reader：读取字符流的抽象类

方法	说明
int read()	读取单个字符，如果读到文件末尾返回-1
int read(char[] cbuf)	将字符读入数组
abstract int read(char[] cbuf, int off, int len)	将字符读入数组的某一部分
long skip(long n)	跳过字符
abstract void close()	关闭该流并释放与之关联的所有资源

2. InputStreamReader

InputStreamReader是字节流转字符流，它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

• 构造方法：

  方法	说明
  InputStreamReader(InputStream in)	创建一个使用默认字符集的 InputStreamReader
  InputStreamReader(InputStream in, Charset cs)	创建使用给定字符集的 InputStreamReader
  InputStreamReader(InputStream in, CharsetDecoder dec)	创建使用给定字符集解码器的 InputStreamReader
  InputStreamReader(InputStream in, String charsetName)	创建使用指定字符集的 InputStreamReader

• 常用方法：

  方法	说明
  String getEncoding()	返回此流使用的字符编码的名称

public static void main(String[] args) throws IOException {
    //1)建立字节流, 读取abc.txt文件,该文件的编码是GBK编码
    FileInputStream fis = new FileInputStream("D:\\course\\03-JavaSE\\file\\abc.txt");
    //2)把再把字节流转换为字符流
    InputStreamReader isr = new InputStreamReader(fis, "GBK");

    //再通过isr字符流读取文件的内容
    int cc = isr.read();
    while (cc != -1) {
        System.out.print((char) cc);
        cc = isr.read();
    }
    isr.close();
}

3. FileReader

FileReader是InputStreamReader类的直接子类，以字符为单位读取文件中的内容。只能以默认的编码方式读取纯文本文件

• 构造方法：

  方法	说明
  FileReader(File file)	通过 File创建一个新的 FileReader。
  FileReader(FileDescriptor fd)	通过给定 FileDescriptor创建一个新的 FileReader。
  FileReader(String fileName)	通过文件的名称创建一个新的 FileReader。

• 常用方法同InputStreamReader。

4. BufferedReader

BufferedReader是字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

• 构造方法：

  方法	说明
  BufferedReader(Reader in)	创建一个使用默认大小输入缓冲区的缓冲字符输入流
  BufferedReader(Reader in, int sz)	创建一个使用指定大小输入缓冲区的缓冲字符输入流

• 常用方法：

  方法	说明
  String readLine()	一次读取一行文本，读到文本末尾返回

public static void main(String[] args) throws IOException {
    //读取abc.txt文件,该文件是GBK编码
    InputStreamReader fr = new InputStreamReader(new FileInputStream("D:\\course\\03-JavaSE\\file\\abc.txt"), "GBK");

    //对字符流进行缓冲
    BufferedReader bufferedReader = new BufferedReader(fr);

    //缓冲字符流可以一次读取一行, 读到文件末尾返回null
    String line = bufferedReader.readLine();
    while (line != null) {
        System.out.println(line);
        line = bufferedReader.readLine();
    }

    bufferedReader.close();
}

六、Writer及其子类

1. Writer

Writer：写入字符流的抽象类

方法	说明
void write(char[] cbuf)	写入字符数组
abstract void write(char[] cbuf, int off, int len)	写入字符数组的某一部分
void write(int c)	写入单个字符
void write(String str)	写入字符串
void write(String str, int off, int len)	写入字符串的某一部分
Writer append(char c)	将指定字符添加到此 writer
Writer append(CharSequence csq)	将指定字符序列添加到此 writer
Writer append(CharSequence csq, int start, int end)	将指定字符序列的子序列添加到此 writer.Appendable
abstract void flush()	刷新该流的缓冲
abstract void close()	关闭此流，但要先刷新它

2. OutputStreamWriter

OutputStreamWriter可以把字符流转换为指定格式的字节流，文件编码与当前环境编码不一致时使用

• 构造方法：

  方法	说明
  OutputStreamWriter(OutputStream out)	创建使用默认字符编码的 OutputStreamWriter
  OutputStreamWriter(OutputStream out, Charset cs)	创建使用给定字符集的 OutputStreamWriter
  OutputStreamWriter(OutputStream out, CharsetEncoder enc)	创建使用给定字符集编码器的 OutputStreamWriter
  OutputStreamWriter(OutputStream out, String charsetName)	创建使用指定字符集的 OutputStreamWriter

• 特有方法：

  方法	说明
  String getEncoding()	返回此流使用的字符编码的名称

public static void main(String[] args) throws IOException {
    //1)先建立字节流, 以追加的方式打开abc.txt文件, 该文件是GBK编码
    FileOutputStream fos = new FileOutputStream("D:\\course\\03-JavaSE\\file\\abc.txt", true);
    //2)把字符流转换为字节流
    OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");

    osw.write("\r\n");
    osw.write("这一条语句是从UTF-8编码环境中写入到文件中的");

    osw.close();
}

3. FileWriter

FileWriter是OutputStreamWriter类的直接子类，以字符为单位把数据保存到文件中。只能以默认的编码方式写入纯文本文件

• 构造方法：

  方法	说明
  FileWriter(File file)	给一个File对象构造一个FileWriter对象。
  FileWriter(File file, boolean append)	给一个File对象构造一个FileWriter对象，append为true表示追加
  FileWriter(FileDescriptor fd)	构造与文件描述符关联的FileWriter对象。
  FileWriter(String fileName)	构造一个给定文件名的FileWriter对象。
  FileWriter(String fileName, boolean append)	构造一个FileWriter对象，append为true表示追加。

• 常用方法同OutputStreamWriter。

4. BufferedWriter

• 构造方法：

  方法	说明
  BufferedWriter(Writer out)	创建一个使用默认大小输出缓冲区的缓冲字符输出流
  BufferedWriter(Writer out, int sz)	创建一个使用给定大小输出缓冲区的新缓冲字符输出流

• 特有方法：

  方法	说明
  void newLine()	写入一个行分隔符

public static void main(String[] args) throws IOException {
    //写入Abc.txt文件,该文件编码是GBK
    OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("D:\\course\\03-JavaSE\\file\\abc.txt", true), "GBK");

    BufferedWriter bufferedWriter = new BufferedWriter(writer);

    bufferedWriter.newLine();//产生一个新行
    bufferedWriter.write("使用缓冲字符流写入的数据");

    bufferedWriter.close();
}

5. PrintWriter

PrintWriter类可用来创建一个文件并向文本文件写入数据，使用方式与PrintStream几乎是一模一样的

• 区别：PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print()/println()方法最终输出的是char数据。

• 构造方法：

  方法	说明
  PrintWriter(File file)	使用指定的文件创建一个新的PrintWriter，而不需要自动的线路刷新。
  PrintWriter(File file, String csn)	使用指定的文件和字符集创建一个新的PrintWriter，而不需要自动进行线条刷新。
  PrintWriter(OutputStream out)	从现有的OutputStream创建一个新的PrintWriter，而不需要自动线路刷新。
  PrintWriter(OutputStream out, boolean autoFlush)	从现有的OutputStream创建一个新的PrintWriter。
  PrintWriter(String fileName)	使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新。
  PrintWriter(String fileName, String csn)	使用指定的文件名和字符集创建一个新的PrintWriter，而不需要自动线路刷新。
  PrintWriter(Writer out)	创建一个新的PrintWriter，没有自动线冲洗。
  PrintWriter(Writer out, boolean autoFlush)	创建一个新的PrintWriter。