Java基礎知識學習——I/O流

知識點彙總

流：1.操作數據單位：字節流、字符流
2.數據的流向：輸入流、輸出流
3.流的角色：節點流、處理流
流的結構：
抽象基類：InputStream、OutputStream、Reader、Writer。
節點流/文件流：FileInputStream、FileOutputStream、FileReader FileWriter。
緩衝流(處理流)：BufferedInputStream、BufferedOutputStream、
BufferedReader、BufferedWriter。
注意：對於文本文件使用字符流去處理；對於非文本文件使用字節流去處理。
代碼示例：

public class FileIOTest {
    public static void main(String[] args) throws IOException {
        //實例化File類的對象
        File file=new File("Day18\\hi.txt");
        System.out.println(file.getAbsoluteFile());
        //提供具體的字符流
        FileReader fileReader=new FileReader(file);
        //數據的讀入
        int flag=fileReader.read();
        while(flag!=-1){
            System.out.print((char) flag);
            flag=fileReader.read();
        }
        System.out.println();
        //流的關閉
        fileReader.close();
        /*
        * 使用read()的重載方法
        * */
        File file1=new File("Day18\\hello.txt");
        //提供具體的流
        FileReader fileReader1=new FileReader(file1);
        //數據的讀入
        char[] chars=new char[5];
        int len;
        while((len=fileReader1.read(chars))!=-1){
            //錯誤的寫法
//            for (int i = 0; i < chars.length; i++) {
//                System.out.println(chars[i]);
//            }
            //方式一：
//            for(int i=0;i<len;i++){
//                System.out.print(chars[i]);
//            }
            //方式二：
            String string=new String(chars,0,len);
            System.out.print(string);
        }
        //資源關閉
        fileReader1.close();
        System.out.println("讀出寫入");
        /*
        * 從內存寫出到指定文件中
        * 輸出操作：如果文件不存在會自動創建文件，如果存在會依據append:(true/false)選擇覆蓋文件還是追加
        *
        * */
        //提供File對象
        File file2=new File("Day18\\he.txt");
        //創建FileWriter的對象
        FileWriter fileWriter=new FileWriter(file2);
        //寫出數據
        fileWriter.write("I am Roy");
        fileWriter.write("hope regain powerful urge to learn");
        //關閉數據流
        fileWriter.close();
        //文件的讀取並輸出到文件中
        //1.創建輸出輸入文件對象
        File src=new File("Day18\\hello.txt");
        File dest=new File("Day18\\copy.txt");
        //2.創建輸入輸出流對象
        FileReader srcRead=new FileReader(src);
        FileWriter destWrite=new FileWriter(dest);
        //3.數據讀出和寫入
        char[] trans=new char[5];
        int size;
        while((size=srcRead.read(trans))!=-1){
             destWrite.write(trans,0,size);
        }
        //4.關閉數據流
        destWrite.close();
        srcRead.close();
        System.out.println("************************");

    }
}

知識點彙總二

1.FileInputStream和FileOutputStream的使用
2.緩衝流的使用：處理字節的BufferedInputStream、BufferedOutputStream，處理字符的BufferedReader、BufferedWriter
其作用是提高讀取和寫入的效率。

public class FileInputOutputTest {
    public static void main(String[] args) {
        //使用字節流處理文本文件可能會亂碼
        FileInputStream fis = null;
        try {
            //創建文件對象
            File file = new File("Day18\\hello.txt");
            //創建字節流
            fis = new FileInputStream(file);
            //讀取數據
            byte[] bytes = new byte[5];
            int size;
            while ((size = fis.read(bytes)) != -1) {
                String s = new String(bytes, 0, size);
                System.out.print(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //關閉數據流
            try {
                if(fis!=null)
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //緩衝流的示例
        BufferedInputStream bis= null;
        BufferedOutputStream bos= null;
        try {
            //創建文件對象
            File firstFile=new File("Day18\\copy.txt");
            File copyFile=new File("Day18\\copies.txt");
            //創建流
            //1.創建字節流
            FileInputStream in=new FileInputStream(firstFile);
            FileOutputStream out=new FileOutputStream(copyFile);
            //2.創建緩衝流
            bis = new BufferedInputStream(in);
            bos = new BufferedOutputStream(out);
            //實現數據的讀取
            byte[] buffer=new byte[10];
            int length;
            while ((length=bis.read(buffer))!=-1){
                bos.write(buffer,0,length);
            }
            System.out.println("copies.txt複製成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //關閉數據流(只關閉外層則內層會自動關閉)
            if(bis!=null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bos!=null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
    *@ClassName FileInputOutputTest
    *@Description 用字節流實現對文件的複製操作
    *@Param [srcPath, destPath]
    *@Return void
    *@Date 2020/2/9 13:00
    *@Author Roy
    */
    public void copyTest(String srcPath,String destPath){
        FileInputStream srcStream= null;
        FileOutputStream destStream= null;
        try {
            //創建file對象
            File srcFile=new File(srcPath);
            File destFile=new File(destPath);
            //創建字節流
            srcStream = new FileInputStream(srcFile);
            destStream = new FileOutputStream(destFile);
            //讀取字節
            byte[] trans=new byte[1024];
            int size;
            while ((size=srcStream.read(trans))!=-1){
                destStream.write(trans,0,size);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //關閉數據流
            try {
                if(srcStream!=null)
                srcStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(destStream!=null)
                destStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

知識點彙總三

轉換流的使用
1.轉換流：屬於字符流
InputSteamReader：將一個字節的輸入流轉換爲字符的輸入流。
OutputStreamWriter：將一個字符的輸出流轉換爲字節的輸出流。
作用是字節流和字符流之間的轉換。
代碼示例：

public class transferTest {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("Day18\\hello.txt");
        FileOutputStream fos=new FileOutputStream("Day18\\trans.txt");
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
        char[] buf=new char[10];
        int size;
        while((size=isr.read(buf))!=-1){
            osw.write(buf,0,size);
            String str=new String(buf,0,size);
            System.out.print(str);
        }
        isr.close();
        osw.close();
    }
}

其他流的使用示例：

public class filterTest {
    public static void main(String[] args) {
        /*
        * 1.標準的輸入輸出流
        * 1.1 System.in：標準的輸入流默認從鍵盤輸入
        *     System.out：標準的輸出流默認從控制檯輸出
        *1.2System類的setIn/setOut方式重新指定輸入輸入流
        * */
        BufferedReader bfr= null;
        try {
            InputStreamReader  isr=new InputStreamReader(System.in);
            bfr = new BufferedReader(isr);
            while(true){
                System.out.print("請輸入字符串：");
                String data=bfr.readLine();
                if("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
                    System.out.println("程序退出");
                    break;
                }
                String upStrings=data.toUpperCase();
                System.out.println(upStrings);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
       if(bfr!=null) {
           try {
               bfr.close();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
        }
   /*
   *打印流：實現將基本數據類型的數據格式轉化爲字符串輸出
   * PrintStream
   * PrintWriter
   *
   * */
        /*FileOutputStream fos=new FileOutputStream(new File("Day18\\print.txt"));
        PrintStream ps=new PrintStream(fos,true);
        if(ps!=null){//把標準輸出流（控制檯輸出）改成文件
            System.setOut(ps);
        }*/
        /*
        * 數據流：DataInputStream和DataOutputStream
        * 作用是用來讀取和寫出基本數據類型的變量和 字符串
        *
        * */
    }
}