IO流——常用IO流詳解

1：字節流

　　字節流：用於處理以字節為單位的二進制文件（如音樂，圖片等）

　　InputStream 是抽象類 它的對應子類FileInputStream可以被實例化

　　構造方法：

             FileInputStream常用構造方法：

                 FileInputStream(File file) ：通過File對象創建FileInputStream對象。                                             

            FileInputStream(String name) ：通過文件（非“目錄”）路徑創建FileInputStream對象。

　　常用方法：

            int read()：從輸入流中讀取單個字節的數據；如果已到達文件末尾，則返回 -1。

            int read(byte[] b)：從輸入流中將最多b.length個字節的數據讀入一個byte數組中，以整數形 式返回存入數組中的實際字節個數；如果已到達文件末尾，則返回 -1。                           void close()：關閉此文件輸入流並釋放與此流有關的所有系統資源

OutputStream是抽象類，它的子類FileOutputStream可以被實例化

　　構造方法：　　　

                            FileOutputStream(File file) ：通過File對象創建FileOutputStream對象。                                       

                               FileOutputStream(String name) ：通過文件（非“目錄”）路徑創建 FileOutputStream對象。 

                               FileOutputStream(File file, boolean append)：通過File對象創建 FileOutputStream對象；第二個參數如果為true ，則字節將被寫入文件的末尾而不是開頭

　　常用方法：

           FileOutputStream常用方法： 

                          void write(int b)：將指定的單個字節數據寫入此文件輸出流。

                            void write(byte[] b, int off, int len)：將byte數組中從off開始的len個字節寫入此文件輸出流。

                             void flush()：刷新字節輸出流並強制寫出緩沖內所有字節數據。

                             void close()：關閉此文件輸出流並釋放與此流有關的所有系統資源。

package com.xt.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileInputStreamTest {

    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            /**
             * 讀和寫都是站在程序的角度來看的，讀文件用FileInputStream  寫文件用FileOutPutStream
             */
            fis=new FileInputStream("C:\\中心.jpg");
            fos=new FileOutputStream("D:\\重要.jpg");
            //第一種方法：一個字節一個字節的讀
            /*int date;
            while((date=fis.read())!=-1) {
                System.out.println(date);
            }*/
            //第二種方法：1024個字節1024個字節的讀
            byte[] bufferDate=new byte[1024];
            int length;
            while((length=fis.read(bufferDate))!=-1) {
                fos.write(bufferDate, 0, length);
            }
            fos.flush();//強制全部讀出來所有的數據
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //釋放資源
            if(fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            
            if(fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

          1.1：緩沖字節流

　　緩沖輸入流：BufferedInputStream      BufferedInputStream(InputStream in)：

　　緩沖輸出流：BufferedOutputStream  BufferedOutputStream(OutputStream out)

package com.xt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferInputStreamTest {

    public static void main(String[] args) {
        try {
            BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("C:\\中心.jpg"));
            BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("D:\\重要k.jpg"));
        
            /*int b;
            while((b=bufferedInputStream.read())!=-1) {
                bufferedOutputStream.write(b);
            }*/
            
            byte[] bufferByte=new byte[1024];
            int length;
            while((length=bufferedInputStream.read(bufferByte))!=-1) {
                bufferedOutputStream.write(bufferByte, 0, length);
            }
            bufferedOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 

 

2：字符流

    Reader是抽象類，它的子類FileReader 可以被實例化

　　構造方法：　　　

              FileReader常用構造方法： FileReader(File file) ：通過File對象創建FileReader對象。

　　　　　　　　　　　　　　　　 FileReader(String fileName) ：通過文件（非“目錄”）路徑創建FileReader對象。

 

　　常用方法：

　　　　　　　　FileReader常用方法： int read()：從輸入流中讀取單個字符的數據，如果已到達流的末尾，則返回 -1 。

　　　　　　　　　　　　　　　　　　 int read(char[] cbuf)：從輸入流中將最多cbuf.length個字符的數據讀入一個char數組中，以整數形式返回存入

　　　　　　　　　　　　　　　　　　　　　　　數組中的實際字節個數，如果已到達流的末尾，則返回 -1 。

　　　　　　　　　　　　　　　　　　 void close()：關閉此文件輸入流並釋放與此流有關的所有系統資源。

　　Writer是抽象類，它的子類FileWriter可以被實例化

　　構造方法：

 

　　　　　　FileWriter(File file) ：通過File對象創建FileWriter對象。

　　　　　　　　　　　　FileWriter(String fileName) ：通過文件（非“目錄”）路徑創建FileWriter對象。

　　　　　　　　　　　　 FileWriter(File file, boolean append)：通過File對象創建FileWriter對象；第二個參數如果為true ，則字節將被寫入文件的末尾而不是開頭。

 

　　常用方法：

 

　　　　　　void write(int c)：將指定的單個字符數據寫入此文件輸出流。

　　　　　　 void write(char[] cbuf, int off, int len)：將char數組中從off開始的len個字符寫入此文件輸出流。

　　　　　　　　void flush()：刷新字符輸出流緩沖。

　　　　　　 void close()：關閉此文件輸出流並釋放與此流有關的所有系統資源。

package com.xt.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

class FileReaderAndFileWriter {

    public static void main(String[] args) {
        Reader reader=null;
        Writer writer=null;
        try {
            reader=new FileReader("C:\\unintall.log");
            writer=new FileWriter("D:\\unintall.log");
            
            char[] buffer=new char[1024];
            int length;
            while((length=reader.read(buffer))!=-1) {
                writer.write(buffer, 0, length);
            }
            writer.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                if(writer!=null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(reader!=null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        
    }
}

 

 

2.1：緩沖字符流

　　BufferedReader:緩沖字符輸入流      BufferedReader(Reader in)：

　　BufferedWriter :緩沖字符輸出流 BufferedWriter(Writer out)

package com.xt.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferReaderTest {

    public static void main(String[] args) {
        try {
            BufferedReader bufferedReader =new BufferedReader(new FileReader("C:\\unintall.log"));
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\unintall.log"));
            
            //第一種方法
//            int date;
//            while((date=bufferedReader.read())!=-1) {
//                bufferedWriter.write(date);
//            }
//            bufferedWriter.flush();
//            
//            
            //第二種方法
            char[] bufferDate=new char[1024];
            int length;
            while((length=bufferedReader.read(bufferDate))!=-1) {
                bufferedWriter.write(bufferDate, 0, length);
            }
            bufferedWriter.flush();
            
            
            //第三種方法
//            String lineDate;
//            while((lineDate=bufferedReader.readLine())!=null) {
//                bufferedWriter.write(lineDate);
//                bufferedWriter.newLine();
//            }
//            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

3:轉換流

轉化只能是字節向字符轉化

　　InputStreamReader(Reader in)　　

　　OutputStreamWriter(Writer out)

因為InputStreamReader是Reader的子類，所以同樣可以用緩沖字符流BufferedReader(new InputStreamReader(Reader in))

t同理

package com.xt.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class InputStreamReaderTest {

    public static void main(String[] args) {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\aa.txt"),"UTF-8"));
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\bb.txt"), "UTF-8"));
            String lineDate;
            while((lineDate=bufferedReader.readLine())!=null) {
                bufferedWriter.write(lineDate);
                bufferedWriter.newLine();
            }
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

 

 

數據流

 

package com.xt.io;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataInputStreamTest {

    public static void main(String[] args) {
        double[] scores = {20,50,42,62};
        DataOutputStream dataOutputStream=null ;
        try {
            dataOutputStream = new DataOutputStream(new FileOutputStream("D:\\data.data")) ;
            for (double score : scores) {
                dataOutputStream.writeDouble(score);
            }
            dataOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(dataOutputStream!=null) {
                try {
                    dataOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        
        try {
            DataInputStream dataInputStream=new DataInputStream(new FileInputStream("D:\\data.data"));
            while(true) {
                System.out.println(dataInputStream.readDouble());
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }catch(Exception e) {
            
        }
    }
}