简介

FileOutputStream流是指文件字节输出流，专用于输出原始字节流，如图像数据等，其继承OutputStream类，拥有输出流的基本特性

源码分析

  1. package java.io;
  3. import java.nio.channels.FileChannel;
  4. import sun.nio.ch.FileChannelImpl;
  7. /**
  8.  * @author  Arthur van Hoff
  9.  * @see     java.io.File
  10.  * @see     java.io.FileDescriptor
  11.  * @see     java.io.FileInputStream
  12.  * @see     java.nio.file.Files#newOutputStream
  13.  * @since   JDK1.0
  14.  */
  15. public
  16. class FileOutputStream extends OutputStream
  17. {
  18.     /**
  19.      * 文件描述符，打开文件句柄
  20.      */
  21.     private final FileDescriptor fd;
  23.     /**
  24.      * 是否在文件末尾追加
  25.      */
  26.     private final boolean append;
  28.     /**
  29.      * 文件通道
  30.      */
  31.     private FileChannel channel;
  33.     /**
  34.      * 文件路径
  35.      */
  36.     private final String path;
  38.     // 锁机制对象，用于调用close方法时的同步锁对象
  39.     private final Object closeLock = new Object();
  41.     // 当前输出流是否已关闭
  42.     private volatile boolean closed = false;
  44.     /**
  45.      * 构造方法，传入表示文件路径的字符串，并构造File对象，调用别的构造方法
  46.      * @param      name   the system-dependent filename
  47.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  48.      */
  49.     public FileOutputStream(String name) throws FileNotFoundException {
  50.         this(name != null ? new File(name) : null, false);
  51.     }
  53.     /**
  54.      * 传入表示文件路径的字符串和是否追加标识，将字符串初始化为File对象，并调用别的构造方法
  55.      * @param     name        the system-dependent file name
  56.      * @param     append      if <code>true</code>, then bytes will be written
  57.      *                   to the end of the file rather than the beginning
  58.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  59.      * @since     JDK1.1
  60.      */
  61.     public FileOutputStream(String name, boolean append)
  62.         throws FileNotFoundException
  63.     {
  64.         this(name != null ? new File(name) : null, append);
  65.     }
  67.     /**
  68.      * 传入File对象，调用别的构造方法
  69.      * @param      file               the file to be opened for writing.
  70.      * @see        java.io.File#getPath()
  71.      * @see        java.lang.SecurityException
  72.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  73.      */
  74.     public FileOutputStream(File file) throws FileNotFoundException {
  75.         this(file, false);
  76.     }
  78.     /**
  79.      * 传入文件对象和是否追加标识，构造输出流对象
  80.      * @param      file               the file to be opened for writing.
  81.      * @param     append      if <code>true</code>, then bytes will be written
  82.      *                   to the end of the file rather than the beginning
  83.      * @see        java.io.File#getPath()
  84.      * @see        java.lang.SecurityException
  85.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  86.      * @since 1.4
  87.      */
  88.     public FileOutputStream(File file, boolean append)
  89.         throws FileNotFoundException
  90.     {
  91.         // 合法验证
  92.         String name = (file != null ? file.getPath() : null);
  93.         SecurityManager security = System.getSecurityManager();
  94.         if (security != null) {
  95.             security.checkWrite(name);
  96.         }
  97.         if (name == null) {
  98.             throw new NullPointerException();
  99.         }
  100.         if (file.isInvalid()) {
  101.             throw new FileNotFoundException("Invalid file path");
  102.         }
  104.         // 正常赋值
  105.         this.fd = new FileDescriptor();
  106.         fd.attach(this);
  107.         this.append = append;
  108.         this.path = name;
  110.         // 根据文件路径和是否追加标识构建输出流
  111.         open(name, append);
  112.     }
  114.     /**
  115.      * 创建一个向指定文件描述符处写入数据的输出文件流
  116.      * @param      fdObj   the file descriptor to be opened for writing
  117.      * @see        java.lang.SecurityManager#checkWrite(java.io.FileDescriptor)
  118.      */
  119.     public FileOutputStream(FileDescriptor fdObj) {
  120.         SecurityManager security = System.getSecurityManager();
  121.         if (fdObj == null) {
  122.             throw new NullPointerException();
  123.         }
  124.         if (security != null) {
  125.             security.checkWrite(fdObj);
  126.         }
  127.         this.fd = fdObj;
  128.         this.append = false;
  129.         this.path = null;
  131.         fd.attach(this);
  132.     }
  134.     /**
  135.      * native方法，开启输出流
  136.      * @param name name of file to be opened
  137.      * @param append whether the file is to be opened in append mode
  138.      */
  139.     private native void open0(String name, boolean append)
  140.         throws FileNotFoundException;
  142.     // wrap native call to allow instrumentation
  143.     /**
  144.      * 打开文件，并标识追加还是覆盖
  145.      * @param name name of file to be opened
  146.      * @param append whether the file is to be opened in append mode
  147.      */
  148.     private void open(String name, boolean append)
  149.         throws FileNotFoundException {
  150.         open0(name, append);
  151.     }
  153.     /**
  154.      * native方法，向文件输出一个字节内容，并指定是追加到原有内容后面还是覆盖原有内容
  155.      * @param   b   the byte to be written.  需要输出的字节
  156.      * @param   append   {@code true} if the write operation first
  157.      *     advances the position to the end of file 是否追加
  158.      */
  159.     private native void write(int b, boolean append) throws IOException;
  161.     /**
  162.      * 向文件输出一个字节内容
  163.      * @param      b   the byte to be written.
  164.      * @exception  IOException  if an I/O error occurs.
  165.      */
  166.     public void write(int b) throws IOException {
  167.         write(b, append);
  168.     }
  170.     /**
  171.      * native方法，向文件输出byte数组从off下标之后的len个字节，并指定是否追加
  172.      * @param b the data to be written 字节数组
  173.      * @param off the start offset in the data 输出内容在字节数组的起始位置
  174.      * @param len the number of bytes that are written 输出多少个字节
  175.      * @param append {@code true} to first advance the position to the
  176.      *     end of file 是否追加
  177.      */
  178.     private native void writeBytes(byte b[], int off, int len, boolean append)
  179.         throws IOException;
  181.     /**
  182.      * 向文件输出字节数组的全部内容
  183.      * @param      b   the data.
  184.      */
  185.     public void write(byte b[]) throws IOException {
  186.         writeBytes(b, 0, b.length, append);
  187.     }
  189.     /**
  190.      * 向文件输出字节数组从off下标开始的len个字节
  191.      * @param      b     the data.
  192.      * @param      off   the start offset in the data.
  193.      * @param      len   the number of bytes to write.
  194.      */
  195.     public void write(byte b[], int off, int len) throws IOException {
  196.         writeBytes(b, off, len, append);
  197.     }
  199.     /**
  200.      * 关闭输出流
  201.      * @revised 1.4
  202.      * @spec JSR-51
  203.      */
  204.     public void close() throws IOException {
  206.         // 线程同步 
  207.         synchronized (closeLock) {
  208.             if (closed) {
  209.                 return;
  210.             }
  211.             closed = true;
  212.         }
  214.         // 关闭通道
  215.         if (channel != null) {
  216.             channel.close();
  217.         }
  219.         // 文件句柄释放
  220.         fd.closeAll(new Closeable() {
  221.             public void close() throws IOException {
  222.                close0();
  223.            }
  224.         });
  225.     }
  227.     /**
  228.      *  获取文件描述符（文件句柄）
  229.      * @return  the <code>FileDescriptor</code> object that represents
  230.      *          the connection to the file in the file system being used
  231.      *          by this <code>FileOutputStream</code> object.
  232.      * @see        java.io.FileDescriptor
  233.      */
  234.      public final FileDescriptor getFD()  throws IOException {
  235.         if (fd != null) {
  236.             return fd;
  237.         }
  238.         throw new IOException();
  239.      }
  241.     /**
  242.      * 获取通道
  243.      * @return  the file channel associated with this file output stream
  244.      * @since 1.4
  245.      * @spec JSR-51
  246.      */
  247.     public FileChannel getChannel() {
  248.         synchronized (this) {
  249.             if (channel == null) {
  250.                 channel = FileChannelImpl.open(fd, path, false, true, append, this);
  251.             }
  252.             return channel;
  253.         }
  254.     }
  256.     /**
  257.      * 释放资源，同时刷新缓存，强制将缓存中的内容写入文件
  258.      * @see        java.io.FileInputStream#close()
  259.      */
  260.     protected void finalize() throws IOException {
  261.         if (fd != null) {
  262.             if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
  263.                 flush();
  264.             } else {
  265.                 /* 
  266.                  */
  267.                 close();
  268.             }
  269.         }
  270.     }
  272.     private native void close0() throws IOException;
  274.     private static native void initIDs();
  276.     static {
  277.         initIDs();
  278.     }
  279. }

简单使用

package com.java.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @description
 * @date: 2021-01-18 22:01
 */
public class FileOutputStreamExample {
    public static void main(String[] args) {
        commonExample();
    }

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

            fileOutputStream.write("Test Message".getBytes());

            // 默认是追加到Test Message后面
            fileOutputStream.write(" Test Text".getBytes());

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

    }
}

输出结果：
图片.png