Java FileInputStream FileOutputStream类源码解析

最新推荐文章于 2022-08-21 14:54:39 发布
最新推荐文章于 2022-08-21 14:54:39 发布
阅读量270 收藏
点赞数
文章标签： java 操作系统
原文链接：https://yq.aliyun.com/articles/629062
版权

FileInputStream和FileOutputStream是匹配的文件输出输出流，读取和写入的是byte，所以适合用来处理一些非字符的数据，比如图片数据。因为涉及到大量关于文件的操作，所以存在很多的native方法和利用操作系统的文件系统实现，所以要深入了解文件输入输出流还是需要加强操作系统和native源码的知识。先来看一下简单的使用示例：

    public static void main(String args[]) throws IOException{
        FileOutputStream out = new FileOutputStream("D:/test/file.txt");
        out.write("1234567890".getBytes());//1234567890
        out.close();
        out = new FileOutputStream("D:/test/file.txt");
        out.write("765".getBytes());//765
        out.close();
        out = new FileOutputStream("D:/test/file.txt", true);
        out.write("asdfgh".getBytes());//765asdfgh
        out.close();
        new File("D:/test/file.txt");//765asdfgh
        out = new FileOutputStream("D:/test/file.txt");
        out.close();//内容为空
        
        //测试filechannel位置改变对stream的影响
        out = new FileOutputStream("D:/test/file.txt");
        out.write("1234567890".getBytes());//1234567890
        out.close();
        
        FileInputStream in = new FileInputStream("D:/test/file.txt");
        
        System.out.print(String.valueOf((byte)in.read() & 0xf));//1
        System.out.print(String.valueOf((byte)in.read() & 0xf));//2
        System.out.print(String.valueOf((byte)in.read() & 0xf));//3
        
        in.getChannel().position(5);
        System.out.print(String.valueOf((byte)in.read() & 0xf));//6
        in.getChannel().position(0);
        System.out.print(String.valueOf((byte)in.read() & 0xf));//1
        
        in.skip(-1);//向前跳一位
        System.out.print(String.valueOf((byte)in.read() & 0xf));//1
    }

FileInputStream

实现了抽象类InputStream，FileInputStream从文件系统中的文件获取bytes，文件是否有效取决于主机环境。FileInputStream对于直接从流中读取bytes数据非常有意义如图像数据。如果要读取字符信息，考虑使用FileReader。我们可以看到除了close以外，没有出现任何锁，但是实际上如果我们使用多个线程读取同一个文件时，单次读取是原子操作，见下方代码：

package test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileThreadTest implements Runnable {
    private int type;// 0做skip操作，1做读取操作
    
    private int gap;

    private FileInputStream in;

    public FileThreadTest(int type, FileInputStream in, int gap) {
        this.type = type;
        this.in = in;
        this.gap = gap;
    }

    @Override
    public void run() {
        byte[] body = new byte[gap];
        if (this.type == 0) {
            try {
                for(int i = 0; i < 4; i++) {
                    in.skip(gap);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            try {
                for(int i = 0; i < 10; i++) {
                    in.read(body);
                    System.out.println(Thread.currentThread().getName() + "-" + new String(body));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
    }

    public static void main(String args[]) throws IOException, InterruptedException {
        FileOutputStream out = new FileOutputStream("D:/test/file.txt");
        for (int i = 0; i < 1000; i++) {
            out.write("1234567890".getBytes());// 写入测试数据
        }
        out.close();
        FileInputStream in = new FileInputStream("D:/test/file.txt");
        FileThreadTest t1 = new FileThreadTest(0, in, 2);
        FileThreadTest t2 = new FileThreadTest(1, in, 4);
        FileThreadTest t3 = new FileThreadTest(1, in, 3);
        Thread thread1 = new Thread(t1,"线程1");
        Thread thread2 = new Thread(t2,"线程2");
        Thread thread3 = new Thread(t3,"线程3");
        thread2.start();
        thread3.start();
        thread1.start();
        thread1.join();
        thread2.join();
        thread3.join();
        in.close();
        /*
        线程3-567
        线程3-678
        线程2-1234
        线程3-901
        线程3-678
        线程2-2345
        线程2-2345
        线程2-6789
        线程2-0123
        线程2-4567
        线程2-8901
        线程2-2345
        线程2-6789
        线程3-901
        线程3-456
        线程3-789
        线程2-0123
        线程3-012
        线程3-345
        线程3-678
        */
    }
}

运行结果试机器配置每次运行会有所不同，但是我们可以看到无论怎么运行，每一次read操作本身是不会被其他线程抢占而中断的，它一定会完整的读取到这次要读取的内容，但是由于其他线程可以改变输入流的位置，所以每个线程读取时开始的位置是不可预知的，每个线程的read和skip操作都会改变流的位置。

先来看下内部变量，一个文件输出流有文件路径名、文件描述符、文件通道属性，若由文件描述符来创建，则文件路径名为null

    /* 文件描述符，用来打开文件*/
    private final FileDescriptor fd;

    /**
     * 引用文件的路径，如果流是通过文件描述符创建时该值为null
     */
    private final String path;

    private FileChannel channel = null;
    //用于保证close操作的线程安全性
    private final Object closeLock = new Object();
    private volatile boolean closed = false;

然后是构造函数，主要分为通过文件路径名、文件描述符、具体文件，通过文件描述符创建时文件路径名为null

    /**
     * 通过打开一个连接实际文件的连接来创建一个FileInputStream，文件通过文件系统中的路径名name来命名。
     * 一个新的文件描述符对象会被创建来表示这个文件连接
     * 如果存在安全管理器，checkRead方法会被调用，name作为参数传入
     * 如果文件名不存在，或者是一个目录而不是规则文件，或者因为其他原因无法打开读取，抛出FileNotFoundException
     */
    public FileInputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null);
    }
    //通过具体文件来创建，其他情况同上
    public FileInputStream(File file) throws FileNotFoundException {
        String name = (file != null ? file.getPath() : null);//name是file的路径名
        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.attach(this);//绑定文件描述符便于关闭对象
        path = name;
        open(name);//打开文件
    }

    /**
     * 通过文件描述符fdObj来创建FileInputStream，代表了对一个文件系统中实际存在文件的连接
     * 如果FileInputStream是null会抛出NullPointerException
     * 如果fdObj是无效的，构造器不会抛出异常，但是，如果调用这个流的IO方法，会抛出IOException
     */
    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.attach(this);
    }

文件本身需要打开才能进行操作，open只能由构造函数来调用，最终是由native方法open0来完成的系统的交互

    private void open(String name) throws FileNotFoundException {
        open0(name);
    }

    private native void open0(String name) throws FileNotFoundException;

读取根据参数重载分为读取单个字节和读取字符数组，它们分别基于native方法read0和readBytes，前面的测试中，我们可以看到被多个线程共享的FileInputStream依然能够保证单次的read操作读取的信息是完整的，这应该与readBytes的实现有关

    //从流中读取byte，如果没有有输出没有完成会阻塞方法
    public int read() throws IOException {
        return read0();
    }
    //从流中读取最大b.length的bytes数据到数组b中。该方法会被阻塞知道某些输入完成
    public int read(byte b[]) throws IOException {
        return readBytes(b, 0, b.length);
    }
    //从流中读取长度为len的数据，放到b中从off开始的位置
    public int read(byte b[], int off, int len) throws IOException {
        return readBytes(b, off, len);
    }

    private native int read0() throws IOException;
    private native int readBytes(byte b[], int off, int len) throws IOException;

skip也是native方法跳过并废弃输入流中n个bytes数据，skip方法可能因为一些不同的原因以跳过更少的bytes数结束，可能这个数量是0.如果n是负数，方法会尝试往回跳（见本文最上方例子）。如果文件不支持从当前位置往回掉，会抛出IOException。返回的是实际跳过的bytes数量，为正是往后跳，为负是往前跳。可能会跳过比文件中剩余数量更多的bytes数，这个过程不会产生异常，跳过的bytes数可能包括了一些文件中超过了EOF文件结束符的bytes数，跳过了文件结束符再尝试读取会返回-1，说明已经到达文件末尾。

    public native long skip(long n) throws IOException;

available也是native方法，返回剩余可读取的或者可跳过的bytes数的估计值，这个过程不会阻塞下一个操作。文件超过EOF时返回0。下一个调用可能是相同的线程或不同的线程，一个读取或者跳过这么多bytes的操作不会被阻塞，但是可能读取或跳过更少的bytes。一些情况下，一个非阻塞的读取或者跳过可能在非常慢时被阻塞，比如从一个很慢的网络中读取大文件。

    public native int available() throws IOException;

close关闭文件输入流并释放相关联的任何系统资源，如果流关联通道则通道也要关闭。通过加锁保证只能进行一次，避免重复关闭。最终由文件描述符通过close0来关闭文件。

    public void close() throws IOException {
        synchronized (closeLock) {//只能由一个线程来执行关闭一次
            if (closed) {
                return;
            }
            closed = true;
        }
        if (channel != null) {
           channel.close();//关闭关联的通道
        }

        fd.closeAll(new Closeable() {//通知文件描述符关闭文件
            public void close() throws IOException {
               close0();
           }
        });
    }

    private native void close0() throws IOException;

getChannel返回关联的通道，初始化通道的位置是目前位置从文件中读取的bytes数量。从流中读取bytes会增加通道的位置，改变通道的位置会改变流中的文件位置。延迟初始化，第一次调用该方法才会打开文件通道。

    public FileChannel getChannel() {
        synchronized (this) {//初始化单例
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
            }
            return channel;
        }
    }

finalize是protected方法必须通过继承FileInputStram的类来使用，作用是确保close在没有任何对流的引用时被调用，也就是避免其他线程中流还在读取，另一个线程发起了close，因为可以通过文件描述符来判断是否是in状态也就是正在读取。

    protected void finalize() throws IOException {
        if ((fd != null) &&  (fd != FileDescriptor.in)) {
            /* 
             * 如果fd被共享，FileDescriptor中的引用会确保终结方法只会在安全的时候调用。
             * 所有使用fd的引用都不可达时，我们调用close
             */
            close();
        }
    }

FileOutputStream

FileOutputStream是对应的文件输出流，文件输出流将数据也到一个文件或者是一个文件描述符中，无论文件是否有效或者可能根据所在平台创建一个新的文件。在一些平台上，一个文件只允许被一个FileOutputStream或者其他文件写入对象进行操作，在这种环境下，本类的构建在文件已经被打开时可能会出错。FileOutputStream写入的是比特，可以用于写入图片数据，如果要写入字符的话可以考虑使用FileWriter。

和上面的输入流很相似，FileOutputStream除了close以外也是不加锁的，但是write是一个原子性操作，必须在前一个byte串输出完之后，下一个输出才能开始。多线程可以强制输出流进行输出，但不能中断未进行完的write。

package test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputThreadTest implements Runnable {
    private byte[] txt;

    private FileOutputStream out;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                out.write(txt);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public FileOutputThreadTest(String txt, FileOutputStream out) {
        this.txt = txt.getBytes();
        this.out = out;
    }

    public static void main(String args[]) throws InterruptedException, IOException {
        FileOutputStream out = new FileOutputStream("D:/test/file.txt");
        StringBuilder build = new StringBuilder();
        Thread[] t = new Thread[10];
        for (int i = 0; i < 10; i++) {
            build.setLength(0);
            for (int j = 0; j < 5; j++) {
                build.append(i);
            }
            t[i] = new Thread(new FileOutputThreadTest(build.toString(), out));
        }
        for (int i = 0; i < 10; i++) {
            t[i].start();
        }
        for (int i = 0; i < 10; i++) {
            t[i].join();
        }
        out.close();

        // 根据输出结果，每个字符应该连续出现5的倍数
        FileInputStream in = new FileInputStream("D:/test/file.txt");
        int pos = 0;
        while (in.available() > 0) {
            int text = in.read();
            pos++;
            for (int i = 1; i < 5; i++) {
                if (text != in.read()) {
                    System.out.println("error" + String.valueOf(pos));// 没有出现
                    return;
                }
                pos++;
            }
        }
        /*
         * 00000000000000000000000000000000000000000000000000
         * 22222222222222211111222222222222222222222222222222输入有交错
         * 22222111111111111111111111111111111111111111111111
         * 33333333333333333333333333333333333333333333333333
         * 55555555555555555555555555555555555555555555555555
         * 44444444444444444444444444444444444444444444444444
         * 66666666666666666666666666666666666666666666666666
         * 99999999999999999999999998888888888777777777777777
         * 77777777777777777777777777777777777999999999999999
         * 99999999998888888888888888888888888888888888888888
         */
    }

}

FileOutputStream有两种模式，清空文件从头开始输入和保留原本内容从文件末尾开始添加，这取决于内部属性append为true时是添加模式

    /**
     * 系统依赖的文件描述符
     */
    private final FileDescriptor fd;

    /**
     * 文件为扩展模式在末尾添加时为true
     */
    private final boolean append;

    /**
     * 相关联的文件通道，延迟初始化
     */
    private FileChannel channel;

    /**
     * 文件路径，如果该流是通过文件描述符来创建，为null
     */
    private final String path;

    private final Object closeLock = new Object();
    private volatile boolean closed = false;

构造方法传入的参数同样是三类：文件路径名、具体文件和文件描述符，append参数也在构造中指定，如果不输入默认是false

    /**
     * 通过具体的名字创建一个文件输出流来写入到文件。一个新的文件描述符被创建来代表这个文件.
     * 如果有一个安全管理器，它的checkWrite方法需要传入name参数
     * 如果文件存在但它是一个目录而不是规则的文件，或者文件不出在但不能被创建，或者文件因为其他原因不能被打开，抛出FileNotFoundException
     */
    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);
    }
    //创建一个文件输出流来向一个具体的file中写入数据。一个新的文件描述符被创建来代表这个文件连接。
    public FileOutputStream(File file) throws FileNotFoundException {
        this(file, false);//清空文件并且从头开始输入
    }
    
    public FileOutputStream(File file, boolean append)
        throws FileNotFoundException
    {
        String name = (file != null ? file.getPath() : null);//file的路径和文件名
        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();
        fd.attach(this);//便于文件描述符关闭文件
        this.append = append;
        this.path = name;

        open(name, append);
    }
    
    /**
     * 创建一个文件输入流写入到具体的文件描述符中，该文件描述符表示了对一个文件系统中实际文件存在的链接
     * 安全管理器的checkWrite参数是文件描述符fdObj
     * 如果fdObj是null会抛出NullPointerException
     * 如果fdObj不可用不会抛出异常，但是，如果此时尝试调用该流的IO方法会抛出IOException
     */
    public FileOutputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkWrite(fdObj);
        }
        this.fd = fdObj;
        this.append = false;//从头写入
        this.path = null;//使用文件描述符时没有路径

        fd.attach(this);
    }

同样，文件需要打开才能进行写入，open方法只能由构造函数调用，基于native方法open0完成

    private void open(String name, boolean append)
        throws FileNotFoundException {
        open0(name, append);//调用native方法打开文件
    }

    private native void open0(String name, boolean append)
        throws FileNotFoundException;

write操作上面提到过写入byte数组的操作是原子的，也就是native方法writeBytes是不可中断的。append变量作用在两个native方法中

    //将具体的byte写入到文件输出流中，实现了OutputStream.write方法
    public void write(int b) throws IOException {
        write(b, append);
    }

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

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

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

    private native void write(int b, boolean append) throws IOException;

close关闭这个文件输出流并释放任何关联的系统资源，这个输出流不能再用于写入bytes，如果流关联到了通道，则通道也关闭。通过加锁保证只会被关闭一次。

    public void close() throws IOException {
        synchronized (closeLock) {//close只能进行一次所以需要是线程安全的，只能由一个线程进行
            if (closed) {
                return;
            }
            closed = true;
        }

        if (channel != null) {
            channel.close();//关闭文件通道
        }

        fd.closeAll(new Closeable() {
            public void close() throws IOException {
               close0();
           }
        });
    }

    private native void close0() throws IOException;

getChannel获取的文件通道，返回通道的初始化等于到目前为止写入文件的bytes数量，除非当前的流是扩展模式，该模式下等于文件的大小。写入bytes将会增加通道的位置，无论是通过写入或者指明来改变通道的位置都会改变流的文件位置。文件通道是延迟初始化的设计，在调用时才进行初始化。

    public FileChannel getChannel() {
        synchronized (this) {//确保只初始化一次
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, false, true, append, this);
            }
            return channel;
        }
    }

finalize和FIleInputStream一样也是要通过继承类来调用的protected方法，清除所有到文件的连接，确保当没有其他对这个流的引用时，close方法被调用。通过文件描述符的状态来判断当前是否在输出。

    protected void finalize() throws IOException {
        if (fd != null) {
            if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
                flush();
            } else {
                /* 
                 * 如果fd被共享，FileDescriptor中的引用会确保终结器只在安全的时候被调用。
                 * 所有使用fd的引用都不可达时，我们调用close
                 */
                close();
            }
        }
    }
Java中IO框架——FileOutputStream源码解析
在梅边的专栏
02-26 594
FileOutputStream 继承自 OutputStream 。 OutputStream 的源码分析见：http://blog.csdn.net/yx0628/article/details/79370689 同时可以参考 FileInputStream 的源码：http://blog.csdn.net/yx0628/article/details/79344859FileOutpu
java FileInputStream open0源码解析
zhanghl的博客
11-04 2012
这里写目录标题一级目录 一级目录 本文的jdk源码为openjdk1.8。在java中对File类来表示文件，但是File类并没有inputStream和outputStream来对文件输入输出进行操作，在java中文件的输入输出功能交由FileInputStream和FileOutputStream两个类来进行。 public FileInputStream(File file) throws FileNotFoundException { String name = (file
Java IO 之 FileInputStream & FileOutputStream源码分析
weixin_30532759的博客
10-09 127
Writer ：BYSocket（泥沙砖瓦浆木匠） 微 博：BYSocket 豆 瓣：BYSocket FaceBook：BYSocket Twitter ：BYSocket 一、引子 文件，作为常见的数据源。关于操作文件的字节流就是 —FileInputStream&FileOutputStream。它们是Basic IO...
Java IO框架总揽--FileOutputStream源码解读
weixin_34062329的博客
11-03 170
FileOutputStream 是继承与OutputStream的子类 1 常用属性 private final FileDescriptor fd;// 文件描述符 private final boolean append; // 是否在文件尾部开始追加写入 private FileChannel channel; // 用于读、...
Java中FileOutputStream流的write方法
08-27
主要为大家详细介绍了Java中FileOutputStream流的write方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java io源码解读_Java IO 之 FileInputStream & FileOutputStream源码分析
weixin_32672471的博客
02-27 287
Writer ：李强强一、引子文件，作为常见的数据源。关于操作文件的字节流就是 — FileInputStream & FileOutputStream。它们是Basic IO字节流中重要的实现类。二、FileInputStream源码分析FileInputStream源码如下：/*** FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。* 比...
Java8 FileInputStream / FileDescriptor / FileOutputStream 源码解析
菜鸟进阶之路
06-26 1714
目录 一、InputStream 二、FileInputStream 1、定义 2、initIDs 3、open0 /close0 4、read0/readBytes 5、skip0 / available0 三、FileDescriptor 1、定义 2、attach /closeAll 3、initIDs /sync 四、OutputStream 五、FileOutputStream 1、定义 2、initIDs /open0 /close0 3、wr...
java源码api-java-:JAVA常用API源码解析
05-25
2. **IO流**：Java的IO库提供了读写数据的机制，如FileInputStream和FileOutputStream用于文件操作，BufferedReader和PrintWriter用于文本处理。NIO（New IO）是Java 1.4引入的改进版，支持非阻塞I/O和选择器，提高...
工作5年精心整理_Java常用工具类源码
09-19
1. **IO操作**：Java的`java.io`包包含了一系列用于处理输入/输出的类，如`FileInputStream`、`FileOutputStream`、`BufferedReader`等。这些工具类可以帮助我们读写文件、处理流数据，是处理文件操作的基础。 2. *...
超详细的逐句介绍Java高级接口之文件输入流函数FileInputStream函数源码讲解（全）
m0_43405302的博客
11-17 500
一、FileInputStream函数 FileInputStream函数主要实现将程序的内容通过这个接口将数据传入到文件中。下面我将从源码角度进行对FileInputStream的内部方法进行介绍。 二、内部源码介绍 首先FileInputStream函数继承于InputStream函数 public class FileInputStream extends InputStream { } 下面定义了文件修饰符 private final FileDescriptor fd; 下面定义了文件路径pa
FileInputStream read(byte b[])源码解析
qq_23146367的博客
10-09 414
问题描述 源文件source.txt中有10个字节(GBK编码)的数据 qwertyuiop ，当使用4字节的byte数组读取时，依次读取出qwer tyui opui,造成数据重复，如图 源码解析 查看源码发现实际调用的是readBytes(byte b[], int off, int len) 方法，此方法是native,无法看到具体实现，但是其继承的InputStream有如下方法可供参考...
FileInputStream 源码分析
czj4451的专栏
05-29 197
java.io.FileInputStream是从文件系统中获取一个文件的原始字节。如果要读取字符流，可以用java.io.FileReader。 [code="java"] public class FileInputStream extends InputStream { private FileDescriptor fd; private FileChannel ch...
超详细的逐句介绍Java高级接口之文件输入流函数FileOutputStream函数源码讲解（全）
m0_43405302的博客
11-17 596
一、FileOutputStream函数 FileOutputStream函数主要实现将程序的内容通过这个接口将数据传入到文件中。下面我将从源码角度进行对FileOutputStream的内部方法进行介绍。 二、内部源码介绍 FileOutputStream函数 public class FileOutputStream extends OutputStream { } ...
【Java IO】2、文件流与转换流
小确幸的博客
05-02 646
说明： 上一篇总结了Java I/O流的分类，其中 InputStream和 OutputStream 是所有字节流的基类、Reader 和 Writer 是所有字符流的基类。当然了，不同用途的流则对应有不同的子类，这篇从访问文件和转换的角度，整理下文件流和转换流。文件流有：字节文件输入流 FileInputStream、字节文件输出流 FileOutputStream、字符文件输入流 FileReader、字符文件输出流 FileWriter；转换流则有：InputStreamReader 和 Outp
Java IO流之字节流【一】
会者定离，一期一祈
03-07 1801
1.IO 概述 生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s ，可能文件就白白编辑了。 当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是存储在哪些设备呢？内存、硬盘、外接设备（移动硬盘，U盘）等等。 数据的传输可以看做是数据的流动，按照流动的方向，以内存为基准，分为输入流input 和输出流output ，即流向内存是输入流，流出内存的输出流。 Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。 输入也叫做读取数据，输出也叫
学习java第六周总结
qihaojinqiuma的博客
08-21 191
java学习的第六周总结，这周发生了很多事情，一时间难以言喻，很累！
java io FileInputStream源码分析
许诗宇的博客
10-29 497
目录 简介 3个构造器函数 open,read方法 其余方法 简介 package java.io; import java.nio.channels.FileChannel; import sun.nio.ch.FileChannelImpl; /** * FileInputStream从文件系统中的文件中获取输入字节。 * 可用的文件取决于主机环境。 * * <p>FileInputStream用于读取原始字节流，比如图像数据。 * 对于读取字符流，可以考虑使用
FileInputStream读取字节流。读取文件数据的两种方式(写的好)
热门推荐
Grace_1203的博客
10-16 2万+
总结： //1读取文件的数据到字节流inputStream InputStream inputStream = new FileInputStream("D:\\demo.txt");//读取文件的数据到字节流inputStream。 //2将字节流inputStream转换成字符流inputStreamReader。 InputStreamReader inputStr...
Java字节流输入流FileInputStream的简单使用
I want to fly higher
02-12 975
官网API: https://docs.oracle.com/javase/8/docs/api/java/io/FileInputStream.html public static void main(String[] args) throws IOException { getConstructor(); //getLoanShift(); //getLoanShiftThr...
Java进程通信技术源码解析与实践
Java中可以使用`java.io`包下的类如`FileReader`、`FileWriter`、`FileInputStream`、`FileOutputStream`等来实现文件的读写操作。 2. 管道（Pipes） 管道是一种经典的IPC机制，Java中的`PipedInputStream`和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值