澳门新浦京娱乐游戏IO (二)

澳门新浦京娱乐游戏 1

一、引子

文件,作为常见的数据源。关于操作文件的字节流就是
— FileInputStream & FileOutputStream。它们是Basic
IO字节流中重要的实现类。

8.2 构造方法

  • 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件流通过文件系统中的File对象的file指定。

    public FileInputStream(File file) throws FileNotFoundException

  • 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的路径名name来指定。

    public FileInputStream(String name) throws FileNotFoundException

  • 通过文件描述符fdObj创建一个FileInputStream,该文件描述符表示到文件系统中某个实际文件的现有连接。

    public FileInputStream(FileDescriptor fdObj)

 

二、FileInputStream源码分析

FileInputStream源码如下:

/**
 * FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
 *  比如读取图片等的原始字节流。如果读取字符流,考虑使用 FiLeReader。
 */
public class SFileInputStream extends InputStream
{
    /* 文件描述符类---此处用于打开文件的句柄 */
    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对象 */
    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

    private static native void initIDs();

    private native void close0() throws IOException;

    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. 三个核心方法

三个核心方法,也就是Override(重写)了抽象类InputStream的read方法。

int read() 方法,即

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.1 BufferedReader简介

  • 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
  • 可以指定缓冲区的代销,或者使用默认的大小。大多数情况下,默认值就足够大了。

 

五、思考与小结

FileInputStream & FileOutputStream 是一对来自
InputStream和OutputStream的实现类。用于本地文件读写(二进制格式按顺序读写)。

本文小结:

1、FileInputStream 源码分析

2、FileOutputStream 资源分析

3、FileInputStream & FileOutputStream 使用案例

4、其源码调用过程

7.3 方法

  • 关闭此输出流并释放与此流有关的所有系统资源

    public void close() throws IOException

  • 刷新此输出流并强制写出所有缓冲的输出字节

    public void flush() throws IOException

  • 将b.length个字节从指定的byte数组写入此输出流

    public void write(byte[] b) throws IOException

  • 将指定byte数组中从偏移量off开始的len个字节写入此输出流

    public void write(byte[] b, int off,int len) throws IOException

  • 将指定的字节写入此输出流

    public abstract void write(int b) throws IOException

 

三、FileOutputStream 源码分析

FileOutputStream 源码如下:

/**
 * 文件输入流是用于将数据写入文件或者文件描述符类
 *  比如写入图片等的原始字节流。如果写入字符流,考虑使用 FiLeWriter。
 */
public class SFileOutputStream extends OutputStream
{
    /* 文件描述符类---此处用于打开文件的句柄 */
    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);
        }
    }

    /* 关闭此文件输出流并释放与此流有关的所有系统资源 */
    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();
     }

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

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

    private native void close0() throws IOException;

    private static native void initIDs();

    static {
        initIDs();
    }

}

1. 三个核心方法

三个核心方法,也就是Override(重写)了抽象类OutputStream的write方法。

void write(int b) 方法,即

public void write(int b) throws IOException

代码实现中很简单,一个try中调用本地native的write()方法,直接将指定的字节b写入文件输出流。IoTrace.fileReadEnd()的意思和上面FileInputStream意思一致。

void write(byte b[]) 方法,即

public void write(byte b[]) 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”。

11.2 构造方法

  • 创建一个新的缓冲输出流,以将数据写入指定的底层输出流

    public BufferedOutputStream(OutputStream out)

  • 创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流

    public BufferedOutputStream(OutputStream out,int size)

 

四、使用案例

下面先看代码:

package org.javacore.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.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. 简单地分析下源码:

1、创建了FileInputStream,读取该代码文件为文件输入流。

2、创建了FileOutputStream,作为文件输出流,输出至data.txt文件。

3、针对流的字节数组,一个 read ,一个write,完成读取和写入。

4、关闭流

  1. 代码调用的流程如图所示:

澳门新浦京娱乐游戏 1

  1. 代码虽简单,但是有点小问题:

FileInputStream.available()
是返回流中的估计剩余字节数。所以一般不会用此方法。

一般做法,比如创建一个
byte数组,大小1K。然后read至其返回值不为-1,一直读取即可。边读边写。

7 OutputSteram

3 BufferedReader

2.2.2 普通方法

  • 关闭此流,但要先刷新

    public void close() throws IOException

  • 刷新该流的缓冲

    public void flush() throws IOException

  • 澳门新浦京娱乐游戏,写入一个行分隔符

    public void newLine() throws IOException

  • 写入字符数组的一部分

    public void write(char[] cbuf,int off,int len) throws IOException

  • 写入单个字符

    public void write(int c) throws IOException

  • 写入字符串的一部分

    public void write(String s,int off,int len) throws IOException

 

2.1 BufferedWriter简介

  • 将文本写入字符输出流,缓冲各个字符,从而提高单个字符、数组和字符串的高效写入。
  • 可以指定缓冲区的大小,或者接受默认的大小。在大多数的情况下,默认值就已经足够大了。

 

3.2 常用方法

7.1 OutputStream简介

  • 此抽象类是表示输出字节流的所有类的父类,输出流接收输出字节并将这些字节发送到某个接收器。

 

4 练习:使用BufferedReader和BufferedWriter来完成复制文件 

  • 方法①:每次读取1个字符

    package java19;

import java.io.*;

/**
 * 2017/10/13
 * 说明:方法①每次读取1个字符
 */
public class BufferedWriterAndBufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br =  new BufferedReader(new FileReader("demo.txt"));

        BufferedWriter bw =  new BufferedWriter(new FileWriter("bw.txt"));

        int len = 0;
        while((len = br.read()) != -1){
            bw.write(len);
            bw.flush();
        }

        bw.close();
        br.close();



    }
}

 

  • 方法②:自定义缓冲区

    package java19;

import java.io.*;

/**
 * 2017/10/13
 * 说明:方法②自定义缓冲区
 */
public class BufferedWriterAndBufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br =  new BufferedReader(new FileReader("demo.txt"));

        BufferedWriter bw =  new BufferedWriter(new FileWriter("bw.txt"));

        char[] buffer = new char[1024];

        int len = 0;

        while((len = br.read(buffer)) != -1){
            bw.write(buffer,0,len);
            bw.flush();
        }


        bw.close();
        br.close();



    }
}

 

  • 方法③:使用readLine()方法

    package java19;

import java.io.*;

/**
 * 2017/10/13
 * 说明:方法③使用readLine()方法
 */
public class BufferedWriterAndBufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br =  new BufferedReader(new FileReader("demo.txt"));

        BufferedWriter bw =  new BufferedWriter(new FileWriter("bw.txt"));

        String line = null;
        while((line = br.readLine()) != null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }


        bw.close();
        br.close();



    }
}

 

11.1 BufferedOutputStream简介

  • 该类实现缓冲的输出流。通过设置这种输出流,应用程序就可以将各个字节写入底层输出流总,而不必针对每次字节写入调用底层系统。

 

7.2 构造方法

  • 默认构造方法

    public OutputStream()

 

1 字符流的缓冲区

  • 缓冲区的出现提高了对数据的读写效率。
  • 对应的类:
    • BufferedWriter
    • BufferedReader
  • 缓冲区要结合流才能使用。
  • 在流的基础上对流的功能进行了增强。  

 

9.2 构造方法

  • 创建一个向指定File对象表示文件中写入数据的文件输出流

    public FileOutputStream(File file) throws FileNotFoundException

  • 创建一个向指定File对象表示的文件中写入数据的文件输出流

    public FileOutputStream(File file, boolean append) throws FileNotFoundException

  • 创建一个向指定文件描述符处写入数据的输出文件流,该文件描述符表示一个到文件系统中的某个实际文件的现有连接

    public FileOutputStream(FileDescriptor fdObj)

  • 创建一个向具有指定名称的文件中写入数据的输出文件流

    public FileOutputStream(String name) throws FileNotFoundException

  • 创建一个向具有指定name的文件中写入数据的输出文件流

    public FileOutputStream(String name, boolean append) throws FileNotFoundException

 

11 BufferedOutputStream

9 FileOutputStream

9.3 方法

  • 关闭此文件输出流并释放与此流有关的所有系统资源

    public void close() throws IOException

  • 清理到文件的连接,并确保在不再引用此文件输出流时调用此流的close方法

    protected void finalize() throws IOException

  • 返回与此文件输出流有关的唯一FileChannel对象

    public FileChannel getChannel()

  • 返回与此流有关的文件描述符

    public final FileDescriptor getFD() throws IOException

  • 将b.length个字节从指定byte数组写入到此文件输出流中

    public void write(byte[] b) throws IOException

  • 将指定byte数组中从偏移量off开始的len个字节写入到此文件输出流

    public void write(byte[] b,int off, int len) throws IOException

  • 将指定字节写入到此文件输出流

    public void write(int b) throws IOException

 

3.2.2 普通方法

  • 关闭该流并释放与之关联的所有资源

    public void close() throws IOException

  • 标记流中的当前位置

    public void mark(int readAheadLimit) throws IOException

  • 判断此流是否支持mark()操作

    public boolean markSupported()

  • 读取单个字符

    public int read() throws IOException

  • 将字符读取数组的某一部分

    public int read(char[] cbuf, int off,int len) throws IOException

  • 读取一个文本行

    public String readLine() throws IOException

  • 判断此流是否已准备好被读取

    public boolean ready() throws IOException

  • 将流重置到最新的标记

    public void reset() throws IOException

  • 跳过字符

    public long skip(long n) throws IOException

 

10.3 方法

  • 返回从此输入流读取或跳过、且不受此输入流接下来的方法调用阻塞的估计字节数

    public int available() throws IOException

  • 关闭此输入流并释放与该流关联的所有O系统资源

    public void close() throws IOException

  • 参见InputStream的mark方法的常规协定

    public void mark(int readlimit)

  • 测试此输入是否支持mark和reset方法

    public boolean markSupported()

  • 参见InputStream的read方法的常规协定

    public int read() throws IOException

  • 从此输入流中戈丁偏移量出开始将各字节读取到指定的byte数组中

    public int read(byte[] b, int off,int len) throws IOException

  • 参见InputStream的reset方法的常规协定

    public void reset() throws IOException

  • 参见InputStream的skip方法的常规协定

    public long skip(long n) throws IOException

 

2.2.3 示例

  • 示例:

    package java19;

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

    /**

    • 2017/10/12
    • 说明:
      */
      public class BufferedWriterDemo {
      public static void main(String[] args) throws IOException {

       BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
      
       bw.write("abcd");
      
       bw.flush();
      
       bw.close();
      

      }
      }

 

9.1 FileOutputStream简介

  • 文件输出流是用于将数据写入File或FileDescriptor的输出流。文件是否可用或能否可用被创建取决于基础平台。特别是某些平台一次只允许一个FileOutputStream打开文件进行写入。在这种情况下,如果所涉及的文件已经打开,则此类中的构造方法将失败。
  • FilOutputStream用于写入诸如图像数据之类的原始字节的六。要写入字符流,请考虑使用FileWriter。

 

6.2 InputStream的构造方法

  • 默认的构造方法

    public InputStream()

 

5 字节流

  • 基本操作与字符流相同。
  • 字节流不仅可以操作字符,还可以操作其它媒体文件。

 

2.2.1 构造方法

  • 创建一个使用默认大小输出缓冲区的缓冲字符输出流

    public BufferedWriter(Writer out)

  • 创建一个使用给定大小输出缓冲区的新缓冲字符输出流

    public BufferedWriter(Writer out,int sz)

 

10.2 构造方法

  • 创建一个BufferedInputStream并保存其参数,即输入流in,以便将来使用

    public BufferedInputStream(InputStream in)

  • 创建一个具有指定缓冲区大小的BufferedInputStream并保存其参数,即输入流in,以便将来使用

    public BufferedInputStream(InputStream in,int size)

 

6 InputStream

8.3 方法

  • 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的估计剩余字节数

    public int available() throws IOException

  • 关闭此文件输入流并释放与此流有关的所有系统资源

    public void close() throws IOException

  • 确保在不再引用文件输入流的时候调用其close方法

    protected void finalize() throws IOException

  • 返回与此文件输入流有关的唯一FileChannel对象

    public FileChannel getChannel()

  • 返回表示到文件系统中实际文件的连接的FileDescriptor对象,该文件系统正被FileInputStream使用

    public final FileDescriptor getFD() throws IOException

  • 从输入流中读取一个数据字节

    public int read() throws IOException

  • 从输入流中将最多b.length个字节的数据读入一个byte数组中

    public int read(byte[] b) throws IOException

  • 从输入流中将最多len个字节的数据读入一个byte数组中

    public int read(byte[] b, int off,int len)

  • 从输入流中跳过并丢弃n个资借鉴的数据

    public long skip(long n) throws IOException

 

8.1 FileInputStream简介

  • FileInputStream从文件系统中的某个文件获取输入字节。哪些文件可用取决于主机环境。
  • FileInputStream用于读取诸如图像数据之类的原始字节流。要读取字符流,请考虑使用FileReader。

 

8 FileInputStream

2 BufferedWriter

3.2.3 示例

  • 示例:

    package java19;

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;

    /**

    • 2017/10/13
    • 说明:
      */
      public class BufferedReaderDemo {
      public static void main(String[] args) throws IOException {

       BufferedReader fr = new BufferedReader(new FileReader("demo.txt"));
      
       char[] buffer = new char[1024];
      
       int len = 0;
      
       while((len = fr.read(buffer)) != -1){
           System.out.println(new String(buffer,0,len));
       }
      
       fr.close();
      

      }
      }

 

  • 示例:

    package java19;

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;

    /**

    • 2017/10/13
    • 说明:
      */
      public class BufferedReaderDemo {
      public static void main(String[] args) throws IOException {

       BufferedReader fr = new BufferedReader(new FileReader("demo.txt"));
      
       String str = null ;
      
       while((str = fr.readLine()) != null){
           System.out.println(str);
       }
      
        fr.close();

    }
}

 

3.2.1 构造方法

  • 创建一个使用默认大小的输入缓冲区的缓冲字符输入流

    public BufferedReader(Reader in)

  • 创建一个使用指定大小输入缓冲区的缓冲字符输入流

    public BufferedReader(Reader in, int sz)

 

6.3 方法

  • 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取的字节数

    public int available() throws IOException

  • 关闭此输入流并释放与该流关联的所有系统资源

    public void close() throws IOException

  • 在此输入流中标记当前位置

    public void mark(int readlimit)

  • 判断此流是否支持mark和reset方法

    public boolean markSupported()

  • 从输入流中读取数据的下一个字节

    public abstract int read() throws IOException

  • 从输入流中读取一定数量的字节,并将其存储在缓冲数组中

    public int read(byte[] b) throws IOException

  • 将输入流中最多len个数据字节读取byte数组

    public int read(byte[] b, int off,int len) throws IOException

  • 将此流重新定位到最后一次对此输入流调用mark方法时的位置

    public void reset() throws IOException

  • 跳过和丢弃此输入流中数据的n个字节

    public long skip(long n) throws IOException

 

2.2 常用方法

10.1 BufferedInputStream简介

  • BufferedInputStream为另一个输入流添加一些功能,即缓冲输入以及支持mark和reset方法的能力。在创建BufferedInputStream时,会创建一个内部缓冲区数组。在读取或跳过流中的字节时候,可根据需要从包含的输入流再次填充到该内部缓冲区,一次填充多个字节。mark操作记录输入流中的某个点,reset操作使得从包含的输入流中获取新字节之前,再次读取最后一次mark操作后读取的所有字节。

 

10 BufferedInputStream

11.3 方法

  • 刷新此缓冲的输出流

    public void flush() throws IOException

  • 将指定byte数组中从偏移量off开始的len个字节写入到此缓冲的输出流

    public void write(byte[] b, int off, int len) throws IOException

  • 将指定的字节写入到此缓冲的输出流

    public void write(int b) throws IOException

 

6.1 InputStream的简介

  • 此抽象类是表示字节输入流的所有类的父类。

 

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图