简介

FileWriter是读取字符流的类,继承于OutputStreamWriter类，用于将内容通过字符流的方式从应用程序输出到外部文件中

源码分析

OutputStreamWriter

OutputStreamWriter是字节流通向字符流的桥梁，它使用指定的 charset 输出字符并将其编码为字节。
它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。 每次调用 OutputStreamWriter 中的一个 writer() 方法**都会导致**在给定字符上调用编码转换器。生成的字节在写入底层输出流之前在缓冲区中累积。
OutputStreamWriter流的作用就是利用字节流作为底层输出流然后构建字符输出流，字符输出流输出字符到流中，然后通过指定的字符集把流中的字符编码成字节输出到字节流中，其作用就是一个桥梁，使得双方链接起来。

  1. /*
  2.  * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
  3.  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  4.  *
  5.  *
  6.  *
  7.  *
  8.  *
  9.  *
  10.  *
  11.  *
  12.  *
  13.  *
  14.  *
  15.  *
  16.  *
  17.  *
  18.  *
  19.  *
  20.  *
  21.  *
  22.  *
  23.  *
  24.  */
  26. package java.io;
  28. import java.nio.charset.Charset;
  29. import java.nio.charset.CharsetEncoder;
  30. import sun.nio.cs.StreamEncoder;
  33. /**
  34.  * An OutputStreamWriter is a bridge from character streams to byte streams:
  35.  * Characters written to it are encoded into bytes using a specified {@link
  36.  * java.nio.charset.Charset charset}.  The charset that it uses
  37.  * may be specified by name or may be given explicitly, or the platform's
  38.  * default charset may be accepted.
  39.  *
  40.  * <p> Each invocation of a write() method causes the encoding converter to be
  41.  * invoked on the given character(s).  The resulting bytes are accumulated in a
  42.  * buffer before being written to the underlying output stream.  The size of
  43.  * this buffer may be specified, but by default it is large enough for most
  44.  * purposes.  Note that the characters passed to the write() methods are not
  45.  * buffered.
  46.  *
  47.  * <p> For top efficiency, consider wrapping an OutputStreamWriter within a
  48.  * BufferedWriter so as to avoid frequent converter invocations.  For example:
  49.  *
  50.  * <pre>
  51.  * Writer out
  52.  *   = new BufferedWriter(new OutputStreamWriter(System.out));
  53.  * </pre>
  54.  *
  55.  * <p> A <i>surrogate pair</i> is a character represented by a sequence of two
  56.  * <tt>char</tt> values: A <i>high</i> surrogate in the range '&#92;uD800' to
  57.  * '&#92;uDBFF' followed by a <i>low</i> surrogate in the range '&#92;uDC00' to
  58.  * '&#92;uDFFF'.
  59.  *
  60.  * <p> A <i>malformed surrogate element</i> is a high surrogate that is not
  61.  * followed by a low surrogate or a low surrogate that is not preceded by a
  62.  * high surrogate.
  63.  *
  64.  * <p> This class always replaces malformed surrogate elements and unmappable
  65.  * character sequences with the charset's default <i>substitution sequence</i>.
  66.  * The {@linkplain java.nio.charset.CharsetEncoder} class should be used when more
  67.  * control over the encoding process is required.
  68.  *
  69.  * @see BufferedWriter
  70.  * @see OutputStream
  71.  * @see java.nio.charset.Charset
  72.  *
  73.  * @author      Mark Reinhold
  74.  * @since       JDK1.1
  75.  */
  77. public class OutputStreamWriter extends Writer {
  79.     // 流编码器
  80.     private final StreamEncoder se;
  82.     /**
  83.      * 构造方法
  84.      * @param  out
  85.      *         An OutputStream 字节输出流
  86.      *
  87.      * @param  charsetName
  88.      *         The name of a supported 字符编码集名称
  89.      *         {@link java.nio.charset.Charset charset}
  90.      *
  91.      */
  92.     public OutputStreamWriter(OutputStream out, String charsetName)
  93.         throws UnsupportedEncodingException
  94.     {
  95.         super(out);
  96.         if (charsetName == null)
  97.             throw new NullPointerException("charsetName");
  98.         se = StreamEncoder.forOutputStreamWriter(out, this, charsetName);
  99.     }
  101.     /**
  102.      * 构造方法
  103.      * @param  out  An OutputStream 字节输出流
  104.      */
  105.     public OutputStreamWriter(OutputStream out) {
  106.         super(out);
  107.         try {
  108.             se = StreamEncoder.forOutputStreamWriter(out, this, (String)null);
  109.         } catch (UnsupportedEncodingException e) {
  110.             throw new Error(e);
  111.         }
  112.     }
  114.     /**
  115.      * 构造方法
  116.      * @param  out
  117.      *         An OutputStream 字节输出流
  118.      *
  119.      * @param  cs
  120.      *         A charset 字符编码集
  121.      *
  122.      * @since 1.4
  123.      * @spec JSR-51
  124.      */
  125.     public OutputStreamWriter(OutputStream out, Charset cs) {
  126.         super(out);
  127.         if (cs == null)
  128.             throw new NullPointerException("charset");
  129.         se = StreamEncoder.forOutputStreamWriter(out, this, cs);
  130.     }
  132.     /**
  133.      * 构造方法
  134.      * @param  out
  135.      *         An OutputStream 字节输出流
  136.      *
  137.      * @param  enc
  138.      *         A charset encoder 编码器
  139.      * @since 1.4
  140.      * @spec JSR-51
  141.      */
  142.     public OutputStreamWriter(OutputStream out, CharsetEncoder enc) {
  143.         super(out);
  144.         if (enc == null)
  145.             throw new NullPointerException("charset encoder");
  146.         se = StreamEncoder.forOutputStreamWriter(out, this, enc);
  147.     }
  149.     /**
  150.      * 获取当前流的指定编码名称
  151.      * @return The historical name of this encoding, or possibly
  152.      *         <code>null</code> if the stream has been closed
  153.      * @revised 1.4
  154.      * @spec JSR-51
  155.      */
  156.     public String getEncoding() {
  157.         return se.getEncoding();
  158.     }
  160.     /**
  161.      * 刷新缓存，将缓存中的数据写入流中
  162.      */
  163.     void flushBuffer() throws IOException {
  164.         se.flushBuffer();
  165.     }
  167.     /**
  168.      * 写入一个字符到流中
  169.      */
  170.     public void write(int c) throws IOException {
  171.         se.write(c);
  172.     }
  174.     /**
  175.      * 将字符数组off位置后的len个元素通过流输出
  176.      * @param  cbuf  Buffer of characters
  177.      * @param  off   Offset from which to start writing characters
  178.      * @param  len   Number of characters to write
  179.      *
  180.      * @exception  IOException  If an I/O error occurs
  181.      */
  182.     public void write(char cbuf[], int off, int len) throws IOException {
  183.         se.write(cbuf, off, len);
  184.     }
  186.     /**
  187.      * 将字符串中的off位置后len个字符通过流输出
  188.      * @param  str  A String
  189.      * @param  off  Offset from which to start writing characters
  190.      * @param  len  Number of characters to write
  191.      */
  192.     public void write(String str, int off, int len) throws IOException {
  193.         se.write(str, off, len);
  194.     }
  196.     /**
  197.      * 强刷缓存，将所有缓存中的数据强制输出
  198.      * @exception  IOException  If an I/O error occurs
  199.      */
  200.     public void flush() throws IOException {
  201.         se.flush();
  202.     }
  204.     /**
  205.      * 关闭流，释放资源
  206.      */
  207.     public void close() throws IOException {
  208.         se.close();
  209.     }
  210. }

可以看到，OutputStreamWriter构造方法主要是结合一个字节输出流和编码集合构建一个StreamEncoder，该编码器可以将字符编码为字节，而后续所有操作都依赖于该类执行。

FileWriter

package java.io;


/**
 * @see OutputStreamWriter
 * @see FileOutputStream
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class FileWriter extends OutputStreamWriter {

    /**
     * 构造方法，传入文件名，构造一个文件字节输出流，调用父类方法构造字符输出流
     *
     * @param fileName  String The system-dependent filename.
     */
    public FileWriter(String fileName) throws IOException {
        super(new FileOutputStream(fileName));
    }

    /**
     * 构造方法，传入文件名和是否追加标识，构造一个文件字节输出流，调用父类方法构造字符输出流
     *
     * @param fileName  String The system-dependent filename.
     * @param append    boolean if <code>true</code>, then data will be written
     *                  to the end of the file rather than the beginning.
     */
    public FileWriter(String fileName, boolean append) throws IOException {
        super(new FileOutputStream(fileName, append));
    }

    /**
     * 构造方法，传入文件对象，构造一个文件字节输出流，调用父类方法构造字符输出流
     *
     * @param file  a File object to write to.
     */
    public FileWriter(File file) throws IOException {
        super(new FileOutputStream(file));
    }

    /**
     * 构造方法，传入文件对象和是否追加标识，构造一个文件字节输出流，调用父类方法构造字符输出流
     * @param file  a File object to write to
     * @param     append    if <code>true</code>, then bytes will be written
     *                      to the end of the file rather than the beginning
     * @since 1.4
     */
    public FileWriter(File file, boolean append) throws IOException {
        super(new FileOutputStream(file, append));
    }

    /**
     * 构造方法，传入文件描述符，构造一个文件字节输出流，调用父类方法构造字符输出流
     * @param fd  FileDescriptor object to write to.
     */
    public FileWriter(FileDescriptor fd) {
        super(new FileOutputStream(fd));
    }
}

可见，FileWriter只提供了三个构造方法，其余所有方法都是依赖于父类OutputStreamWriter执行

简单使用

package com.java.io;

import java.io.FileWriter;
import java.io.IOException;

/**
 * @description
 * @date: 2021-01-19 10:03
 */
public class FileWriterExample {
    public static void main(String[] args) {
        commonExample();
    }

    public static void commonExample() {
        String filePath = "D:\\IDEAWorkSpace\\JAVALearn\\io\\src\\resource\\fileOut.txt";
        FileWriter fileWriter = null;

        try {
            fileWriter = new FileWriter(filePath);

            String message = "只需要看到第五个字符哦";

            fileWriter.write(message, 0, 5);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null!=fileWriter){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件结果：
图片.png

总结

1、FileWriter是读取字符流的类,继承于OutputStreamWriter类，用于将内容通过字符流的方式从应用程序输出到外部文件中

2、OutputStreamWriter是字节流通向字符流的桥梁，它使用指定的 charset 输出字符并将其编码为字节**。

3、OutputStreamWriter构造方法主要是结合一个字节输出流和编码集合构建一个StreamEncoder，该编码器可以将字符编码为字节，而后续所有操作都依赖于该类执行。

4、FileWriter只提供了三个构造方法，其余所有方法都是依赖于父类OutputStreamWriter执行