【JAVA的 IO流之FileInputStream和FileOutputStream】

java的 IO流即输入输出流，流是一组有顺序的，有起点和终点的字节结合，是对数据传输的总称。即数据在两设备间的传输称为流，流的本质是数据传输。

    IO流可以分为字节流和字符流。给出相应的IO结构图：

在接下来的一段时间里，将会慢慢介绍各种流的使用，本篇博客先介绍字节流的FileOutputStream和相对应的FileInputStream。

一.FileOutputStream(文件输出流）

     OutputStream是一个抽象类，抽象类必须通过子类实现。现在要向文件里输出就要用FileOutputStream。

FileOutputStream有四个构造方法，分别为

1.FileOutputStream(File file)-------------向File对象的文件写入数据

2.FileOutputStream(File file,boolean append);------向File对象的文件追加写入数据

3.FileOutputStream(String path)-------------向指定文件写入数据

4.FileOutputStream(String path,boolean append);--------向指定文件追加写入数据

       当append的值为true时，向文件中写入的数据会追加到原数据的后面，否则会重写该文件的数据。默认为false。

写入方法1：一个个字节写入

1. public static void main(String[] args) {  
2.       
3.     try {  
4.         //创建一个文件字节输出流对象  
5.         OutputStream os=new FileOutputStream("L:\\io.txt");  
6.           
7.         //写入的数据  
8.         String string="hello IO  Stream";  
9.         byte[]bytes=string.getBytes();//转化为字节数组  
10.         for(int i=0;i<bytes.length;i++){  
11.             //向文件输出  
12.             os.write(bytes[i]);  
13.         }  
14.         os.close();//关闭流  
15.     } catch (FileNotFoundException e) {  
16.         e.printStackTrace();  
17.     } catch (IOException e) {  
18.         e.printStackTrace();  
19.     }  
20.   
21. }  

复制代码

方法二：全部一次写入

1. public static void main(String[] args) {  
2.           
3.         try {  
4.             //创建一个文件字节输出流对象  
5.             OutputStream os=new FileOutputStream("L:\\io.txt",true);//追加  
6.               
7.             //写入的数据  
8.             String string="hello IO  Stream";  
9.             byte[]bytes=string.getBytes();//转化为字节数组       
10.             os.write(bytes);//全部写入  
11.             //os.write(bytes,0,5)表示从0开始，写入长度为5个字节  
12.             os.close();//关闭流  
13.         } catch (FileNotFoundException e) {  
14.             e.printStackTrace();  
15.         } catch (IOException e) {  
16.             e.printStackTrace();  
17.         }  
18.    
19.     }  

复制代码

一.FileInputStream(文件输入流）

   FileInputStream是从系统的某个文件中获得输入字节，有两个构造方法

1.FileInputStream(File file)

2.FileInputStream(String path)

读取字节方法1：一个个字节读取

1. public static void main(String[] args) {  
2.           
3.         try {  
4.             //创建一个字节输入流对象  
5.             InputStream is=new FileInputStream("L:\\io.txt");  
6.               
7.             int b=-1;  
8.             while((b=is.read())!=-1)//字节读取，当为-1时读取完毕  
9.             {  
10.                 System.out.print((char)b);//转化为字符输出  
11.             }  
12.               
13.             is.close();//关闭流  
14.         } catch (FileNotFoundException e) {  
15.             e.printStackTrace();  
16.         } catch (IOException e) {  
17.             e.printStackTrace();  
18.         }  
19.    
20.     }  

复制代码

输出结果为：hello IO Stream。这样一个一个字节读取，速度很慢。

读取字节方法2：一次性读取全部字节

1. public static void main(String[] args) {  
2.           
3.         try {  
4.               
5.             File file=new File("L:\\io.txt");  
6.             //创建一个字节输入流对象  
7.             InputStream is=new FileInputStream(file);  
8.             //根据文件大小来创建字节数组  
9.             byte[]bytes=new byte[(int)file.length()] ;  
10.             int len=is.read(bytes);//返回读取字节的长度  
11.             System.out.println("读取字节长度为："+len);  
12.               
13.             System.out.println("读取的内容为： "+new String(bytes));//构建成字符串输出  
14.               
15.             is.close();//关闭流  
16.         } catch (FileNotFoundException e) {  
17.             e.printStackTrace();  
18.         } catch (IOException e) {  
19.             e.printStackTrace();  
20.         }  
21.    
22.     }  

复制代码

运行结果： <ignore_js_op> 

这种读取方法主要缺点是要构建一个和文件大小一样大的字节数组，文件小的时候还可以，当文件很大，内存可能无法构架出如此大的字节数组。所以，这种方法只适合小文件。

读取字节方法3：每次读取指定长度（最常用的方法）

1. public static void main(String[] args) {  
2.           
3.         try {  
4.   
5.             //创建一个字节输入流对象  
6.             InputStream is=new FileInputStream("L:\\io.txt");  
7.             //指定每次读取的大小--可根据性能字节修改  
8.             byte[]bytes=new byte[8] ;  
9.               
10.             StringBuffer sb=new StringBuffer();  
11.             int len=-1;//每次读取的实际长度  
12.             while((len=is.read(bytes))!=-1)  
13.             {  
14.                 sb.append(new String(bytes,0,len));  
15.             }  
16.             System.out.println("读取字节为："+sb);  
17.               
18.             is.close();//关闭流  
19.         } catch (FileNotFoundException e) {  
20.             e.printStackTrace();  
21.         } catch (IOException e) {  
22.             e.printStackTrace();  
23.         }  
24.    
25.     }  

复制代码

输出结果：
<ignore_js_op>