Java InputStream类

InputStream是以字节为单位的输出流,它是所有以字节输入流类的公共父类。

定义

public abstract class InputStream  extends Object  implements Closeable

此抽象类是表示字节输入流的所有类的超类。需要定义 InputStream 子类的应用程序必须总是提供返回下一个输入字节的方法。

构造函数

InputStream()

类图

Java InputStream类图

BufferedInputStream: 提供了缓冲功能。 

DataInputStream: 允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。 

PipedInputStream: 允许以管道的方式来处理流。当连接到一个PipedOutputStream后,它会读取后者输出到管道的数据。 

PushbackInputStream: 允许放回已经读取的数据。 

SequenceInputStream: 能对多个inputstream进行顺序处理。

方法

int available()  返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。
void close() 关闭此输入流并释放与该流关联的所有系统资源。
void mark(int readlimit) 在此输入流中标记当前的位置。
boolean markSupported() 测试此输入流是否支持 mark 和 reset 方法。
abstract int read() 从输入流中读取数据的下一个字节。
int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。
void reset() 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
long skip(long n) 跳过和丢弃此输入流中数据的 n 个字节。

源码解析

public abstract class InputStream implements Closeable {  
    //最大跳过的缓冲区大小  
    private static final int MAX_SKIP_BUFFER_SIZE = 2048;  
    //从输入的流中读取下一个字节  
    public abstract int read() throws IOException;  
    //从输入流中读取一定大小的字节,没有数据返回-1  
    public int read(byte b[]) throws IOException {  
        return read(b, 0, b.length);  
    }  
    //从输人流中读取的数据放到b数组中起始位置为off,长度为len  
    public int read(byte b[], int off, int len) throws IOException {  
        if (b == null) {  
            throw new NullPointerException();  
        } else if (off < 0 || len < 0 || len > b.length - off) {  
            throw new IndexOutOfBoundsException();  
        } else if (len == 0) {  
            return 0;  
        }  
  
        int c = read();  
        if (c == -1) {  
            return -1;  
        }  
        b[off] = (byte)c;  
  
        int i = 1;  
        try {  
            for (; i < len ; i++) {  
                c = read();  
                if (c == -1) {  
                    break;  
                }  
                b[off + i] = (byte)c;  
            }  
        } catch (IOException ee) {  
        }  
            return i;  
        }  
        //跳过输入流的长度为n字节  
        public long skip(long n) throws IOException {  
  
            long remaining = n;  
            int nr;  
  
            if (n <= 0) {  
                return 0;  
            }  
  
            int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);  
            byte[] skipBuffer = new byte[size];  
            while (remaining > 0) {  
                nr = read(skipBuffer, 0, (int)Math.min(size, remaining));  
                if (nr < 0) {  
                    break;  
                }  
                remaining -= nr;  
            }  
  
        return n - remaining;  
        }  
    //返回从输入流中可以读取的数据  
    public int available() throws IOException {  
        return 0;  
    }  
    //关闭输入流,释放任何与这个流有关的资源  
    public void close() throws IOException {}  
        //标记在这个输入流的当前位置  
    public synchronized void mark(int readlimit) {}  
        //返回到最近标记的位置  
    public synchronized void reset() throws IOException {  
        throw new IOException("mark/reset not supported");  
    }  
    //测试这个输入流是否支持标记或者重置方法  
    public boolean markSupported() {  
        return false;  
    }  
}  

例子

public class InputStreamDemo01{
    public static void main(String args[]) throws Exception{    // 异常抛出,不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;    // 准备好一个输入的对象
        input = new FileInputStream(f)  ;    // 通过对象多态性,进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[1024] ;        // 所有的内容都读到此数组之中
        input.read(b) ;        // 读取内容   网络编程中 read 方法会阻塞
        // 第4步、关闭输出流
        input.close() ;                        // 关闭输出流
        System.out.println("内容为:" + new String(b)) ;    // 把byte数组变为字符串输出
    }
};

版权声明:本文为JAVASCHOOL原创文章,未经本站允许不得转载。