概述

InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。 继承自InputStream 流是向程序中输入数据的，且 数据单位 为字节（8bit）；

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：

　　（1） public abstract int read( )：读取一个 byte 的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。

　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的

　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。

　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前 线程 将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用。

　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取。

　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流关闭。

主要的子类：

1） FileInputStream 把一个文件作为InputStream，实现对文件的读取操作

2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用

3） StringBufferInputStream：把一个String对象作为InputStream

4） PipedInputStream：实现了pipe的概念，主要在线程中使用

5） SequenceInputStream：把多个InputStream合并为一个InputStream

6) FilterInputStream ：用来“封装其它的输入流，并为它们提供额外的功能”。它的常用的子类有BufferedInputStream和DataInputStream。

BufferedInputStream的作用就是为“输入流提供缓冲功能，以及mark()和reset()功能”。

DataInputStream 是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。应用程序可以使用DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据。

InputStream框架图

FileInputStream 子类

FileInputStream是Java语言中抽象类InputStream用来具体实现类的创建对象。 File InputStream可以从文件系统中的某个文件中获得输入字节，获取的文件可用性取决于主机环境，提供的主要方法：

int available()

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

void close()

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

protected void finalize()

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

FileChannel getChannel()

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

FileDescriptor getFD()

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

int read()

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

int read(byte[] b)

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

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

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

long skip(long n)

从输入流中跳过并丢弃 n 个字节的数据。

利用FileInputStream进行文件复制

public class FileInputStream copy {

public static void main(String[] args) throws IOException {

//1. 创建字节输入流对象，用来读取

FileInputStream fis = new FileInputStream(“E:\test.txt”);

//2创建字节输出流对象，用来写入//没有会创建

FileOutputStream fs = new FileOutputStream(E:\copy.txt);

//3创建一个数组用来读取

byte arr[] = new byte[1024 * 8];

int len;//用来计数

while ((len = fis.read(arr)) != -1) {

//从文件中用字节数组读取数组，存储到字节数组中

// 每读取到一个内容，就把读取到的内容写入到目的地文件

fs.write(arr,0, len );

}

//释放资源

fs.close();

fis.close();

}

}

ByteArrayInputStream 子类

ByteArrayInputStream 是字节数组输入流。它继承于InputStream。

它包含一个内部缓冲区，该缓冲区包含从流中读取的字节；通俗点说，它的内部缓冲区就是一个字节数组，而ByteArrayInputStream本质就是通过字节数组来实现的。

public void reset() 将此字节数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。

public byte[] toByteArray() 创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。

public String toString() 将缓冲区的内容转换为 字符串 ，根据平台的默认 字符编码 将字节转换成字符。

public void write(int w) 将指定的字节写入此字节数组输出流。

public void write(byte []b, int off, int len) 将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。

public void writeTo(OutputStream outSt) 将此字节数组输出流的全部内容写入到指定的输出流参数中。

使用例子代码：

public class ByteArrayInputStreamTest{

public static void main(String[] args) throws Exception {

ByteArrayOutputStream out = new ByteArrayOutputStream();

//字节值被放入内部数组

out.write(“abc中文”.get Bytes ());

out.close();

byte[] a = out.toByteArray();

System.out.println(Arrays.toString(a));

InputStreamReader in = new InputStreamReader(

new ByteArrayInputStream(a));

int c;

while ((c = in.read()) != -1) {

System.out.println((char) c);

}

in.close();

}

}

PipedInputStream 子类

PipedInputStream类管道输入流，它是可以连接管道输出流，管道输入流提供了要写入管道输出流的所有数据的字节。

PipedInputStream类方法有：

int read():读取数据的下一个字节。

int read(byte []b,int off,int len):读取len个字节数据到一个字节数组，off参数表示偏移量，len表示读取数据的长度。

void receive(int b):接受一个字节的数据。

void connect(PipedOutputStream src):表示管道输入流连接到管道输出流src

int available():表示没有什么阻碍从输入流中读取字节数。

void close():表示关闭流。

例子代码:

 public class PipedInputStreamTest  { 
public static void main(String[] args) throws Exception { 
//创建PipedInputStream对象 
final PipedInputStream in=new PipedInputStream(); 
final PipedOutputStream out=new PipedOutputStream(); 
//两个类进行连接 
in.connect(out); 
new Thread(new Runnable(){ 
        public void run(){ 
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 
            //通过键盘读取数据写入管道流 
            PrintStream ps=new PrintStream(out); 
            System.out.print(Thread.currentThread().getName()+"请输入内容:"); 
            try { 
                ps.println(br.readLine()); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
},"发送数据的线程").start(); 
new Thread(new Runnable(){ 
        public void run(){ 
            BufferedReader br=new BufferedReader(new InputStreamReader(in)); 
            try { 
                System.out.println(Thread.currentThread().getName()+"收到的内容："+br.readLine()); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
},"接受数据的线程").start(); 
  } 
}   

FilterInputStream 子类

FilterInputStream 的作用是用来“封装其它的输入流，并为它们提供额外的功能”。它的常用的子类有BufferedInputStream和DataInputStream。
BufferedInputStream的作用就是为“输入流提供缓冲功能，以及mark()和reset()功能”。
DataInputStream 是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。应用程序可以使用DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据。

提供的常法方法：

int available（）

此方法返回可以从此输入流中读取（或跳过）的字节数的估计值，而不会被此输入流的方法的下一个调用方阻塞。

void close（）

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

void mark（int readlimit）

此方法标记此输入流中的当前位置。

boolean markSupported（）

此方法测试此输入流是否支持标记和重置方法。

int read（）

此方法从此输入流中读取下一个数据字节。

int read（byte [] b）

此方法将此输入流中的byte.length字节数据读入字节数组。

int read（byte [] b，int off，int len）

此方法将此输入流中最多len个字节的数据读入一个字节数组。

void reset（）

此方法将此流重新定位到上次在此输入流上调用mark方法时的位置。

long skip(long n)

此方法跳过并从此输入流中丢弃n个字节的数据。

例子代码：

public class FilterInputStreamDemo {

public static void main(String[] args) throws Exception {

InputStream is = null;

FilterInputStream fis = null;

boolean bool = false;

try{

is = new FileInputStream(“E:\test.txt”);

fis = new BufferedInputStream(is);

bool = fis.markSupported();

System.out.print(“返回值: “+bool);

} catch(IOException e){

e.printStackTrace();

} finally {

if (is!=null)

is.close();

if(fis!=null)

fis.close();

}

}

}

SequenceInputStream子类

SequenceInputStream 可以将两个或多个其他 InputStream 合并为一个。 首先，SequenceInputStream 将读取第一个 InputStream 中的所有字节，然后读取第二个 InputStream 中的所有字节。 这就是它被称为 SequenceInputStream 的原因，因为 InputStream 实例是按顺序读取的。

构造方法

SequenceInputStream(InputStream s1, InputStream s2): 通过两个参数初始化新创建的 SequenceInputStream(将按顺序读取这两个参数，先读取 s1，然后读取 s2)

SequenceInputStream(Enumeration extends InputStream> e): 通过枚举对象来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。

例子代码:

public class SequenceInputStreamTest {

public static void main(String[] args) throws IOException {

InputStream s1 = new FileInputStream(“E:\text1.txt”);

InputStream s2 = new FileInputStream(“E:\text1.txt”);

SequenceInputStream sis = new SequenceInputStream(s1, s2);

InputStreamReader isr = new InputStreamReader(sis);

BufferedReader br = new BufferedReader(isr);

BufferedWriter bw = new BufferedWriter(new FileWriter(“E:\text3.txt”));

String line = null;

while((line = br.readLine()) != null) {

bw.write(line);

bw.newLine();

bw.flush();

}

s1.close();

s2.close();

br.close();

bw.close();

}

}