Java IO流操作汇总： inputStream 和 outputStream

来源：互联网发布：大数据解决方案公司编辑：程序博客网时间：2024/05/28 11:50

Java IO通过Stream（流）来实现。关于流，可以理解为是一种“数据的管道”。管道中流动的东西可以是基于字节，也可以是基于字符的等。

1、在java中stream代表一种数据流（源），javaio的底层数据元，－－－（想像成两头都有水龙头的输水管）
2、任何有能力产生数据流（源）的javaio对象就可以看作是一个InputStream对象
既然它能产生出数据，我们就可以将数据取出，java对封装的通用方法就read()方法了－－（出水龙头）
3、任何有能力接收数据源(流)的javaio对象我们就可以看作是一个OutputStream对象
同样，它能接收数据，我们就可以调用它的write方法，来让它接收数据－－（进水龙头了）
-------------------------------------------------------------------------------------------------------------------------
OutputStream
(1)输出数据
   void write(int b)往流中写一个字节b
   void write(byte b[])往流中写一个字节数组b
   void write(byte b[],int off,int len)把字节数组b中从下标off开始，长度为len的字节写入流中
(2) flush()刷空输出流，并输出所有被缓存的字节
由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中。
(3)关闭流
   close()流操作完毕后必须关闭。
------------------------------------------------------------------------------------------------------------------------
InputStream
(1)从流中读取数据
   int read() 读取一个字节，返回值为所读得字节
   int read(byte b[]) 读取多个字节，放置到字节数组b中，通常读取的字节数量为b的长度，返回值为实际独取的字节的数量。
   int read(byte b[] ,int off,int len)读取len个字节，放置到以下标off开始字节数组b中，返回值为实际读取的字节的数量。
   int available() 返回值为流中尚未读取的字节的数量。
   long skip(long n);读指针跳过n个字节不读，返回值为实际跳过的字节数量
(2)关闭流
   close() 流操作完毕后必须关闭
(3)使用输入流中的标记
   void mark(int readlimit)纪录当前指针的所在位置.readlimit表示读指针读出的readlimit个字节后所标记的指针位置才实效。
   void reset() 把读指针重新指向用mark方法所记录的位置
   boolean markSupported() 当前的流是否支持读指针的记录功能。

--------------------------------------------------------------------------------------

4、IO流操作一般分为两类：字符流和字节流。以“Reader”结尾都是字符流，操作的都是字符型的数据；以“Stream”结尾的都是字节流，操作的都是byte数据。

一、字节流

1. InputStream 和 OutputStream
InputStream 和 OutputStream为各种输入输出字节流的基类，所有字节流都继承这两个基类。

2. FileInputStream 和 FileOutputStream
这两个从字面意思很容易理解，是对文件的字节流操作，也会最常见的IO操作流。

3.DataInputStream和DataOutputStream
DataInputStream 是数据输入流，它继承于FilterInputStream。
DataOutputStream 是数据输出流，它继承于FilterOutputStream。
二者配合使用，“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。

4.BufferedInputStream 和 BufferedOutputStream
BufferedInputStream是带缓冲区的输入流，它继承于FilterInputStream。默认缓冲区大小是8M，能够减少访问磁盘的次数，提高文件读取性能。
BufferedOutputStream是带缓冲区的输出流，它继承于FilterOutputStream，能够提高文件的写入效率。
它们提供的“缓冲功能”本质上是通过一个内部缓冲区数组实现的。例如，在新建某输入流对应的BufferedInputStream后，当我们通过read()读取输入流的数据时，BufferedInputStream会将该输入流的数据分批的填入到缓冲区中。
每当缓冲区中的数据被读完之后，输入流会再次填充数据缓冲区；如此反复，直到我们读完输入流数据。

5. ByteArrayInputStream 和 ByteArrayOutputStream
该类从内存中的字节数组中读取数据，它的数据源是一个字节数组，它们分别继承自InputStream 和 OutputStream。
ByteArrayInputStream类的构造方法包括：
ByteArrayInputStream(byte[] buf)--------参数buf指定字节数组类型的数据源。
ByteArrayInputStream(byte[] buf, int offset, int length)-----参数buf指定字节数组类型数据源，参数offset指定从数组中开始读取数据的起始下标位置，length指定从数组中读取的字节数。

二、字符流

1. InputStreamReader 和 OutputStreamWriter
InputStreamReader 和 OutputStreamWriter为各种输入输出字符流的基类，所有字符流都继承这两个基类。
实际上，这两个类内部各自持有一个inputStream 和 outputStream对象，相当于是对inputStream 和 outputStream进行了包装，将输入字节流转换成字符流，便于读写操作。

2. FileReader 和 FileWriter
FileReader 和 FileWriter分别继承自 inputStreamReader 和 outputStreamWriter。它是对读取文件操作系统的封装，所有的读写都是直接操作文件系统。因此如果是频繁读写操作，不建议使用FileReader 和 FileWriter，性能将会非常低，这时你需要使用BufferedReader。
（1）FileWriter类
构造方法：
FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话，并创建。
FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。
主要方法：
write(char[] buffer, int offset, int count) //将字符数组写入，offset为数组的起始地址，count为需要写入的字符数
void write(String str) //写入字符串。当执行完此方法后，字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。
viod flush() //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。
viod close() //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后，再写入或者刷新的话，会抛IOException异常。
（2）FileReader类
构造方法：
FileReader fr = new FileReader(String fileName); //使用带有指定文件的String参数的构造方法。创建该输入流对象。并关联源文件。
主要方法：
int read(); // 读取单个字符。返回作为整数读取的字符，如果已达到流末尾，则返回 -1。
int read(char []cbuf); //将字符读入数组。返回读取的字符数。如果已经到达尾部，则返回-1。
void close(); //关闭此流对象。释放与之关联的所有资源。

3. BufferedReader 和 BufferedWriter
（1）BufferedReader和BufferedWriter类各拥有8192字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并置入缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。
（2）从标准输入流System.in中直接读取使用者输入时，使用者每输入一个字符，System.in就读取一个字符。为了能一次读取一行使用者的输入，使用了BufferedReader来对使用者输入的字符进行缓冲。readLine()方法会在读取到使用者的换行字符时，再一次将整行字符串传入

示例查看http://blog.csdn.net/wangbaochu/article/details/53484042

[java] view plain copy
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
  
/** 拷贝文件 
 *  1、建立联系 File 对象   源头  目的地 
 *  2、选择流    既然是文件的拷贝  那肯定包含了 读取跟写入  所以 
 *      1)文件输入流   InputStream FileInputStream  
 *      2)文件输出流  OutputStream FileOutputStream  
 *  3、操作：拷贝  -->一边读取 一边写入  就可以完成拷贝了  
 *      byte flush[] = new byte[1024]; 
 *      int len = 0; 
 *      while(-1=(len=输入流.read(flush))){ 
 *          输出流.write(flush,0,len); 
 *      } 
 *      输出流.flush; 
 *  4、释放资源：关闭两个流 
 */  
public class Demo01 {  
    public static void main(String[] args){  
        String str = new String("e:/work/a.txt");  
        String str1 = new String("e:/work/asdfg.txt");  
        try {  
            copyFile(str, str1);  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
            System.out.println("文件未找到！");  
        } catch (IOException e) {  
            e.printStackTrace();  
            System.out.println("文件拷贝失败！没事找找bug再来！！！");  
        }  
          
    }  
    public static void copyFile(String srcPath,String datePath) throws FileNotFoundException,IOException{  
        //源文件  必须是文件不能是文件夹  输入流是读取不了文件夹的    
        File src = new File(srcPath);  
        //目的地  文件可以不存在    
        File date = new File(datePath);  
        //打开流  
        InputStream it = new FileInputStream(src);  
        OutputStream os = new FileOutputStream(date);  
        //文件拷贝      
        byte flush[]  = new byte[1024];  
        int len = 0;  
        while(0<=(len=it.read(flush))){  
            os.write(flush, 0, len);  
        }  
        //关闭流的注意 先打开的后关  
        os.close();  
        it.close();  
    }  
}  

阅读全文

0 0