JAVA中常用IO流类：FileInputStream和FileOutputStream

FileInputStream 用于读取本地文件中的字节数据，继承自InputStream类

构造方法摘要FileInputStream(File file) 
          通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的 File 对象 file 指定。FileInputStream(FileDescriptor fdObj) 
          通过使用文件描述符 fdObj 创建一个FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。FileInputStream(String name) 
          通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径名 name 指定。

方法摘要 intavailable() 
          返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。 voidclose() 
          关闭此文件输入流并释放与此流有关的所有系统资源。protected  voidfinalize() 
          确保在不再引用文件输入流时调用其close 方法。 FileChannelgetChannel() 
          返回与此文件输入流有关的唯一FileChannel 对象。 FileDescriptorgetFD() 
          返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此FileInputStream 使用。 intread() 
          从此输入流中读取一个数据字节。 intread(byte[] b) 
          从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 intread(byte[] b, int off, int len) 
          从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。 longskip(long n) 
          从输入流中跳过并丢弃 n 个字节的数据。

其中read()返回的是读入的一个字节所对应的int值(0-255),而read(byte[] b) 和read(byte[] b, int off, int len) 返回的是读入的字节数

 

 

FileOutputStream用于将字节数据写出到文件。继承自OutputStream类

构造方法摘要FileOutputStream(File file) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。FileOutputStream(File file, boolean append) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。FileOutputStream(FileDescriptor fdObj) 
          创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。FileOutputStream(String name) 
          创建一个向具有指定名称的文件中写入数据的输出文件流。FileOutputStream(String name, boolean append) 
          创建一个向具有指定 name 的文件中写入数据的输出文件流。

  

方法摘要 voidclose() 
          关闭此文件输出流并释放与此流有关的所有系统资源。protected  voidfinalize() 
          清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。 FileChannelgetChannel() 
          返回与此文件输出流有关的唯一FileChannel 对象。 FileDescriptorgetFD() 
          返回与此流有关的文件描述符。 voidwrite(byte[] b) 
          将 b.length 个字节从指定 byte 数组写入此文件输出流中。 voidwrite(byte[] b, int off, int len) 
          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 voidwrite(int b) 
          将指定字节写入此文件输出流。
实例代码：使用这两个类进行文件复制：

 

[java] view plain copy

1. import java.io.FileInputStream;  
2. import java.io.FileOutputStream;  
3. import java.io.IOException;  
4. class IODemo  
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         try  
9.         {  
10.         //使用FileInputStream和FileOutputStream进行文件复制  
11.         FileInputStream fis=new FileInputStream("a.txt");  
12.         FileOutputStream fos=new FileOutputStream("b.txt");  
13.             int read;  
14.             //read=fis.read();  
15.             byte b[]=new byte[1024];  
16.             //读取文件，存入字节数组b，返回读取到的字符数，存入read,默认每次将b数组装满  
17.             read=fis.read(b);  
18.             while(read!=-1)  
19.             {  
20.                 fos.write(b,0,read);  
21.                 read=fis.read(b);  
22.                 //read=fis.read();  
23.             }  
24.             fis.close();  
25.             fos.close();  
26.         }  
27.         catch (IOException e)  
28.         {  
29.             e.printStackTrace();  
30.         }  
31.           
32.     }  
33. }  

 

上述的例子采用也可以只使用对象fis的read()方法，逐个字节的读入数据，然后用对象fos的write()这个字节输出。

 

注：FileInputStream 和FileOutputStream适用于操作于任何形式的文件（因为是以字节为向导），如果想要操作文本文件，采用FileInputReader和FileOutputWriter效率更高。

深入解析FileInputStream和FileOutputStream

栏目:IO与序列化 作者:admin 日期:2015-08-05 评论:5点击: 5,213 次

FileInputStream和FileOutputStream类属于字节类，可以操作任意类型的文件。在数据流的处理过程中，有两种情况。
（1）以单个字节的形式读写文件
（2）以数据块的形式读写文件
从JDK的源码中，我们可以看出来：
FileInputStream的读：

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

FileOutputStream的写：

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

例子一：单个字节的读写

public class Test{    public static void main(String[] args)    {        File src = new File("d:\\src.txt");        File dst = new File("d:\\dst.txt");        doSaveFile(src, dst);    }    public static void doSaveFile(File src, File dst)    {        InputStream in = null;        OutputStream out = null;        try        {            in = new FileInputStream(src);            out = new FileOutputStream(dst);            int len = 0;            while ((len = in.read()) > 0)            {//len表示读取的字节                out.write(len);            }        }        catch (Exception e)        {        }        finally        {            if (null != in)            {                try                {                    in.close();                }                catch (IOException e)                {                }            }            if (null != out)            {                try                {                    out.close();                }                catch (IOException e)                {                }            }        }    }}

例子二：数据块的读写

public class Test{    private final static int BUFFER_SIZE = 16 * 1024;    public static void main(String[] args)    {        File src = new File("d:\\src.txt");        File dst = new File("d:\\dst.txt");        doSaveFile(src, dst);    }    public static void doSaveFile(File src, File dst)    {        InputStream in = null;        OutputStream out = null;        try        {            in = new FileInputStream(src);            out = new FileOutputStream(dst);            byte[] buffer = new byte[BUFFER_SIZE];            int len = 0;            while ((len = in.read(buffer)) > 0)            {//len表示读取的字节数                out.write(buffer, 0, len);            }        }        catch (Exception e)        {        }        finally        {            if (null != in)            {                try                {                    in.close();                }                catch (IOException e)                {                }            }            if (null != out)            {                try                {                    out.close();                }                catch (IOException e)                {                }            }        }    }}

上面列出了两个例子，到底哪个例子的效率更高一些呢？
也许这个问题很难回答，因为效率的比对很难实现。而且数据流的底层实现，我们也很难搞清楚。其实，撇开这个问题，我们还有更高效的读取方式，那就是下一篇文章要讲的BufferedInputStream和BufferedOutputStream。
需要注意的是：
创建FileInputStream实例对象时，指定的文件应当是存在和可读的。创建FileOutputStream实例对象时，如果指定的文件已经存在，这个文件中的原来内容将被覆盖清除。