java 文件输出流

一、对文件操作的流——基本知识

1.read（）方法读取流中的数据是按照字节一个个读取，而且每次只读取一个字节。实践如下：

代码如下：

[java] view plain copy
 
  1. import java.io.FileInputStream;  
  2.   
  3. /** 
  4.  * 文件的输入输出流 
  5.  * @author Administrator 
  6.  * 
  7.  */  
  8. public class FileOperationTest {  
  9.       
  10.     public static void main(String[] args) throws Exception {  
  11.         readFile("G:\文件测试\1.txt");  
  12.     }  
  13.     /** 
  14.      * 读取指定的文件 
  15.      * @param fileName 
  16.      */  
  17.     public static void readFile(String fileName) throws Exception{  
  18.         //根据fileName构建文件输入流对象  
  19.         FileInputStream fis = new FileInputStream(fileName);  
  20.         //从此输入流中读取数据一个个读  
  21.         int i= fis.read();  
  22.         System.out .print((char)i);  
  23.     }     
  24.           
  25.     }  

*read()方法如何实现字符串的输出

代码如下：

[java] view plain copy
 
  1. import java.io.FileInputStream;  
  2.   
  3. /** 
  4.  * 文件的输入输出流 
  5.  * @author Administrator 
  6.  * 
  7.  */  
  8. public class FileOperationTest {  
  9.       
  10.     public static void main(String[] args) throws Exception {  
  11.         readFile("G:\文件测试\1.txt");  
  12.     }  
  13.     /** 
  14.      * 读取指定的文件 
  15.      * @param fileName 
  16.      */  
  17.     public static void readFile(String fileName) throws Exception{  
  18.         //根据fileName构建文件输入流对象  
  19.         FileInputStream fis = new FileInputStream(fileName);  
  20.         //从此输入流中读取数据一个个读  
  21.         int i= fis.read();  
  22.         //用read()实现文件的完整输出  
  23.         while(i!=-1){  
  24.             System.out.print((char)i);  
  25.             i = fis.read();  
  26.         }  
  27.     }     
  28.           
  29. }  

*read()读取到文件末尾，返回-1。

2.read（byte[] b）按字节读取流中的数据，将读取到的数据存到byte[]数组中

代码如下：

[java] view plain copy
 
  1. import java.io.FileInputStream;  
  2.   
  3. /** 
  4.  * 文件的输入输出流 
  5.  * @author Administrator 
  6.  * 
  7.  */  
  8. public class FileOperationTest {  
  9.       
  10.     public static void main(String[] args) throws Exception {  
  11.         readFile("G:\文件测试\1.txt");  
  12.     }  
  13.     /** 
  14.      * 读取指定的文件 
  15.      * @param fileName 
  16.      */  
  17.     public static void readFile(String fileName) throws Exception{  
  18.         //根据fileName构建文件输入流对象  
  19.         FileInputStream fis = new FileInputStream(fileName);  
  20.     /*  //从此输入流中读取数据一个个读 
  21.         int i= fis.read(); 
  22.         //用read()实现文件的完整输出 
  23.         while(i!=-1){ 
  24.             System.out.print((char)i); 
  25.             i = fis.read(); 
  26.         }*/  
  27.         //获取此流中的有效字节数  
  28.         int length=fis.available();  
  29.         //按块读  
  30.         byte[] buf= new byte[length];//刚好存满  
  31.         fis.read(buf);//此行代码执行完毕后文件中所有的字节都存到buf数组中  
  32.         String fileCountent = new String(buf);//用一个字符串接收这个数组  
  33.         System.out .println(fileCountent);  
  34.         //关闭流  
  35.         fis.close();  
  36.     }     
  37. }  

*中文字符由两个字节组成，在对流数据进行读取时会将字符拆成字节一个个读取，造成乱码。

代码如下：

[java] view plain copy
 
  1. import java.io.FileInputStream;  
  2.   
  3. /** 
  4.  * 文件的输入输出流 
  5.  * @author Administrator 
  6.  * 
  7.  */  
  8. public class FileOperationTest {  
  9.       
  10.     public static void main(String[] args) throws Exception {  
  11.         readFile("G:\文件测试\1.txt");  
  12.     }  
  13.     /** 
  14.      * 读取指定的文件 
  15.      * @param fileName 
  16.      */  
  17.     public static void readFile(String fileName) throws Exception{  
  18.         //根据fileName构建文件输入流对象  
  19.         FileInputStream fis = new FileInputStream(fileName);  
  20.         //从此输入流中读取数据一个个读  
  21.         int i= fis.read();  
  22.         //用read()实现文件的完整输出  
  23.         while(i!=-1){  
  24.             System.out.print((char)i);  
  25.             i = fis.read();  
  26.         }  
  27.         /*//获取此流中的有效字节数 
  28.         int length=fis.available(); 
  29.         //按块读 
  30.         byte[] buf= new byte[length];//刚好存满 
  31.         fis.read(buf);//此行代码执行完毕后文件中所有的字节都存到buf数组中 
  32.         String fileCountent = new String(buf);//用一个字符串接收这个数组 
  33.         System.out .println(fileCountent); 
  34.         //关闭流 
  35.         fis.close();*/  
  36.     }     
  37. }  

通过read（byte[] b）方法将流中的数据整体保存在byte型数组中，用字符串接收这个数组，这串数据怎么解码的字符串在接收时又怎么拼接起来。

代码如下：

[java] view plain copy
 
  1. import java.io.FileInputStream;  
  2.   
  3. /** 
  4.  * 文件的输入输出流 
  5.  * @author Administrator 
  6.  * 
  7.  */  
  8. public class FileOperationTest {  
  9.       
  10.     public static void main(String[] args) throws Exception {  
  11.         readFile("G:\文件测试\1.txt");  
  12.     }  
  13.     /** 
  14.      * 读取指定的文件 
  15.      * @param fileName 
  16.      */  
  17.     public static void readFile(String fileName) throws Exception{  
  18.         //根据fileName构建文件输入流对象  
  19.         FileInputStream fis = new FileInputStream(fileName);  
  20.         /*//从此输入流中读取数据一个个读 
  21.         int i= fis.read(); 
  22.         //用read()实现文件的完整输出 
  23.         while(i!=-1){ 
  24.             System.out.print((char)i); 
  25.             i = fis.read(); 
  26.         }*/  
  27.         //获取此流中的有效字节数  
  28.         int length=fis.available();  
  29.         //按块读  
  30.         byte[] buf= new byte[length];//刚好存满  
  31.         fis.read(buf);//此行代码执行完毕后文件中所有的字节都存到buf数组中  
  32.         String fileCountent = new String(buf);//用一个字符串接收这个数组  
  33.         System.out .println(fileCountent);  
  34.         //关闭流  
  35.         fis.close();  
  36.     }     
  37. }  

写的操作与读的操作一一对应

三、实例，实现文件的复制粘贴

我们通过两种方式实现文件的复制粘贴，比较两种方式的效率。

第一种：用read（）方法和write()方法实现复制粘贴。

第二种：创建缓冲区及byte型数组（用read(byte[])方法和write(byte[],int off,int len)）实现复制粘贴。

*文件复制从G:文件测试14.txt，复制到的G:文件测试24.txt。

从实验可以看出第二种方法的效率高于第一种，代码如下:

[java] view plain copy
 
  1. import java.io.FileInputStream;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4.   
  5. /** 
  6.  * 文件的输入输出流 
  7.  * @author Administrator 
  8.  * 
  9.  */  
  10. public class FileOperationTest {  
  11.       
  12.     public static void main(String[] args) throws Exception {  
  13.         String srcPath = "G:\文件测试1\4.txt";  
  14.         String destPath = "G:\文件测试2\4.txt";  
  15.         //计时器>计算复制粘贴文件所用的时间  
  16.         long start_time = System.currentTimeMillis();  
  17.         copyPaste(srcPath,destPath);  
  18.         long end_time = System.currentTimeMillis();  
  19.         System.out.println("拷贝用时："+(end_time - start_time));  
  20.     }  
  21.          /** 
  22.          *  
  23.          * @param srcPath 
  24.          * @param destPath 
  25.          * @throws Exception  
  26.          */  
  27.         public static void copyPaste(String srcPath,String destPath) throws Exception {  
  28.             //构建文件输入输出流对象  
  29.             FileInputStream fis = new FileInputStream(srcPath);  
  30.             FileOutputStream fos = new FileOutputStream(destPath);  
  31.             //读取以及写入文件内容  
  32.             /*//用read（）方法和write()方法实现复制粘贴 
  33.             int i =fis.read(); 
  34.             while(i != -1){ 
  35.                 fos.write(i);//写 
  36.                 i = fis.read(); 
  37.             }*/  
  38.             //创建缓冲区（用read(byte[])方法和write(byte[],int off,int len)）实现复制粘贴  
  39.             byte[] buf = new byte[1024];//1024个字节大小的缓冲区  
  40.             //read(byte[])方法返回读取的字节的数量  
  41.             int i = fis.read(buf);  
  42.             while(i!=-1){  
  43.                 //按块写入，每次写入1024个字节，最后一次写入len个字节  
  44.                 fos.write(buf, 0, i);  
  45.                 i = fis.read(buf);  
  46.             }  
  47.             fis.close();  
  48.             fos.close();  
  49.         }  
  50.       
  51. }  

 三种读写文件的操作总结：

*  1.一个一个字节读写，用read(),write()方法对数据拆分成字节而进行读写，优点是灵活，逻辑也比较简单，但并不适合大数据的读写。

 *  2.一块一块缓冲区读写，用read（byte[] b）,write(byte[] b)方法实现按块的读取，b为读取或者写入的字节数量，优点是适当大小的缓冲区（byte型数组）可以显著提高读写的速度（较一个一个字节读写而言），但因为缓冲区（数组长度）固定，最后一个缓冲区或许字节数会不够，read(byte[] b)就会写入很多空数据，造成文件变大。

 *  3.一次性读写，用read（byte[] b）,write(byte[] b,int off,int len)方法，与第二种方法相似，不同在于，write（byte[] b,int off,int len）会判断缓冲区里字节的数量，与第二种方法遇到最后一缓冲区里的字节数不够却写入空数据充数相比，这种方法会根据缓冲区里的字节数写入相应数量的数据。

二、在文件输入输出流的基础上，对字节进行包装而衍生的其他字节流，常见的如下：

*1.BufferedInputStream    缓冲字节流         BufferedOutputStream

*2.DataInputStream         原始数据流          DataOutputStream

*3.ObjectInputStream         对象流               ObjectOutputStream

*4.ByteArrayInputStream    内存流               ByteArrayOutputStream

应用如下：

代码如下：

[java] view plain copy
 
    1. import java.io.BufferedInputStream;  
    2. import java.io.BufferedOutputStream;  
    3. import java.io.FileInputStream;  
    4. import java.io.FileNotFoundException;  
    5. import java.io.FileOutputStream;  
    6. import java.io.IOException;  
    7.   
    8. /** 
    9.  * 根据文件输入输出流来了解其他流 
    10.  * @author Administrator 
    11.  * 
    12.  */  
    13.   
    14. public class Test {  
    15.   
    16.     public static void main(String[] args) throws Exception {  
    17.         //Student stu = new Student();  
    18.         //stu.study();  
    19.           
    20.           
    21.         //计时器>计算复制粘贴文件所用的时间  
    22.         long start_time = System.currentTimeMillis();  
    23.         writeToFileBufferedStream("G:\文件测试1\《超神学院》第十集.flv","G:\文件测试2\《超神学院》第十集.flv");  
    24.         long end_time = System.currentTimeMillis();  
    25.         System.out.println("拷贝用时："+(end_time - start_time));  
    26.           
    27.           
    28.         }  
    29.     /** 
    30.      *  
    31.      * @param srcPAth 
    32.      * @param destPath 
    33.      * @throws Exception  
    34.      */  
    35.     public static void writeToFileBufferedStream(String srcPath,String destPath) throws Exception {  
    36.         //构建输出流对象  
    37.         FileInputStream fis = new FileInputStream(srcPath);  
    38.         FileOutputStream fos = new FileOutputStream(destPath);  
    39.         //构建缓冲字节输入输出流  
    40.         BufferedInputStream bis = new BufferedInputStream(fis);  
    41.         BufferedOutputStream bos = new BufferedOutputStream(fos);  
    42.         //读写操作（复制粘贴的功能）  
    43.         int i= bis.read();  
    44.         while(i!=-1){  
    45.             bos.write(i);  
    46.             i = bis.read();  
    47.         }  
    48.         bos.flush();//清空缓冲区  
    49.         bos.close();  
    50.         bis.close();  
    51.         fos.close();  
    52.         fis.close();  
    53.         }  
    54. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/tutumissed/p/8276621.html