Java文件字节流和字符流FileInputStream,FileOutputStream，FileReader,FileWriter

一，文件输入流和文件输出流：FileInputStream,FileOutputStream
FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。

int read();int read(byte b[]);int read(byte b[],int off,int len);

使用方法：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。

//构造函数
FileInputStream（String name）;
FileInputStream(File file);
//使用方法(1)
File f=new File("d:/a.txt");   
FileInputStream in=new FileInputStream( f);
//使用方法（2）
FileInputStream in=new FileInputStream("d:/a.txt");

程序举例：

import java.io.IOException; 
import java.io.FileInputStream; 
; 
public class TestFile { 
    public static void main(String args[]) throws IOException { 
        try{     
              FileInputStream rf=new   FileInputStream("d:/a.txt"); 
               int n=512;   
               byte  buffer[]=new  byte[n];    
               while((rf.read(buffer,0,n)!=-1)&&(n>0)){ //把文件内容读到这个缓存数组里边去，缓存数组其实就是内存
              System.out.println(new String(buffer) ); 
              } 
                System.out.println(); 
                rf.close(); 
        } catch(IOException  IOe){       
              System.out.println(IOe.toString()); 
        } 
    }  
} 

FileOutputStream类用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件，FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串

//方法
void write(byte b[]);void write(byte b[],int off,int len);

//构造函数
FileOutputStream（String name）;
FileOutputStream(File file);
//使用方法(1)
File f=new File("d:/a.txt");   
FileOutputStream in=new FileOutputStream( f);
//使用方法（2）
FileOutputStream in=new FileOutputStream("d:/a.txt");

程序举例：
import java.io.*;

import java.io.*;
public class test {
   public static void main(String args[]) {
      byte [] b="你想在还在武汉吗?".getBytes();
      try{  
          FileOutputStream out=new FileOutputStream("hello.txt");
          out.write(b);
          out.write(b,0,b.length); //把字符串写到文件里面
      }
      catch(IOException e) {
          System.out.println("Error "+e);
      }
  }
}

例子：把一个文件拷贝到另一个文件中

import java.io.File; 
import java.io.IOException; 
import java.io.FileOutputStream; 
import java.io.FileInputStream; 
public class test{ 
    public static void main(String args[]) throws IOException { 
        try { 
            File fromFile = new File("a.txt"); 
            File toFile = new File("b.txt"); 
            FileInputStream formS = new FileInputStream(fromFile); //文件输入流
            FileOutputStream toS = new FileOutputStream(toFile); //文件输出流
            int c; 
            while ((c = formS.read()) != -1) { 
                toS.write(c); //从a中读到后就写到b中去
            } 
            finS.close(); 
            foutS.close(); 
        } catch (IOException e) { 
            System.err.println("FileStreamsTest: " + e); 
        } 
    }  
} 

二，文件字符流：FileReader,FileWriter
文件字节流的read个write方法使用字节读写操作，即以字节为基本单位处理数据，但是字节流不能很好的操作Unicode字符，比如一个汉字占用两个字节。
与FileInputStream,FileOutputStream对应的是FileReader和Filewriter字符流，分别是Reader和Writer的子类。

//FileReader
FileReader(String filename);
FileReader(File file);
//方法
int read();
int read(byte b[]);
int read(byte b[],int off,int len);
//FileWriter
FileWriter(String filename);
FileWriter(File file);
//方法
void write(byte b[]);
void write(byte b[],int off,int len);

程序举例：

import java.io.*;
public class test {
   public static void main(String args[]) {
      char a[]="这是文件字符流".toCharArray();   
      int n=0,m=0;
      try{  File f=new File("secret.txt");
            for(int i=0;i<a.length;i++) {
               a[i]=(char)(a[i]^‘R‘);//对数组a进行加密
            }
            FileWriter out=new FileWriter(f);
            out.write(a,0,a.length);//向文件f中写加密的数组a
            out.close();
            FileReader in=new FileReader(f);
            char tom[]=new char[10];
            System.out.println("密文:");
            while((n=in.read(tom,0,10))!=-1) {//从文件f中读出已经加密的a到数组tom中再输出
               String s=new String (tom,0,n);
               System.out.print(s);
            }
            in.close();
            System.out.printf("\n解密：\n"); 
            in=new FileReader(f);
            while((n=in.read(tom,0,10))!=-1) { 
               for(int i=0;i<n;i++) {
                  tom[i]=(char)(tom[i]^‘R‘);//对数组tom解密
               }
               String s=new String (tom,0,n);
               System.out.print(s);//输出
            }
            in.close();
          }
      catch(IOException e) {
          System.out.println(e.toString());
      }
   }
}