Java SE 08 IO

 

1.Java流式输入/输出原理

               

2.Java流类的分类

                 

              

Java I/O类库需要多种不同功能的组合，通过叠合多个对象来提供所期望的功能。（装饰器设计模式）

3.输入/输出流类

      

    

          

          

            

            

          

      

4.常见的节点流和处理流

 

5.文件流

package com.io;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
 
public class TestFileInputStream {//从文件中读取字节并打印
     public static void main(String[] args) {
        
         int b = 0;
         long num = 0;
        
         FileInputStream in = null;
         try {
             
              in = new FileInputStream("D:\\eclipse-workspace\\"
         +"IO\\src\\com\\io\\TestFileInputStream.java");
             
         } catch (FileNotFoundException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
         }
         try {
             
              while((b = in.read())!=-1) {
                   System.out.print((char)b);
                   num++;
              }
              in.close();
              System.out.println("共读取了"+num+"个字节");
             
         } catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
         }
     }
}
/*输出：
package com.io;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
 
public class TestFileInputStream {//从文件中读取字节并打印
     public static void main(String[] args) {
        
         int b = 0;
         long num = 0;
        
         FileInputStream in = null;
         try {
              in = new FileInputStream("D:\\eclipse-workspace\\"
         +"IO\\src\\com\\io\\TestFileInputStream.java");
         } catch (FileNotFoundException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
         }
         try {
             
              while((b = in.read())!=-1) {
                   System.out.print((char)b);
                   num++;
              }
              in.close();
              System.out.println("????????"+num+"??×???");
         } catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
         }
     }
}
共读取了760个字节
 
 */

package com.io;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * FileInputStream、FileOutputStream、FileWriter、FileReader
 * */
public class TestFileIO {
     public static void main(String[] args) {
        
         int a=0;
         FileInputStream in = null;
         FileOutputStream out = null;
         int b=0;
         FileReader fr = null;
         FileWriter fw = null;
        
         try {
              in = new FileInputStream("D:\\eclipse-workspace"
                       + "\\IO\\src\\com\\io\\TestFileIO.java");
              out = new FileOutputStream("D:\\eclipse-workspace"
                        + "\\IO\\src\\com\\io\\TestFileIO.txt");
              while((a=in.read())!=-1) {            //每读取一个字节就写入新的文件
                   out.write(a);
              }
              in.close();
              out.close();
              System.out.println("产生新的文件TestFileIO.txt！");
             
              fr = new FileReader("D:\\eclipse-workspace"
                       + "\\IO\\src\\com\\io\\TestFileIO.java");
              fw = new FileWriter("D:\\eclipse-workspace"
                       + "\\IO\\src\\com\\io\\TFIO.java");
              while((b=fr.read())!=-1) {
                   fw.write(b);
              }
              fr.close();
              fw.close();
              System.out.println("产生新的文件TFOS.java！");
         } catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
         }       
     }
}

6.缓冲流 

package com.io;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 在节点流基础上的处理流
 * 缓冲流
 * 先在缓冲区中写，写满了再往文件中一块写
 * 读的时候不是一个字节一个字节地读而是一行一行的地读
 * */
public class TestBufferStream {
       public static void main(String[] args) {
             
              try {
                     FileWriter fw = new FileWriter("d:\\a.txt");
                     FileReader fr = new FileReader("d:\\a.txt");
                     BufferedWriter bw = new BufferedWriter(fw);
                     BufferedReader br = new BufferedReader(fr);
                     String s= null;
                    
                     for(int i=0;i<100;i++) {
                            s=String.valueOf(Math.random());
                            bw.write(s);
                            bw.newLine();
                     }
                     bw.flush();
                    
                     while((s=br.readLine())!=null) {
                            System.out.println(s);
                     }
                    
                     fw.close();
                     fr.close();
                     bw.close();
                     br.close();
              } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
}

7.数据流 

package com.io;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
 
public class TestDataStream {
       public static void main(String[] args) {
             
              ByteArrayOutputStream baos = new ByteArrayOutputStream();
              DataOutputStream dos = new DataOutputStream(baos);
              try {
                     dos.writeDouble(Math.random());     //写
                     dos.writeBoolean(true);
                     //读
                     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                     DataInputStream dis = new DataInputStream(bais);
                     System.out.println(bais.available());
                     System.out.println(dis.readDouble());
                     System.out.println(dis.readBoolean());
                    
                     dos.close();
                     dis.close();
              } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
}
/*
9
0.6320193774599024
true
 */

8.转换流

package com.io;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 将输入的字符进行输出（阻塞式）
 * 使用转换流InputStreamReader将输入的InputStream转换为Reader
 * 然后使用处理缓冲流BufferedReader成行读取
 * */
public class TestTransForm {
       public static void main(String[] args) {
 
              String s = null;
              InputStreamReader isr = new InputStreamReader(System.in);
              BufferedReader br = new BufferedReader(isr);
 
              try {
                     s = br.readLine();
                     while (s != null) {
                            System.out.println(s);
                            s = br.readLine();
                     }
                     isr.close();
                     br.close();
              } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
 
       }
}

9.Print流 

将原来在命令行显示的数据重定向输入到文件中。

package com.io;
 
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Date;
 
public class TestPrintWriter {
       public static void main(String[] args) {
             
              String s = null;           //用于接收输入的一行
              //将输入的字节转换为字符、并使用缓存
              BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      
              try {
                     FileWriter fw = new FileWriter("d://log.txt",true);
                     PrintWriter log = new PrintWriter(fw);
                    
                     while((s=br.readLine())!=null) {
                            if(s.equals("exit")) break;
                            System.out.println(s.toUpperCase());
                            log.println("-------");
                            log.println(s);         //将s写入日志
                            log.flush();
                     }
                     log.println("======"+new Date());  //写入时间
                     log.flush();                      //清空缓存
                     log.close();
              } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
}
/*
 控制台:
 wqer
WQER
123hello
123HELLO
exit
 
log.txt:
-------
wqer
-------
123hello
======Thu Jan 25 10:40:56 CST 2018
*/

10.Object流

直接将Object写入或读出

       Transient关键字  使该字段不被序列化

       Serializable标记接口，不包括任何方法，将对象转换成一个字节序列不想

       Externalizable接口可通过实现此接口代替实现Serializable接口来对序列化过程进行控制。

package com.io;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
public class TestObjectIO {
 
       public static void main(String[] args) {
 
              T1 t = new T1();
              t.i=11;
              t.k = 8;
 
              try {
                     // 写
                     FileOutputStream fos = new FileOutputStream("d://ObjectIO.dat");
                     ObjectOutputStream oos = new ObjectOutputStream(fos);
                     oos.writeObject(t);
                     oos.flush();
                     oos.close();
                     // 读
                     FileInputStream fis = new FileInputStream("d://ObjectIO.dat");
                     ObjectInputStream ois = new ObjectInputStream(fis);
                     T1 tReaded = (T1) ois.readObject();
                     System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
              } catch (IOException | ClassNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
 
       }
}
 
class T1 implements Serializable { // 标记接口，不包括任何方法，将对象转换成一个字节序列
       int i = 10;
       int j = 2;
       double d = 2.3;
       transient int k = 23;   //瞬时关键字使该字段不被序列化
}
 
/*输出：
11 2 2.3 0
 * */

11.总结 

InputStream/OutputStream抽象类

Reader/Writer抽象类

 

FileInputStream/FileOutputStream

FileReader/FileWriter

 

BufferedInputStream/BufferedOutputStream

BufferedReader/BufferedWriter

 

ByteArrayInputStream/ByteArrayOutputStream

 

InputStreamReader/OutputStreamWriter

 

DataInputStream/DataOutputStream

 

PrintStream/PrintWriter

 

ObjectInputStream/ObjectOutputStream