Java IO - FileInputStream&FileOutputStream

最新推荐文章于 2022-01-09 21:46:35 发布
最新推荐文章于 2022-01-09 21:46:35 发布
阅读量522 收藏
点赞数
分类专栏： Java IO Java IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012420654/article/details/51559218
版权

基本概念

  • FileInputStream 从文件系统中的某个文件中获得输入字节

  • FileOutputStream 文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。

  • 继承结构

这里写图片描述

这里写图片描述

实例探究

  • 写入文件的字节都会被底层按照系统默认编码转换成字符存到文件中

  • 当使用文件字节输出来的时候会被反转成字节

public class Test {

    private static final String TEMPFILE = "E:" + File.separator + "Test.txt";
    private static final String DESFILE = "E:" + File.separator + "Test2.txt";

    //英文字母 a ~ h
    private static final byte[] byteArray = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69 };

    public static void main(String[] args) throws IOException {
        write(TEMPFILE);
        read(TEMPFILE);
        copyFile(TEMPFILE, DESFILE);
    }

    public static void write(String path) {
        // 初始化，不然关闭流时编译不通过
        FileOutputStream fos = null;

        try {
            // 创建流，这里探究追加模式。假设文本内容现在为 1，2，3
            fos = new FileOutputStream(new File(path), true);

            // 写入 a
            fos.write(byteArray[0]);

            // 写入 b，c，d，e，f
            fos.write(byteArray, 1, 5);

            fos.close();

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

    public static void read(String path) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File(path));

            char temp = (char) fis.read();

            // 输出 1
            System.out.print(temp);

            byte[] buffer = new byte[1024];
            int count = 0;
            while ((count = fis.read(buffer)) != -1) {
                // 输出 234abcdefabcdefabcdef
                System.out.println(new String(buffer, 0, count));
            }

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

    // 文件复制
    public static void copyFile(String srcPath, String desPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(new File(srcPath));
            fos = new FileOutputStream(new File(desPath));

            // 为了效率，一般采用按字节数组读取
            byte[] buffer = new byte[1024];
            int count = 0;
            while ((count = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, count);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }

                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

源码分析

1.FileInputStream

类结构图如下：

这里写图片描述

首先来看类中的静态代码块,它的作用是设置类中（也就是FileInputStream）的属性的内存地址偏移量，便于在必要时操作内存给它赋值。

static {
    initIDs();
}

private static native void initIDs();

成员变量

// 文件描述符类，表示用来打开文件的句柄
private FileDescriptor fd;

// 文件通道，NIO部分
private FileChannel channel = null;

private Object closeLock = new Object(); 

private volatile boolean closed = false;

private static final ThreadLocal<Boolean> runningFinalize = new ThreadLocal<Boolean>();

该类总共定义了 3 个构造函数，通过代码可以发现可以 ①③ 都是通过获取实际的文件连接，在通过 open 方法来创建流。而 ② 是直接通过文件描述符创建流。

// ①构造函数，通过文件路径创建
public FileInputStream(String name) throws FileNotFoundException {
    this(name != null ? new File(name) : null);
}

// ②构造函数，通过文件描述符创建
public FileInputStream(FileDescriptor fdObj) {
    SecurityManager security = System.getSecurityManager();
    if (fdObj == null) {
        throw new NullPointerException();
    }
    if (security != null) {
        security.checkRead(fdObj);
    }
    fd = fdObj;

    fd.incrementAndGetUseCount();
}

// ③构造函数，通过文件连接创建
public FileInputStream(File file) throws FileNotFoundException {

    String name = (file != null ? file.getPath() : null);

    // 操作文件之前，检查是否具有 read 权限
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
        security.checkRead(name);
    }

    // 判断路径的合法性
    if (name == null) {
        throw new NullPointerException();
    }

    // 打开文件
    fd = new FileDescriptor();
    fd.incrementAndGetUseCount();
    open(name);
}

// 关键-->打开系统文件，native 方法
private native void open(String name) throws FileNotFoundException;

接下来看它 的 read 方法，观察下面的代码，发现在类中定义了常见的 3 种读取方式，如①②③。① 本身就是个native 方法，而 ②③则是通过 readBytes 这个 native 方法用来实现文件的读取。

//① 从此输入流中读取一个数据字节
public native int read() throws IOException;

//关键-->实际操作由它完成
private native int readBytes(byte b[], int off, int len) throws IOException;


//②从此输入流中将最多 len 个字节的数据读入一个 byte 数组中
public int read(byte b[]) throws IOException {
    return readBytes(b, 0, b.length);
}

//③从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
public int read(byte b[], int off, int len) throws IOException {
    return readBytes(b, off, len);
}

接着来看其他流中没有的而 FileInputStream 中独有的几个方法

//返回文件描述符，表示该文件正在被 FileInputStream 使用
public final FileDescriptor getFD() throws IOException {
    if (fd != null) {
        return fd;
    }
    throw new IOException();
}

//返回文件文件通过，这里只允许单线程访问
public FileChannel getChannel() {
    synchronized (this) {
        if (channel == null) {
            channel = FileChannelImpl.open(fd, true, false, this);

            fd.incrementAndGetUseCount();

        }
        return channel;
    }
}

//重写了 Object 的方法，确保该文件输入流的close方法被调用的时候它不用有引用
protected void finalize() throws IOException {
    if ((fd != null) && (fd != FileDescriptor.in)) {
        // 当前其他流操作该对象时，调用该方法无法释放资源。但是可以调用 colse 方法强行释放。
        runningFinalize.set(Boolean.TRUE);
        try {
            close();
        } finally {
            runningFinalize.set(Boolean.FALSE);
        }
    }
}

最后再来看看剩下的几个方法

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 相关联的计算器（当每获得一个新的通道时，该计算器增加）
        fd.decrementAndGetUseCount();
        channel.close();
    }

    int useCount = fd.decrementAndGetUseCount();

    if ((useCount <= 0) || !isRunningFinalize()) {
        close0();
    }
}

private native void close0() throws IOException;

2.FileOutputStream

类结构图

Alt text

首先来看静态代码块，作用同上。

static {
    initIDs();
}

private static native void initIDs();

成员变量

private FileDescriptor fd;

private FileChannel channel = null;

private boolean append = false;

private Object closeLock = new Object();

private volatile boolean closed = false;

private static final ThreadLocal<Boolean> runningFinalize = new ThreadLocal<Boolean>();

在分析构造函数之前先来看两个 native 方法

//替换原文件的内容
private native void open(String name) throws FileNotFoundException;

//文件原有内容的末尾追加新内容
private native void openAppend(String name) throws FileNotFoundException;

该类定义了 5 个构造函数，其中 ① ~ ④ 都是通过 file 类来创建流，具体的实现都在 ④ 里面。默认未指定 append 时为false，表示替换原文件的内容，当 append 为 true 时，表示在文件原有内容的末尾追加新内容。观察 ④，发现该方法分别调用了 open ，openAppend 这两个 native 方法来实现操作。而 ⑤ 则是通过文件描述符完成创建

//①构造函数，根据文件路径创建，默认不追加内容
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();
    }
    fd = new FileDescriptor();
    fd.incrementAndGetUseCount();
    this.append = append;

    //判断是否追加内容
    if (append) {
        openAppend(name);
    } else {
        open(name);
    }
}

//⑤构造函数，根据文件描述符创建
public FileOutputStream(FileDescriptor fdObj) {
    SecurityManager security = System.getSecurityManager();
    if (fdObj == null) {
        throw new NullPointerException();
    }

    if (security != null) {
        security.checkWrite(fdObj);
    }

    fd = fdObj;

    fd.incrementAndGetUseCount();
}

接着来看 writer 方法，与 文件输入流的 read 方法类型，不再分析。

public native void write(int b) throws IOException;

private native void writeBytes(byte b[], int off, int len) throws IOException;

public void write(byte b[]) throws IOException {
    writeBytes(b, 0, b.length);
}

public void write(byte b[], int off, int len) throws IOException {
    writeBytes(b, off, len);
}

再来看看普通输出流没有，而 FileOutputStream 独有的方法。

public final FileDescriptor getFD() throws IOException {
    if (fd != null) {
        return fd;
    }

    throw new IOException();
}

public FileChannel getChannel() {
    synchronized (this) {
        if (channel == null) {
            channel = FileChannelImpl.open(fd, false, true, this, append);

            fd.incrementAndGetUseCount();
        }
        return channel;
    }
}

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);
            }
        }
    }
}

最后再来看看 close 方法

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();
    }
}

private static boolean isRunningFinalize() {
    Boolean val;
    if ((val = runningFinalize.get()) != null)
        return val.booleanValue();
    return false;
}

private native void close0() throws IOException;
oxf
关注
专栏目录
Java8 I/O源码-FileInputStream与FileOutputStream
潘威威的博客
10-18 2139
FileInputStream是文件输入流，用于从文件系统中的某个文件中获得输入字节。FileInputStream用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用FileReader。 FileOutputStream是文件输出流，用于将数据写入File或FileDescriptor的输出流。FileOutputStream用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用FileWri
Java IO：FileInputStream和FileOutputStream使用详解及源码分析
ahsxsk的学习之路
04-08 4455
1 使用方法　　FileInputStream即文件输入流，使用它从文件中获得字节流，FileOutputStream即问价输出流，使用它将字节流写入文件。1.1 方法介绍　　FileInputStream提供的API如下：FileInputStream(File file) // 创建“File对象”对应的“文件输入流” FileInputStream(FileDescriptor
java文件输入与输出流结合FileInputStream与FileOutputStream
weixin_41069726的博客
01-16 381
void init() throws IOException { String filePath = “…/…/…/desktop/test/1.txt”; FileOutputStream fos = new FileOutputStream(filePath,true); try { byte[] b =new byte[] { 99,100,101,102,103,104,105,106,1...
FileInputStream
weixin_33719619的博客
01-14 150
引用：http://blog.sina.com.cn/s/blog_66e177dd0100h79m.html 无论二进制文件还是文本文件，都可以用文件输入流 java.io.FileInputStream 以字节的方式进行读取操作。如果想以字符的形式读取文本文件，则应该使用 java.io.FileReader 。 [注：从本质上说，文件都是以字节码（即所谓的二进制码）的形式存在的。如果这些...
Java FileInputStream getFD（）方法与示例
07-11 741
FileInputStream类的getFD()方法 (FileInputStream Class getFD() method) getFD() method is available in java.io package. getFD()方法在java.io包中可用。 getFD() method is used to return the FileDescriptor object tha...
Java基础知识之FileOutputStream
JCDYN1219的博客
03-22 433
FileOutputStream将数据导入文件当中： import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /** * 文件字节输出流，负责写。 * 从内存到硬盘。 */ public class FileOutputStreamTest01 { public static void main(String[] args) { Fi...
【IT十八掌徐培成】Java基础第13天-04.字节流-FileInputStream-FileOutputStream.zip
08-07
`FileInputStream`和`FileOutputStream`是Java.io包下的核心类，它们分别代表了文件输入流和文件输出流。这两个类用于对文件进行字节级别的读写操作，适用于处理任何类型的二进制数据，如图片、音频、视频文件等。 ...
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
Java IO流中的File类提供了文件的创建、删除、重命名等操作，FileInputStream和FileOutputStream则用于文件的读写。 9. **NIO（New IO）** NIO（非阻塞I/O）是Java 1.4引入的新特性，提供了一种新的I/O模型，它...
Java——FileInputStream&FileOutputStream字节流实现文件复制
菜鸟的成长之路...
03-11 4387
要实现文件的复制，有很多种方法。今天介绍一种最基础的方法：使用FileInputStream和FileOutputStream实现文件的复制。思路：要实现文件的复制，其实质就是对源文件数据进行读取，再将这些数据写入目标文件，从而实现文件的复制。实现：创建IOUtils类及copyFile方法：package fileCopy;import java.io.File; import java.io.F
java中FileOutputStream流，向文件中追加内容，而不是覆盖掉文件中原有的数据
到达的专栏
06-30 2万+
public FileOutputStream(String name,boolean append) throws FileNotFoundException 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。 new 的时候加一个true参数则是追加。默认为false，则是覆盖。
fileoutputstream 抛文件找不到异常
zona
04-14 1万+
今天使用fileoutputstream的时候， 抛了文件找不到异常：FileNotFoundException 我们知道， 使用new Fileoutputstream(filepath)时， 如果filepath指定的文件不存在， 文件输出流会帮我们自动创建一个文件。仅仅是文件而已。 如果filepath中包含尚未创建的目录， 就会抛出文件找不到异常。 所以在使用输出流之前， 最好使用Fil
用Java进行文件操作时，报出“at java.io.FileOutputStream.<init>(Unknown Source)”错误
weixin_41298964的博客
05-13 1万+
我用Java编写文件管理器时，要写一个文件复制的函数，结果遇到“C:\Users\Administrator\eclipse-workspace\project1\bin\Folderdir3\dir2\FileDemo.java (系统找不到指定的路径。)at java.io.FileOutputStream.open0(Native Method)at java.io.FileOutputSt...
Java 的 FileInputStream 是否需要 close
sleepybear1113的博客
01-09 9240
Java 的 FileInputStream 是否需要 close，是否导致内存泄漏，和其他读写问题
java.io.FileNotFoundException 文件名、目录名或卷标语法不正确 的处理
热门推荐
Yoghurt的博客
01-30 2万+
FileNotFoundException 异常的处理
一些常用的流
tomorrow_fine的博客
05-08 834
FileInputStream 构造方法 FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。  FileInputStream(FileDescriptor fdObj) 创建 FileInputStream通过使用文件描述符 fdObj ，其表示在文件系统中的
java中FileInputStream和OutputStream解析
刘伟的博客
05-16 4417
FileInputStream和FileOutputStream分别表示读写文件数据流，前者是将文件数据读取到内存中，后者表示将内存中的数据写入到文件中。1.FileInputStreamFileInputStream从文件系统中的文件中获得输入的字节数据。主要的构造方法有以下三种： FileInputStream(File file) 用File对象来构造FileInputStream(Str
Java FileInputStream close（）方法与示例
cumtb2002的博客
07-11 3423
FileInputStream类close()方法 (FileInputStream Class close() method) close() method is available in java.io package. close()方法在java.io包中可用。 close() method is used to close this FileInputStream and free...
Java IO理解：文件字节流 FileInputStream与FileOutputStream
2. **java.io** - 输入/输出包，包含了处理I/O操作的类，如InputStream、OutputStream、Reader、Writer等，以及FileInputStream和FileOutputStream，用于文件的读写。 3. **java.util** - 实用工具包，提供了各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

oxf

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值