Day24-C:\Users\Lenovo\Desktop\note\code\JavaSE\Basic\src\com\InOut

字符流

適合讀寫文本文件的內容

FileReader

把文件（磁盤或網絡）中的數據以字符的形式讀取到內存中

package Basic.src.com.InOut.FileReaderWriter;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;

public class FileReaderTest1 {
    public static void main(String[] args) throws Exception {
        try (
                //創建一個文件字符輸入流管道與源文件接通
             Reader fr = new FileReader("Basic\\src\\com\\InOut\\FileReaderWriter\\itheima01.txt");
             ){
//            //2、讀取文本文件的內容
//            int c;
//            while ((c = fr.read()) != -1) {//read返回的是int
//                System.out.print((char)c);
//            }
            //3、每次讀取多個字符
            char[] buffer = new char[3];
            int len;
            while((len = fr.read(buffer))!= -1) {
                String str = new String(buffer, 0, len);
                System.out.print(str);
            }
            //性能是比較不錯的！
        } catch (Exception e) {
            e.printStackTrace();;
        }
    }
}

FileWriter

字符輸出流寫出數據之后，必須刷新流或者關閉流，寫出去的數據才能生效

package Basic.src.com.InOut.FileReaderWriter;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterTest2 {
    public static void main(String[] args) throws IOException {
        try (
                //0、創建一個文字字符輸出流管道與目標文件接通
                //Writer fw = new FileWriter("Basic/src/itheima02out.txt");//是覆蓋管道
                Writer fw = new FileWriter("Basic/src/itheima02out.txt",true);//是追加管道
                ){
            //1、寫一個字符出去
            fw.write('a');
            fw.write(97);
            fw.write('磊');//寫一個字符出去
            fw.write("\r\n");//換行

            //2、寫一個字符串出去
            fw.write("我愛你中國abc");
            fw.write("\r\n");//換行

            //3、寫字符串的一部分出去
            fw.write("我愛你中國abc",0,5);
            fw.write("\r\n");//換行

            //4、寫一個字符數組出去
            char[] buffer = {'黑','馬','a','b','c'};
            fw.write(buffer);
            fw.write("\r\n");//換行

            //5、寫字符數組的一部分出去
            fw.write(buffer,0,2);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }


    }
}

package Basic.src.com.InOut.FileReaderWriter;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterTest3 {
    public static void main(String[] args) throws IOException {
        Writer fw = new FileWriter("Basic/src/itheima03out.txt" );

        //字符輸出流寫出數據之后，必須刷新流或者關閉流，寫出去的數據才能生效
        //字符輸出流運行時會在內存里面新建一個緩沖區，直到數據拷貝結束后再將緩沖區內數據一次性寫到文件中去
        // 但是仍然會創造這個文件出來
        //寫字符數據出去
        fw.write('a');
        fw.write('b');
        fw.write('c');
        fw.write('d');
        fw.write("\r\n");

        fw.write("我愛你中國");
        fw.write("\r\n");
        fw.write("我愛你中國");

//        fw.flush();//刷新流，刷新完會將緩沖區的數據同步到文件中
//        fw.write("張三");
//        fw.flush();

        fw.close();//關閉流包含刷新操作，但后續無法繼續使用
    }
}

緩沖流

對原始流進行包裝，以提高原始流讀寫數據的性能

在內存區創建一個緩存區（8KB)，直接從內存中讀取

package Basic.src.com.InOut.BufferStream;

import java.io.*;

public class BufferedInputStreamTest1 {
    public static void main(String[] args) throws IOException {
        try (
                InputStream is = new FileInputStream("Basic/src/itheima01.txt");
                //1.定義一個字節緩沖輸入流
                InputStream bis = new BufferedInputStream(is);
             OutputStream os = new FileOutputStream("Basic/src/itheima01_bak.txt");
             //2.定義一個字節緩沖輸出流包裝原始的字節流
                OutputStream bos = new BufferedOutputStream(os,8192*2);
             ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            System.out.println("復制完成");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

package Basic.src.com.InOut.BufferStream;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class BufferedReaderTest2 {
    public static void main(String[] args) throws IOException {
        try (
                Reader fr = new FileReader("Basic/src/itheima04.txt");
                //創建一個字符緩存輸入流包裝原本的輸入流
                BufferedReader bfr  = new BufferedReader(fr);
                ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = bfr.read(buffer)) != -1) {
//                System.out.print(new String(buffer,0,len));
//            }
//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine());//null
            String line;
            while ((line = bfr.readLine()) != null) {
                System.out.println(line);
            }


        } catch (IOException e) {
           e.printStackTrace();
        }
    }
}

字節數組理論上越大越好，但是一定程度之后就不明顯，且有可能占用太多內存，一般32KB是巔峰

如果代碼編碼和被讀取的文件編碼不一致，使用字符流讀取文件時就會出現亂碼

字符輸入轉換流

package Basic.src.com.InOut.BufferStream;

import java.io.*;

public class Test2 {
    public static void main(String[] args) throws IOException
    {

        try (
                //1.得到文件的原始字節流（GBK形式）
                InputStream is = new FileInputStream("Basic\\src\\itheima06.txt");
                //2.把原始的字節輸入流按照指定的字符集編碼轉換成字符輸入流
                Reader isr = new InputStreamReader(is,"GBK");
                //3.把字符輸入流包裝成緩沖字符輸入流
                BufferedReader br = new BufferedReader(isr)
        ){
            String line;
            while ((line = br.readLine()) != null)
            {
                System.out.println(line);
            }

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

package Basic.src.com.InOut.BufferStream;

import java.io.*;

public class OutputStreamReaderTest3 {
    /*
    掌握字符輸出轉換流
     */
    public static void main(String[] args) throws IOException {
        try (
                //指定寫出去的字符編碼
                //1.創建一個文件字節輸出流
                OutputStream os = new FileOutputStream("Basic/src/itheima07Out.txt");
                //2.把原始的字節輸出流按照指定的字符集編碼輸出轉換流
                Writer osw = new OutputStreamWriter(os,"GBK");
                //把字符輸出流再包裝成緩沖字符流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中國人abc");
            bw.write("我愛你中國123");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

打印流

打印流實現更方便更高效的方法，能實現打印啥出去就是啥出去

package Basic.src.com.InOut.PrintStream;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;

public class PrintTest1 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        try (
                //1.創建一個打印流管道
                PrintStream ps = new PrintStream("Basic/src/itheima08.txt","GBK");
                ){
            ps.print(97);//打印后自動換行
            ps.print('a');
            ps.print("我愛你中國abc");
            ps.print(true);
            ps.print(99.5);

            ps.write(97);//a
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

重定向

package Basic.src.com.InOut.PrintStream;

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class PrintTest2 {
    public static void main(String[] args) {

        try(
                PrintStream ps = new PrintStream("Basic/src/itheima09.txt");
                ) {
            System.setOut(ps);//重定向
            System.out.println("老驥伏櫪");
            System.out.println("志在千里");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }
}

數據流

package Basic.src.com.InOut.DataStream;

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

public class DataOutputStreamTest1 {
    public static void main(String[] args) throws IOException {
        try (
                //1.創建一個數據輸出流包裝低級的字節輸出流
                DataOutputStream dos = new DataOutputStream(new FileOutputStream("Basic/src/itheima10out.txt"));
                //輸出的還包含了編碼類型，沒辦法直接讀取，可以通過DataInputStream讀取
                ){
           dos.writeInt(97);
           dos.writeDouble(99.5);
           dos.writeBoolean(true);
           dos.writeUTF("黑馬程序員666！");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

package Basic.src.com.InOut.DataStream;

import java.io.*;

/*
使用數據輸入流讀取特定類型的數據
 */
public class DataInputStreamTest2 {
    public static void main(String[] args) throws IOException {
        try (
                DataInputStream dis = new DataInputStream(new FileInputStream("Basic/src/itheima10out.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);
            
            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);
            
            String rs = dis.readUTF();
            System.out.println(rs);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

序列化流

對象序列化：把Java對象寫入到文件當中去

對象反序列化：把文件的Java對象讀出來

package Basic.src.com.InOut.ObjectStream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
目標：掌握對象字節輸出流的使用：序列化對象
 */
public class Test1ObjectOutputStream {
    public static void main(String[] args) {
        try(
                //2.創建一個對象字節輸出流包裝原始的字節輸出流
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Basic/src/itheima11out.txt"));
                ) {
            //1.創建一個java對象
            User u= new User("admin","張三",32,"6156321");
            //3.序列化對象到文件在去
            //對象如果需要序列化，必須實現序列化接口implements Serializable是序列化的前提
            //存入之后無法直接讀取
            oos.writeObject(u);
            System.out.println("序列化對象成功！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

package Basic.src.com.InOut.ObjectStream;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Test2ObjectInputStream {
    public static void main(String[] args) throws ClassNotFoundException {
        try(
                //1.創建一個對象字節輸入流管道，包裝低級的字節輸入流與源文件接通
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Basic/src/itheima11out.txt"));
                ) {
            User u = (User) ois.readObject();
            System.out.println(u);
            //private transient String password;//加上transient之后，這個變量將不參與序列化
            //User{loginName='admin', userName='張三', age=32, password='null'}
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

可以將多個對象存儲到ArrayList中去，然后直接對集合進行序列化即可

ArrayList已經實現了序列化接口

框架

框架的形式：一般是把類、接口等編譯為class形式，再壓縮成一個jar結尾的文件發行出去。

package Basic.src.com.libTest;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class CommonIOTest1 {
    public static void main(String[] args) throws IOException {
        FileUtils.copyFile(new File("Basic/src/itheima01.txt"),new File("Basic/src/a.txt"));
        FileUtils.copyDirectory(new File("F:\\碩士階段\\Java\\測試文件夾"),new File("F:\\碩士階段\\Java\\測試文件夾(存儲用)"));
        FileUtils.deleteDirectory(new File("F:\\碩士階段\\Java\\測試文件夾（）存儲用"));//可以刪除非空文件夾

        //Files.copy(Path.of("Basic\\src\\itheima01.txt"),Path.of("Basic\\src\\b.txt"))在java11中出現
        //System.out.println(Files.readString(Path.of("C:\\Users\\Lenovo\\Desktop\\note\\code\\JavaSE\\Basic\\src\\itheima01.txt")));//也是java11
    }
}

posted @ 2025-10-27 20:35 David大胃閱讀(5) 評論(0) 收藏舉報

刷新頁面返回頂部

David0919