Java中的I/O流，包含字节流和字符流的常用介绍

一.InputStream和FileInputStream
         FileInputStream f=new FileInputStream("test.txt");
        int i;
        int b=f.read();
        for(i=0;b!=-1;i++){
           b=f.read();
            System.out.println((char)b);    //输出的是字节流，需要转换
        }
        f.close();
    
  
二.OutputStream和FileOutputStream
        String s="这是是要输入的字符";
        byte []b=s.getBytes();            //上面这个几个类都是处理的字节流，需要转换
        FileOutputStream f=new FileInputStream("test.txt");
        f.write(b);                      //将字节写入文件
        f.close();

三.PrintStream  非常重要的输出流类
     System.out是java.io.PrintStream类型的变量，
             特性：1.包含直接输出多种类型数据不同的方法
                   2.大部分成员方法不跑出异常
                   3.可以选择是否采用自动强制输出特性  flush()
    使用： PrintStream f=new PrintStream("test.txt");
           f.printf("输入的数据");
           f.close();

四. DataInputStream 和 DataOutputStream  数据的输入流和输出流类
    
       FileOutputStream fout=new FileOutputStream("out.txt");
       DataOutputStream dfout=new DataOutputStream ("out.txt");
       dfout.writeInt(12345);               //这里可以选择直接输入多种数据类型
       dfout.close();                       //如果是write(),则直接输入byte []类型数据

       FileInputStream fin=new FileInputStream("out.txt");
       DataInputStream dfin=new DataInputStream ("out.txt");
       for(i=0;i<4;i++)
       dfout.readInt();               //这里可以选择直接输入多种数据类型
       dfout.close();                       //如果是write(),则直接输入byte []类型数据

五。BufferedInputStream 和 BufferedOutputStream  带缓存的输入流和输出流
     FileInputStream f=new FileInputStream("test.txt");
     BufferedInputStream fb=new BufferedInputStream(f);
                              //读取数据方式与FileInputStream基本相同，只是效率更高，
                               // 需要每次强制输出 flush();

六.重新定义标准输入输出流的方法
      java.lang.System的静态方法：
            static void setIn(InputStream in)
            static void setOut(PrintStream out) 
   下面是一段例子：
    import java.io.*;

     public class Redirecting {

       public static void main(String[] args) throws IOException {
              PrintStream console = System.out;
              BufferedInputStream in = new BufferedInputStream( new FileInputStream( "Redirecting.java"));
              PrintStream out = new PrintStream( new BufferedOutputStream( new FileOutputStream("test.out")));
              System.setIn(in);
              System.setOut(out);

              BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
              String s;
              while((s = br.readLine()) != null)
                     System.out.println(s);
              out.close();
              System.setOut(console);
       }
    }
   提供了重新定义标准输入输出流的方法，这样做是很方便的，比如一个程序的结果有很多，有时候甚至要翻页显示，这样不便于观看结   果，这是你就可以将标准输出流定义为一个文件流，程序运行完之后打开相应的文件观看结果，就直观了许多。

 七.RandomAccessFile 类，
        允许使用同一个实例对象对同一个文件交替进行读写，需要使用时可以查JDK
        也可以操作多种数据类型

 
                                                           （注：上面的这些类，都是处理字节流）

 

     下面的都是处理的字符流类

八：FileReader 和 FileWriter
      FileWriter f=new FileWriter("test.txt");
      f.write("这里可以直接写入字符"):
      f.close();

      FileReader f=new FileReader("test.txt");
      for(int c=f.read();c!=-1;c=f.read())
      System.out.Print((char)c);
      f.close();

九. BufferedReader LineNumberReader 和 BufferedWriter  带缓存的字符流读写器
     创建实例对象
            BufferedReader br=new BufferedReader(new FileReader("test.txt"));
            BufferedWriter br=new BufferedWriter(new FileWriter("test.txt"));
     其他方法：
       BufferedReader   readLine()  //从当前字符流中读取一行字符                      
       LineNumberReader  //继承了BufferedReader的所有方法 另还有 getLineNumber() 获取当前行号
       BufferedWriter   newLine()   //写入行分隔符，即换行

   
      BufferedWriter bw=new BufferedWriter(new FileWriter("test.txt"));
      bw.write("写入数据一");
      bw.newLine();            //插入换行符
      bw.write("写入数据二");
      bw.newLine();
      bw.close();

      LineNumberReader br=new LineNumberReader(new FileReader("test.txt"));
      String s;
      for(s=br.readLine();s!=null;s=br.readLine()){
         System.out.print(br.getLineNumber()+s);         //读取当前数据行数和这一行的数据
      }
 

十.PrintWriter   非常重要的字符流类
      使用方法：  
          PrintWriter f=new PrintWriter("test.txt");
          f.println("写入的字符");            //将字符写入文件
          f.close();

十一：  一个例子
  
   import java.io.*;

   public class IOStreamDemo {

      public void samples() throws IOException {

           //1. 这是从键盘读入一行数据,返回的是一个字符串
           BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
           System.out.print("Enter a line:");
           System.out.println(stdin.readLine());

           //2. 这是从文件中逐行读入数据

           BufferedReader in = new BufferedReader(new FileReader("IOStreamDemo.java"));
           String s, s2 = new String();
           while((s = in.readLine())!= null)
                      s2 += s + "/n";
           in.close();

           //3. 这是从一个字符串中逐个读入字节
           StringReader in1 = new StringReader(s2);
           int c;
           while((c = in1.read()) != -1)
                      System.out.print((char)c);

           //4. 这是将一个字符串写入文件
           try {
                      BufferedReader in2 = new BufferedReader(new StringReader(s2));
                      PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));
                      int lineCount = 1;
                      while((s = in2.readLine()) != null )
                                 out1.println(lineCount++ + ": " + s);
                      out1.close();
           } catch(EOFException e) {
                      System.err.println("End of stream");
           }
      }

}

十二。对象序列化 ObjectOutputStream 和 ObjectInputStream
          ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out")); //构造方法

  Java流有着另一个重要的用途，那就是利用对象流对对象进行序列化。下面将开始介绍这方面的问题。

在一个程序运行的时候，其中的变量数据是保存在内存中的，一旦程序结束这些数据将不会被保存，一种解决的办法是将数据写入文件，而Java中提供了一种机制，它可以将程序中的对象写入文件，之后再从文件中把对象读出来重新建立。这就是所谓的对象序列化Java中引入它主要是为了RMI（Remote Method Invocation）和Java Bean所用，不过在平时应用中，它也是很有用的一种技术。

所有需要实现对象序列化的对象必须首先实现Serializable接口。下面看一个例子：

import java.io.*;
import java.util.*;

public class Logon implements Serializable {

       private Date date = new Date();
       private String username;
       private transient String password;

       Logon(String name, String pwd) {
              username = name;
              password = pwd;
       }

       public String toString() {
              String pwd = (password == null) ? "(n/a)" : password;
              return "logon info: /n " + "username: " + username + "/n date: " + date + "/n password: " + pwd;
       }

       public static void main(String[] args) throws IOException, ClassNotFoundException {
              Logon a = new Logon("Morgan", "morgan83");
              System.out.println( "logon a = " + a);
              ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));
              o.writeObject(a);
              o.close();

              int seconds = 5;
              long t = System.currentTimeMillis() + seconds * 1000;
              while(System.currentTimeMillis() < t) ;

              ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));
              System.out.println( "Recovering object at " + new Date());
              a = (Logon)in.readObject();
              System.out.println("logon a = " + a);
       }
}
 

类Logon是一个记录登录信息的类，包括用户名和密码。首先它实现了接口Serializable，这就标志着它可以被序列化。之后再main方法里ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));新建一个对象输出流包装一个文件流，表示对象序列化的目的地是文件Logon.out。然后用方法writeObject开始写入。想要还原的时候也很简单ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));新建一个对象输入流以文件流Logon.out为参数，之后调用readObject方法就可以了。

需要说明一点，对象序列化有一个神奇之处就是，它建立了一张对象网，将当前要序列化的对象中所持有的引用指向的对象都包含起来一起写入到文件，更为奇妙的是，如果你一次序列化了好几个对象，它们中相同的内容将会被共享写入。这的确是一个非常好的机制。