Java IO 之 FileInputStream & FileOutputStream源码分析
Writer ：BYSocket（泥沙砖瓦浆木匠） java
微 博：BYSocket ios
豆 瓣：BYSocket git
FaceBook：BYSocket github
Twitter ：BYSocket express
1、引子
文件，做为常见的数据源。关于操做文件的字节流就是 — FileInputStream & FileOutputStream。它们是Basic IO字节流中重要的实现类。 apache
2、FileInputStream源码分析
FileInputStream源码以下： 数组
/**
* FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
* 好比读取图片等的原始字节流。若是读取字符流，考虑使用 FiLeReader。
*/
publicclassSFileInputStream extendsInputStream
{
/* 文件描述符类---此处用于打开文件的句柄 */
private final FileDescriptor fd;
/* 引用文件的路径 */
private final String path;
/* 文件通道，NIO部分 */
private FileChannel channel = null;
private final Object closeLock = new Object();
private volatile boolean closed = false;
private static final ThreadLocal<Boolean> runningFinalize =
new ThreadLocal<>();
private static boolean isRunningFinalize() {
Boolean val;
if ((val = runningFinalize.get()) != null)
return val.booleanValue();
return false;
}
/* 经过文件路径名来建立FileInputStream */
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
/* 经过文件来建立FileInputStream */
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.incrementAndGetUseCount();
this.path = name;
open(name);
}
/* 经过文件描述符类来建立FileInputStream */
public FileInputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if (fdObj == null) {
throw new NullPointerException();
}
if (security != null) {
security.checkRead(fdObj);
}
fd = fdObj;
path = null;
fd.incrementAndGetUseCount();
}
/* 打开文件，为了下一步读取文件内容。native方法 */
private native void open(String name) throws FileNotFoundException;
/* 今后输入流中读取一个数据字节 */
public int read() throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int b = 0;
try {
b = read0();
} finally {
IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
}
return b;
}
/* 今后输入流中读取一个数据字节。native方法 */
private native int read0() throws IOException;
/* 今后输入流中读取多个字节到byte数组中。native方法 */
private native int readBytes(byte b[], int off, int len) throws IOException;
/* 今后输入流中读取多个字节到byte数组中。 */
public int read(byte b[]) throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int bytesRead = 0;
try {
bytesRead = readBytes(b, 0, b.length);
} finally {
IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
}
return bytesRead;
}
/* 今后输入流中读取最多len个字节到byte数组中。 */
public int read(byte b[], int off, int len) throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int bytesRead = 0;
try {
bytesRead = readBytes(b, off, len);
} finally {
IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
}
return bytesRead;
}
public native long skip(long n) throws IOException;
/* 返回下一次对此输入流调用的方法能够不受阻塞地今后输入流读取（或跳过）的估计剩余字节数。 */
public native int available() throws IOException;
/* 关闭此文件输入流并释放与此流有关的全部系统资源。 */
public void close() throws IOException {
synchronized (closeLock) {
if (closed) {
return;
}
closed = true;
}
if (channel != null) {
fd.decrementAndGetUseCount();
channel.close();
}
int useCount = fd.decrementAndGetUseCount();
if ((useCount <= 0) || !isRunningFinalize()) {
close0();
}
}
public final FileDescriptor getFD() throws IOException {
if (fd != null) return fd;
throw new IOException();
}
/* 获取此文件输入流的惟一FileChannel对象 */
publicFileChannel getChannel() {
synchronized(this) {
if(channel == null) {
channel = FileChannelImpl.open(fd, path, true, false, this);
fd.incrementAndGetUseCount();
}
returnchannel;
}
}
privatestaticnativevoidinitIDs();
privatenativevoidclose0() throwsIOException;
static{
initIDs();
}
protected void finalize() throws IOException {
if((fd != null) && (fd != FileDescriptor.in)) {
runningFinalize.set(Boolean.TRUE);
try{
close();
} finally{
runningFinalize.set(Boolean.FALSE);
}
}
}
}
1. 三个核心方法 app
三个核心方法，也就是Override（重写）了抽象类InputStream的read方法。 less
int read() 方法，即 socket
public int read() throws IOException
代码实现中很简单，一个try中调用本地native的read0()方法，直接从文件输入流中读取一个字节。IoTrace.fileReadEnd(),字面意思是防止文件没有关闭读的通道，致使读文件失败，一直开着读的通道，会形成内存泄露。
int read(byte b[]) 方法，即
public int read(byte b[]) throws IOException
代码实现也是比较简单的，也是一个try中调用本地native的readBytes()方法，直接从文件输入流中读取最多b.length个字节到byte数组b中。
int read(byte b[], int off, int len) 方法，即
public int read(byte b[], int off, int len) throws IOException
代码实现和 int read(byte b[])方法 同样，直接从文件输入流中读取最多len个字节到byte数组b中。
但是这里有个问：
Q： 为何 int read(byte b[]) 方法须要本身独立实现呢？ 直接调用 int read(byte b[], int off, int len) 方法，即read(b , 0 , b.length)，等价于read(b)？
A：待完善，但愿路过大神回。。。。向下兼容？？ Finally？？
2. 值得一提的native方法
上面核心方法中为何实现简单，由于工做量都在native方法里面，即JVM里面实现了。native却是很多一一列举吧：
native void open(String name) // 打开文件，为了下一步读取文件内容
native int read0() // 从文件输入流中读取一个字节
native int readBytes(byte b[], int off, int len) // 从文件输入流中读取，从off句柄开始的len个字节，并存储至b字节数组内。
native void close0() // 关闭该文件输入流及涉及的资源，好比说若是该文件输入流的FileChannel对被获取后，须要对FileChannel进行close。
其余还有值得一提的就是，在jdk1.4中，新增了NIO包，优化了一些IO处理的速度，因此在FileInputStream和FileOutputStream中新增了FileChannel getChannel()的方法。即获取与该文件输入流相关的 java.nio.channels.FileChannel对象。
3、FileOutputStream 源码分析
FileOutputStream 源码以下：
/**
* 文件输入流是用于将数据写入文件或者文件描述符类
* 好比写入图片等的原始字节流。若是写入字符流，考虑使用 FiLeWriter。
*/
publicclassSFileOutputStream extendsOutputStream
{
/* 文件描述符类---此处用于打开文件的句柄 */
private final FileDescriptor fd;
/* 引用文件的路径 */
private final String path;
/* 若是为 true，则将字节写入文件末尾处，而不是写入文件开始处 */
private final boolean append;
/* 关联的FileChannel类，懒加载 */
private FileChannel channel;
private final Object closeLock = new Object();
private volatile boolean closed = false;
private static final ThreadLocal<Boolean> runningFinalize =
new ThreadLocal<>();
private static boolean isRunningFinalize() {
Boolean val;
if ((val = runningFinalize.get()) != null)
return val.booleanValue();
return false;
}
/* 经过文件名建立文件输入流 */
public FileOutputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null, false);
}
/* 经过文件名建立文件输入流，并肯定文件写入起始处模式 */
public FileOutputStream(String name, boolean append)
throws FileNotFoundException
{
this(name != null ? new File(name) : null, append);
}
/* 经过文件建立文件输入流，默认写入文件的开始处 */
public FileOutputStream(File file) throws FileNotFoundException {
this(file, false);
}
/* 经过文件建立文件输入流，并肯定文件写入起始处 */
public FileOutputStream(File file, boolean append)
throws FileNotFoundException
{
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkWrite(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
this.fd = new FileDescriptor();
this.append = append;
this.path = name;
fd.incrementAndGetUseCount();
open(name, append);
}
/* 经过文件描述符类建立文件输入流 */
public FileOutputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if (fdObj == null) {
throw new NullPointerException();
}
if (security != null) {
security.checkWrite(fdObj);
}
this.fd = fdObj;
this.path = null;
this.append = false;
fd.incrementAndGetUseCount();
}
/* 打开文件，并肯定文件写入起始处模式 */
private native void open(String name, boolean append)
throws FileNotFoundException;
/* 将指定的字节b写入到该文件输入流，并指定文件写入起始处模式 */
private native void write(int b, boolean append) throws IOException;
/* 将指定的字节b写入到该文件输入流 */
public void write(int b) throws IOException {
Object traceContext = IoTrace.fileWriteBegin(path);
int bytesWritten = 0;
try {
write(b, append);
bytesWritten = 1;
} finally {
IoTrace.fileWriteEnd(traceContext, bytesWritten);
}
}
/* 将指定的字节数组写入该文件输入流，并指定文件写入起始处模式 */
private native void writeBytes(byte b[], int off, int len, boolean append)
throws IOException;
/* 将指定的字节数组b写入该文件输入流 */
public void write(byte b[]) throws IOException {
Object traceContext = IoTrace.fileWriteBegin(path);
int bytesWritten = 0;
try {
writeBytes(b, 0, b.length, append);
bytesWritten = b.length;
} finally {
IoTrace.fileWriteEnd(traceContext, bytesWritten);
}
}
/* 将指定len长度的字节数组b写入该文件输入流 */
public void write(byte b[], int off, int len) throws IOException {
Object traceContext = IoTrace.fileWriteBegin(path);
int bytesWritten = 0;
try {
writeBytes(b, off, len, append);
bytesWritten = len;
} finally {
IoTrace.fileWriteEnd(traceContext, bytesWritten);
}
}
/* 关闭此文件输出流并释放与此流有关的全部系统资源 */
publicvoidclose() throwsIOException {
synchronized(closeLock) {
if(closed) {
return;
}
closed = true;
}
if(channel != null) {
fd.decrementAndGetUseCount();
channel.close();
}
intuseCount = fd.decrementAndGetUseCount();
if((useCount <= 0) || !isRunningFinalize()) {
close0();
}
}
public final FileDescriptor getFD() throws IOException {
if(fd != null) returnfd;
thrownewIOException();
}
publicFile Channel getChannel() {
synchronized(this) {
if(channel == null) {
channel = FileChannelImpl.open(fd, path, false, true, append, this);
fd.incrementAndGetUseCount();
}
returnchannel;
}
}
protected void finalize() throws IOException {
if(fd != null) {
if(fd == FileDescriptor.out || fd == FileDescriptor.err) {
flush();
} else{
runningFinalize.set(Boolean.TRUE);
try{
close();
} finally{
runningFinalize.set(Boolean.FALSE);
}
}
}
}
private native void close0() throws IOException;
private static native void initIDs();
static{
initIDs();
}
}
1. 三个核心方法
三个核心方法，也就是Override（重写）了抽象类OutputStream的write方法。
void write(int b) 方法，即
public void write(intb) throws IOException
代码实现中很简单，一个try中调用本地native的write()方法，直接将指定的字节b写入文件输出流。IoTrace.fileReadEnd()的意思和上面FileInputStream意思一致。
void write(byte b[]) 方法，即
public void write(byteb[]) throws IOException
代码实现也是比较简单的，也是一个try中调用本地native的writeBytes()方法，直接将指定的字节数组写入该文件输入流。
void write(byte b[], int off, int len) 方法，即
public void write(byte b[], int off, int len) throws IOException
代码实现和 void write(byte b[]) 方法 同样，直接将指定的字节数组写入该文件输入流。
2. 值得一提的native方法
上面核心方法中为何实现简单，由于工做量都在native方法里面，即JVM里面实现了。native却是很多一一列举吧：
native void open(String name) // 打开文件，为了下一步读取文件内容
native void write(int b, boolean append) // 直接将指定的字节b写入文件输出流
native native void writeBytes(byte b[], int off, int len, boolean append) // 直接将指定的字节数组写入该文件输入流。
native void close0() // 关闭该文件输入流及涉及的资源，好比说若是该文件输入流的FileChannel对被获取后，须要对FileChannel进行close。
类似之处：
其实到这里，该想想。两个源码实现很类似，并且native方法也很类似。其实不能说“类似”，应该以“对应”来归纳它们。
它们是一组，是一根吸管的两个孔的关系：“一个Input一个Output”。
休息一下吧~ 看看小广告：
开源代码都在个人gitHub上哦 — https://github.com/JeffLi1993 做者留言“请手贱，点项目star，支持支持拜托拜托”
4、使用案例
下面先看代码：
packageorg.javacore.io;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
* Copyright [2015] [Jeff Lee]
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Jeff Lee
* @since 2015-10-8 20:06:03
* FileInputStream&FileOutputStream使用案例
*/
public class FileIOStreamT {
private static final String thisFilePath =
"src"+ File.separator +
"org"+ File.separator +
"javacore"+ File.separator +
"io"+ File.separator +
"FileIOStreamT.java";
public static void main(String[] args) throws IOException {
// 建立文件输入流
FileInputStream fileInputStream = new FileInputStream(thisFilePath);
// 建立文件输出流
FileOutputStream fileOutputStream = new FileOutputStream("data.txt");
// 建立流的最大字节数组
byte[] inOutBytes = new byte[fileInputStream.available()];
// 将文件输入流读取，保存至inOutBytes数组
fileInputStream.read(inOutBytes);
// 将inOutBytes数组，写出到data.txt文件中
fileOutputStream.write(inOutBytes);
fileOutputStream.close();
fileInputStream.close();
}
}
运行后，会发现根目录中出现了一个“data.txt”文件，内容为上面的代码。
1. 简单地分析下源码：
一、建立了FileInputStream，读取该代码文件为文件输入流。
二、建立了FileOutputStream，做为文件输出流，输出至data.txt文件。
三、针对流的字节数组，一个 read ，一个write，完成读取和写入。
四、关闭流
2. 代码调用的流程如图所示：
3. 代码虽简单，可是有点小问题：
FileInputStream.available() 是返回流中的估计剩余字节数。因此通常不会用此方法。
通常作法，好比建立一个 byte数组，大小1K。而后read至其返回值不为-1，一直读取便可。边读边写。
5、思考与小结
FileInputStream & FileOutputStream 是一对来自 InputStream和OutputStream的实现类。用于本地文件读写（二进制格式按顺序读写）。
本文小结：
一、FileInputStream 源码分析
二、FileOutputStream 资源分析
三、FileInputStream & FileOutputStream 使用案例
四、其源码调用过程
欢迎点击个人博客及GitHub — 博客提供RSS订阅哦！
———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-
- 1. IO流之FileInputStream和FileOutputStream
- 2. java io 笔记二：FileOutPutStream、FileInPutStream、FileWriter、FileReader类
- 3. Java流操作之FileInputStream&FileOutputStream
- 4. java IO操做:FileInputStream,FileOutputStream,FileReader,FileWriter实例
- 5. JavaIO之FileInputStream 与 FileOutputStream
- 6. FileInputStream与FileOutputStream类
- 7. [八]JavaIO之FileInputStream 与 FileOutputStream
- 8. FileOutputStream 与FileInputStream
- 9. BufferedInputStream & BufferedOutputStream、FileInputStream & FileOutputStream
- 10. Java基础-FileInputStream与FileOutputStream
- 更多相关文章...
- • Java操作Neo4j数据库（附带源码） - NoSQL教程
- • Rust 文件与 IO - RUST 教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • Java Agent入门实战（二）-Instrumentation源码概述
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. IO流之FileInputStream和FileOutputStream
- 2. java io 笔记二：FileOutPutStream、FileInPutStream、FileWriter、FileReader类
- 3. Java流操作之FileInputStream&FileOutputStream
- 4. java IO操做:FileInputStream,FileOutputStream,FileReader,FileWriter实例
- 5. JavaIO之FileInputStream 与 FileOutputStream
- 6. FileInputStream与FileOutputStream类
- 7. [八]JavaIO之FileInputStream 与 FileOutputStream
- 8. FileOutputStream 与FileInputStream
- 9. BufferedInputStream & BufferedOutputStream、FileInputStream & FileOutputStream
- 10. Java基础-FileInputStream与FileOutputStream