IO流

IO流用来处理设备间的数据传输，java在io包中有许多操作流的对象。流分为字节流与字符流。

字节流的类：InputStream,OutputStream  字符流的抽象基类：Reader,Writer。IO中后缀名包含前面四个类名的，

都是流的子类。

接下来介绍几个类：

FileWrite是个便捷的操作文件的类，这个对象初始化一定要明确被操作的文件。如果文件创建到某个目录，而且

该目录有同名文件，则将他覆盖。该类中的write方法，只是将字符串写到了流中，并没有存到文件中去，只有调用

flush方法，才会真正写到目的地文件中。close方法则是关闭流资源，关闭之前会将数据写到目的文件中，flush刷新后，

流可以继续使用，也就是还可以在继续写入数据，而close直接关闭流。这就是两者的区别。可以不要flUsh方法，因为

close方法调用直接会刷新流。

io异常的处理：

trp catch finally ；write，flush，close方法都会抛出异常。例子：

FileWrite a = null;

trp

{

     a = new FileWriter("1.txt");//创建一个文件

     a.write("abc");

     catch(IOException e)

    {

             System.out.println(e.toString());

    }

   finally    //为什么这里还要加finally语句，因为如果流已经声明，之后发生错误，流就没关闭，所以在finally去关闭

   {

             try

                 {

                            a.close();      //为什么这个语句要写try catch 因为close方法也会抛出异常

                 }

                 catch (IOException e)

                 {

                      System.out.println(e.toString());

                  }

  }

}

接下来介绍FIleReader类：

read方法是将字符读入数组，返回的是int。也就是说读取了多少个字符。例子：

FileReader a = new FIleReader("1.txt")；//加入这个文件的数据为123456789

char[] buf = new char[4];

int num = a.read(buf);//这里运行后的结果num = 4  , buf 内容为1234  //当num等于-1 说明读入结束

a.close();

字符流读写文件的例子：

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextTest_2 {
 
   private static final int BUFFER_SIZE = 1024;
   public static void main(String[] args) {
   
      FileReader fr = null;
      FileWriter fw = null;
      try {
        fr = new FileReader("E:\\copy\\1.txt");
        fw = new FileWriter("E:\\copy\\2.txt");
        
        //创建一个临时容器，用于缓存读取到的字符。
        char[] buf = new char[BUFFER_SIZE];//这就是缓冲区。 
        
        //定义一个变量记录读取到的字符数，(其实就是往数组里装的字符个数 )
        int len = 0;
        
        while((len=fr.read(buf))!=-1){ 
           fw.write(buf, 0, len);
        }
        
      } catch (Exception e) {
//       System.out.println("读写失败");
        throw new RuntimeException("读写失败");
      }finally{
        if(fw!=null)
          try {
            fw.close();
          } catch (IOException e) {
            
            e.printStackTrace();
          }
        if(fr!=null)
          try {
            fr.close();
          } catch (IOException e) {
            
            e.printStackTrace();
          }
      }
    } 
  }

用缓冲区方法buffer读写文件，为什么要缓冲区呢，因为可以提高写入的效率。下面是一个例子：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; 
public class CopyTextByBufTest { 
   public static void main(String[] args) throws IOException { 
    FileReader fr = new FileReader("E:\\copy\\1.txt");   
    BufferedReader bufr = new BufferedReader(fr);
    FileWriter fw = new FileWriter("E:\\copy\\2.txt");
    BufferedWriter bufw = new BufferedWriter(fw);  
    String line = null;
    while((line=bufr.readLine())!=null){
      bufw.write(line);
      bufw.newLine();
      bufw.flush();
    } 
    bufw.close();
    bufr.close();
  }
}

说完字符流，接下来介绍字节流。字节流（InputStream、OutputStream）

 字节流的读写例子如下：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Stream {
 public static void main(String[] args) throws IOException {
     FileInputStream fis = new FileInputStream("e:\\copy\\1.txt");    
     FileOutputStream fos = new FileOutputStream("f:\\copy\\1.txt");
     byte[] buf = new byte[1024];
     int len = 0;  
     while((len=fis.read(buf))!=-1){ //当等于-1 表示读取结束
       fos.write(buf,0,len);
     }   
     fos.close();
     fis.close();
   }
}

此外，还有几种读写的方法，接下来举例子说明：

一、使用缓冲区。提高效率。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Stream {
 public static void main(String[] args) throws IOException {
  FileInputStream fis = new FileInputStream("E:\\copy\\1.txt");  
     BufferedInputStream bufis = new BufferedInputStream(fis);    
     FileOutputStream fos = new FileOutputStream("F:\\copy\\1.txt");
     BufferedOutputStream bufos = new BufferedOutputStream(fos);    
     int ch = 0;
     while((ch=bufis.read())!=-1){
      System.out.println((char)ch);
       bufos.write(ch);
     }   
     bufos.close();
     bufis.close();
   }
}

二、不建议使用，一次性读入和写入。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Stream {
 public static void main(String[] args) throws IOException {
  FileInputStream fis = new FileInputStream("e:\\copy\\1.txt");    
     FileOutputStream fos = new FileOutputStream("f:\\copy\\1.txt"); 
     byte[] buf = new byte[fis.available()];
     System.out.println(fis.available());
     fis.read(buf);
     fos.write(buf);
     fos.close();
     fis.close();
 }
}

三、没有效率，一个个字符的读写。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Stream {
 public static void main(String[] args) throws IOException {
  FileInputStream fis = new FileInputStream("e:\\copy\\1.txt");    
     FileOutputStream fos = new FileOutputStream("f:\\copy\\1.txt");
     int ch = 0;
     while((ch =fis.read())!=-1){
       fos.write(ch);
     }
     fos.close();
     fis.close();
 }
}