Java IO流

 

Java IO流 Stream

 

 

InputStream/OutputStream	抽象类-字节
Reader/Writer	抽象类-字符
FileInputStream/FileOutputStream	文件-字节
FileReader/FileWriter	文件-字符
BufferedInputStream/BufferedOutputStream	缓冲区-字节
BufferedReader（可以整行读）/BufferedWriter	缓冲区-字符
ByteArrayInputStream/ByteArrayOutputStream	内存字节数组读写
InputStreamReader/OutputStreamWriter	转换流-字节转字符
DataInputStream/DataOutputStream	直接写基础数据类型，utf-8的字符串
PrintStream/PrintWriter	打印流-字节-字符
ObjectInputStream/ObjectOutputStream	Object流，serializable、 externalizable 接口，transient关键字

• 节点流

	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

FileOutputStream、FileWriter这些输出流，打开文件的时候，如果文件没有会自动创建该文件。（ 目录好像不会自动创建）

• 缓冲流：

缓冲流要“ 套接”在相应的节点流之上，对读写的数据提供了 缓冲的功能，

提高了读写的效率，同时增加了一写新的方法。

缓冲输入流支持其父类的 mark和 reset方法。

BufferedReader提供了 readLine方法用于读取一行字符串（以\r或\n分割）。

BufferedWriter提供了 newLine用于写入一个行分割符。

对于输出的缓冲流，写出的数据会先在 内存中缓存，使用 flush方法将会使内存中的数据立刻写出。

BufferedInputStream

BufferedOutputStream

BufferedInputStream(InputStream in)           创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

BufferedInputStream(InputStream in, int size)           创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

• 转换流：

InputStreamReader  是 字节流通向 字符流的桥梁

OutputStreamWrier  是 字符流通向 字节流的桥梁

 

InputStreamReader(InputStream in)           创建一个使用默认字符集的 InputStreamReader。

InputStreamReader(InputStream in, Charset cs)           创建使用给定字符集的 InputStreamReader。

InputStreamReader(InputStream in, CharsetDecoder dec)           创建使用给定字符集解码器的 InputStreamReader。

InputStreamReader(InputStream in, String charsetName)           创建使用指定字符集的 InputStreamReader。

OutputStreamWriter(OutputStream out)           创建使用默认字符编码的 OutputStreamWriter。

OutputStreamWriter(OutputStream out, Charset cs)           创建使用给定字符集的 OutputStreamWriter。

OutputStreamWriter(OutputStream out, CharsetEncoder enc)           创建使用给定字符集编码器的 OutputStreamWriter。

OutputStreamWriter(OutputStream out, String charsetName)           创建使用指定字符集的 OutputStreamWriter。

//由于FileOutputStream不支持直接写字符串，仅支持字节byte

//采用OutputStreamWriter支持字符串，起到一个转换的功能。

public   class   TestTransForm1 {

public   static   void   main(String[] args) {

  try   {

   OutputStreamWriter osw =   new   OutputStreamWriter(

          new   FileOutputStream( "d:\\bak\\char.txt"   ));

   osw.write( "mircosoftibmsunapplehp" );

   System. out .println(osw.getEncoding());

   osw.close();

   osw =   new   OutputStreamWriter(

                                             new   FileOutputStream( "d:\\bak\\char.txt" ,   true ),

                                             "ISO8859_1" );   // latin-1 西欧语言

   osw.write( "mircosoftibmsunapplehp" );

   System. out .println(osw.getEncoding());

   osw.close();

 }   catch   (IOException e) {

   e.printStackTrace();

 }

}

}

//读取控制台的标准输入

public   class   TestTransForm2 {

public   static   void   main(String args[]) {

  // to get input stream form keyboard[System.in]

    // 添加转换流，防止中文汉字被截断

 InputStreamReader isr =

           new   InputStreamReader(System. in );

    // 添加缓冲流，为了使用readLine

 BufferedReader br =   new   BufferedReader(isr);

 String s =   null ;

  try   {

   s = br.readLine();

     while (s!= null ){

        //阻塞，直到用户输入exit

       if (s.equalsIgnoreCase(   "exit" ))   break ;

     System. out .println(s.toUpperCase());

     s = br.readLine();

   }

   br.close();

 }   catch   (IOException e) {

   e.printStackTrace();

 }

}

}

• 数据流：

DataInputStream：数据输入流允许应用程序以与机器无关方式 从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

DataOutputStream：数据输出流允许应用程序以适当方式将 基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

 

               // 此类实现了一个输出流，其中的数据被写入一个 byte 数组。

               // 缓冲区会随着数据的不断写入而自动增长。

               // 可使用 toByteArray() 和 toString() 获取数据

            ByteArrayOutputStream baos =   new   ByteArrayOutputStream();

               // DataOutputStream 将基本 Java 数据类型写入输出流

            DataOutputStream dos =   new   DataOutputStream(baos);

               try   {

                     // 输出随机数Double 和 true Boolean

                  dos.writeDouble(Math. random());

                  dos.writeBoolean(   true );

             

                    // ByteArrayInputStream 包含一个内部缓冲区，

                    //   该缓冲区包含从流中读取的字节

                  ByteArrayInputStream bais = 

                       new   ByteArrayInputStream(baos.toByteArray());

                  System.   out .println(bais.available());

                  DataInputStream dis =   new   DataInputStream(bais);

                     // 先写先读，队列

                  System.   out .println(dis.readDouble());

                  System.   out .println(dis.readBoolean());

                  dos.close();  dis.close();

            }   catch   (IOException e) {

                  e.printStackTrace();

            }

-------------------------------------------------------------------------------------

OutPut: 

9

0.24384757082225805

true

-----------------------------------------------------------------------------------

• Print流：

PrintWriter和PrintStream都属于 输出流，分别针对于 字符和 字节。不会抛出异常，有自动 flush功能。

//  system.out重新设置

// 输出到文件中

public class TestPrintStream1 {
  public static void main(String[] args) {
      PrintStream ps = null;
    try {
        FileOutputStream fos =
              new FileOutputStream("d:\\bak\\log.dat");
        ps = new PrintStream(fos);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if(ps != null){
        System.setOut(ps);
    }
    int ln = 0;
    for(char c = 0; c <= 60000; c++){
        System.out.print(c+ " ");
      if(ln++ >=100){ System.out.println(); ln = 0;}
    }
  }
}

// open file ， read， print to screen

public class TestPrintStream2 {
  public static void main(String[] args) {
    String filename = args[0];
    if(filename!=null){list(filename ,System.out);}
  }
  public static void list(String f,PrintStream fs){
    try {
       BufferedReader br =
                  new BufferedReader(new FileReader(f));
      String s = null;
      while((s=br.readLine())!=null){
        fs.println(s);           
      }
      br.close();
    } catch (IOException e) {
      fs.println("无法读取文件");
    }
  }
}

// read standard system.in， write to file

public class TestPrintStream3 {
  public static void main(String[] args) {
    String s = null;
      BufferedReader br = new BufferedReader(
                        new InputStreamReader(System.in));
    try {
        FileWriter fw  = new FileWriter
                           ("d:\\bak\\logfile.log", true); //Log4J
       PrintWriter log = new PrintWriter(fw);
      while ((s = br.readLine())!=null) {
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        log.println("-----");
        log.println(s.toUpperCase());
        log.flush();
      }
      log.println("==="+new Date()+"===");
      log.flush();
      log.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

• Object流：

直接将Object写入或读出

如果想把对象序列化，那么要继承 serializable【空接口，标记类为可序列化】

transient 透明，修饰的成员变量在序列化的时候不予考虑

externalizable接口【控制类是如何序列化的】（实现了它，等于实现了serializable）【很少用】

// 先将t对象写入文件

// 然后读取t对象

public class TestObjectIO {
     public static void main(String args[]) throws Exception {
          T t = new T();
          t.k = 8;
          FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");
          ObjectOutputStream oos = new ObjectOutputStream(fos);
          oos.writeObject(t);
          oos.flush();
          oos.close();
         
          FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
          ObjectInputStream ois = new ObjectInputStream(fis);
          T tReaded = (T)ois.readObject();
          System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
         
     }
}


//   transient  透明，修饰的成员变量在序列化的时候不予考虑
class T
     implements Serializable
{
     int i = 10;
     int j = 9;
     double d = 2.3;
       transient  int k = 15;
}