Java對IO的操作

聲明:來自尚學黨馬老師的教程代碼

節點流類型(一根管直接插到下面的類型上,下面的管道指的是線程和線和之間的通訊) 
 

類型	字符流	字節流
File	FileReader	FileInputStream
	FileWriter	FileOutputStream
Memory Array	CharArrayReader	ByteArrayInputStream
	CharArrayWriter	ByteArrayOutputStream
Memory String	StringReader
	StringWriter
Pipe(管道)	PipedReader	PipedInputStream
	PipedWriter	PipedOutputStream

 

緩衝流要"套接"在相應的節點流之上,對讀寫的數據提供了緩衝的功能,提高了讀寫的效
對於輸出的緩衝流,寫出的數據會先在內存中緩存,使用flush方法將會使內在中的數據立刻寫出

 

轉換流
InputStreamReader和OutputStreamWriter用與字節數據到字符數據之間的轉換
InputStreamReader需要和InputStream"套接"
OutputStreamReader需要和OutputStream"套接"

/**
 * 程序輸出的時候會有亂碼,原因是因爲read()方法讀取一個字節,中文字符
 * 是由兩個字節構成,取一個字節(字符的一半)就轉成一個字符,所以輸出就會是亂碼
 * @author DaHai
 *
 */
 public class TestFileInputStream{
     public static void main(String args[]){
             int b = 0;
             FileInputStream in = null;
             try{
                 in = new FileInputStream("c:\\TestFileInputStream.java");
             }catch(FileNotFoundException e){
                 System.out.println("找不到指定的文件");
                //終止當前正在運行的 Java 虛擬機。參數用作狀態碼；根據慣例，非零的狀態碼錶示異常終止。 
                System.exit(-1);    
            }
            try{
                long num = 0;
                //只有讀到文件的結尾才爲-1
                while((b=in.read())!=-1){
                    System.out.print((char)b);
                    num++;    
                }
                in.close();
                System.out.println();
                System.out.println("共讀取了"+ num +"個字節");
            }catch(IOException e){
                System.out.println("文件讀取錯誤");
                System.exit(-1);
            }
        }
}

import java.io.*;
 public class TestFileOutputStream{
     public static void main(String args[]){
         int b = 0;
         FileInputStream in = null;
         FileOutputStream out = null;
         try{
             in = new FileInputStream("c:\\TestFileInputStream.java");
             //如果這個時候C盤下面還沒有Test.java,那麼new FileOutputStream會創建一個空的Test.java文件,但不會創建目錄
             out = new FileOutputStream("c:\\Test.java");
            while((b = in.read())!=-1){
                    out.write(b);
            }
            in.close();
            out.close();
        }catch(FileNotFoundException e){
            System.out.println("找不到指定文件");
            System.exit(-1);
        }catch(IOException e){
            System.out.println("文件複製錯誤");
            System.exit(-1);
        }
        System.out.println("文件已複製");
    }
}

從文件裏讀取字符數據

import java.io.*;
 public class TestFileReader{
     public static void main(String args[]){
         FileReader fr = null;
         int c = 0;
         try{
             fr = new FileReader("c:\\TestFileReader.java");
             while((c = fr.read())!=-1){
                 System.out.print((char)c);
            }
        }catch(FileNotFoundException e){
            System.out.println("系統找不到指定的文件");
        }catch(IOException e){
            System.out.println("文件讀取錯誤");
        }
    }
}

向文件裏寫字符數據

import java.io.*;
public class TestFileWriter{
    public static void main(String args[]){
        FileWriter fw = null;
        int b = 0;
        try{
            fw = new FileWriter("c:\\Unicode.dat");
            for(int i=0;i);
        }
    }
}

帶緩衝區功能的輸入流

import java.io.*;
public class TestBufferStream{
    public static void main(String args[]){
        try{
        	//一個字節的輸入流並且不帶緩衝區
            FileInputStream fis = new FileInputStream("c:\\TestFileInputStream.java");
            //相當於在上面的fis流上又套了一層管道,實際上讀取的是一樣的數據,但是它有了帶緩衝區的功能
            BufferedInputStream bis = new BufferedInputStream(fis);
            int c = 0;
            System.out.println(bis.read());
            System.out.println(bis.read());
            //mark一個標記,從第100個開始往外讀
            bis.mark(100);
            for(int i=0;i<10 && (c=bis.read())!=-1;i++){
                System.out.print((char)c+" ");
            }
            System.out.println();
            //重置到上面的mark處
            bis.reset();
            for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
                System.out.print((char)c+" ");    
            }
            bis.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

import java.io.*;

public class TestBufferStream {
	public static void main(String args[]) {
		try {
			//在FileWriter寫出一個字符外面套層BufferedWriter管道
			BufferedWriter bw = new BufferedWriter(new FileWriter("c:\\write.txt"));
			BufferedReader br = new BufferedReader(new FileReader("c:\\write.txt"));
			String s = null;
			for (int i = 0; i <= 100; i++) {
				s = String.valueOf(Math.random());
				bw.write(s);
				bw.newLine();
			}
			bw.flush();
			// readLine()方法爲讀一行數據
			while ((s = br.readLine()) != null) {
				System.out.println(s);
			}
			bw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("讀取文件出錯");
		}
	}
}

import java.io.*;
public class TestTransForm2{
    public static void main(String args[]){
        //等待從鍵盤的輸入,System.in可以理解爲一根管道直接插在了鍵盤上
    	//System.in字節流輸入一個字節,外面套層InputStreamReader轉換流
        InputStreamReader isr = new InputStreamReader(System.in);
        //isr轉換流的外面又套層緩衝流,爲了使用下面的readLine()方法,可以記取一行
        BufferedReader br = new BufferedReader(isr);
        String s = null;
        try{
            s = br.readLine();
            while(s!=null){
                if(s.equalsIgnoreCase("exit")) break;
                System.out.println(s.toUpperCase());
                s = br.readLine();
            }
            br.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

import java.io.*;
 public class TestDataStream {
   public static void main(String[] args) {
       //在內存中定義了一個空間,同時一根管道插在了上面
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    //DataOutputStream直接寫基礎數據類型(boolean,double等),而且可以寫UTF-8(省空間,網絡上常用)
    DataOutputStream dos = new DataOutputStream(baos);
    try {
      dos.writeDouble(Math.random());
      dos.writeBoolean(true);
      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();
    }
  }
}

import java.io.*;
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;}
    }
  }
}

import java.io.*;
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("無法讀取文件");
    }
  }
}

import java.util.*; 
import java.io.*;
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); 
      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();
    }
  }
}

import java.io.*;

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);
   }
}

/**序列化
 *1.一個Object直接轉換成爲字節流寫到硬盤或網絡上去
 *2.標記作用
 *3.裏面沒有任何方法,給JDK看,JDK看到它就知道可以序列化了
 *4.直接實現這個接口,是JKD幫你控制這個對象
 *5.把一個對象直接寫到硬或網絡上應當把它序列化成一個字節流必須實現這個接口
 */
class T implements Serializable
{
    int i = 10;
    int j = 9;
    double d = 2.3;
    int k = 15;
    //transient透明的,它修飾的成員變量在序列化的時候不予考慮
    //transient int k = 15;  直行的時候,k爲0
}