java IO流

来源:https://www.cnblogs.com/rainaftersummert/archive/2023/05/23/17425644.html
-Advertisement-
Play Games

# Java IO流 ## 什麼是流？ 概念：記憶體和存儲設備之間傳輸數據的通道。 數據藉助流傳輸。 流分類： - 按照方向：輸入流（將存儲設備中的內容讀入到記憶體中）和輸出流（將記憶體中的內容寫入到存儲設備中） - 按照單位：位元組流（以位元組為單位，可以讀寫所有數據）和字元流（以字元為單位，只能讀取文本數 ...


Java IO流

什麼是流？

概念：記憶體和存儲設備之間傳輸數據的通道。

數據藉助流傳輸。

流分類：

  • 按照方向：輸入流（將存儲設備中的內容讀入到記憶體中）和輸出流（將記憶體中的內容寫入到存儲設備中）
  • 按照單位：位元組流（以位元組為單位，可以讀寫所有數據）和字元流（以字元為單位，只能讀取文本數據）
  • 按照功能：節點流（具有實際傳輸數據的讀寫功能）和過濾流（在節點流的基礎之上增強功能）

位元組流

位元組流的父類（抽象類）：

  • InputStream:位元組輸入流：提供一些如read()，close()的方法
  • OutputStream:位元組輸出流：提供一些如write()，close()的方法

文件位元組流

  • FileInputStream：文件位元組輸入流，繼承位元組輸入流
  • FileOutputStream:文件位元組輸出流，繼承位元組輸入流

文件位元組輸入流操作：

//創建FileInputStream並且指定文件路徑
FileInputStream fis = new FileInputStream("d:\\aa.txt");
int data = 0;
//read返回的int，當等於-1表示讀完了，如果是字元返回對應的asc碼
//一次讀取一個位元組
while ((data=fis.read())!=-1){
    System.out.println((char) data);
}
/*
a
b
c

什麼為一次讀取一個位元組的情況

當需要一次讀取多個位元組

//創建FileInputStream並且指定文件路徑
FileInputStream fis = new FileInputStream("d:\\aa.txt");
//一次讀取多個個位元組
byte[] buf = new byte[3];
//本處read返回實際讀取個數，讀完返回-1,並且將讀取到的存儲在buf中
//因為數組大小一次讀取三個
System.out.println(fis.read(buf));
System.out.println(new String(buf));
fis.close();
/*
3
abc
*/

//或者

FileInputStream fis = new FileInputStream("d:\\aa.txt");
        byte[] buf = new byte[3];
        int count=0;
        while ((count=fis.read(buf))!=-1){
         System.out.println(new String(buf,0,count));
        }
        fis.close();
/*
abc
def
g

本處只是例子，實際操作時緩衝區數組不需要創建得太小，可以是1024以上

文件位元組輸出流操作：

//創建文件位元組輸出流，為true代表文件已經存在時追加，false每次都會覆蓋（預設）
FileOutputStream fos=new FileOutputStream("d://aa.txt",false);
fos.write(97);
fos.write('b');
fos.write('c');

//文件中:abc

//要寫入字元串：轉成byte數組
String s = "helloworld";
fos.write(s.getBytes());

//文件中:abchelloworld

實現複製操作：

FileInputStream fis = new FileInputStream("d:\\aa.txt");
FileOutputStream fos = new FileOutputStream("d:\\bb.txt");
byte[] buf = new byte[1024];
int count=0;
while ((count=fis.read(buf))!=-1){
    fos.write(buf,0,count);
}
fis.close();
fos.close();

位元組緩衝流

  • 緩衝流：BufferedInputStream/BufferedOutputStream
  • 繼承了過濾流（FilterOutputStream/FilterInputStream）,而過濾流又繼承了文件位元組流
  • 內置了緩存區（8k）
  • 作用：提高IO效率，減少訪問磁碟次數；數據存儲在緩存區，flush是將緩衝區的內容寫入文件中，也可以直接close，後面實現緩衝區的類類似

位元組輸入緩衝流：

//        創建BufferedInputStream,需要傳入一個底層流
        FileInputStream fis = new FileInputStream("d:\\aa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
//        讀取:類似，但是這個有緩衝區效率更高
        int data = 0;
        while ((data=bis.read())!=-1){
            System.out.print((char)data);
        }
        //當然也可以和文件位元組流一樣，直接再創建一個緩衝區實現，一模一樣但是因為內部緩衝區的存在效率更高
        
//        關閉這一個就行
        bis.close();

//out:abchelloworld

位元組輸出緩衝流：

FileOutputStream fos = new FileOutputStream("d://bb.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//轉義符如換行等也可以寫入也可以
String s = "hello\r\n";
bos.write(s.getBytes());//這是寫入了緩衝區，沒有寫入文件
bos.flush();//需要刷新才能從緩衝區真正寫入文件
bos.close();//當然close時自動flush

對象流

  • 對象流：ObjectOutputStream/ObjectInputStream
  • 可以實現寫入或者讀取對象
  • 增強了緩衝區功能
  • 增強了讀寫8種基本數據類型和字元串的功能，不只是能讀寫int和byte
  • readObject()從流中讀取一個對象；writeObject(Object obj)向流中寫入一個對象
  • 使用流傳輸對象的過程被稱為序列化（寫入）和反序列化（讀取）
  • 繼承文件位元組流，需要基於其才能創建
  • 序列化和反序列化的對象類都必須實現Serializable介面（該介面本身沒有任何方法僅僅標誌該類可以序列化）,而且其中關聯的其他類也要實現該介面
  • 可以在類中自定義生成常量private static final long serialVersionUID ，該常量為序列化版本號用來標識該類，即使是同一個類如果UID不同依舊被認為不是同一個類無法反序列化不同UID的類
  • 使用transient修飾實現，表示該屬性不需要序列化（例如：private transient int age ）
  • 靜態屬性不能序列化

序列化：

public class  Student  implements Serializable {}



//main:
FileOutputStream fos = new FileOutputStream("d://aa.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
//        序列化
        Student student = new Student();
        oos.writeObject(student);
//        oos.writeBoolean();寫入boolean
//         oos.writeBytes("hellow");//寫入字元串
//        其他基本類型也有相應的辦法寫入
        oos.close();

反序列化：

FileInputStream fis = new FileInputStream("d://aa.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
//讀取存入的第一個對象
Student s = (Student)ois.readObject();
ois.close();

序列化、反序列化多個對象時可以使用集合：

//序列化 
FileOutputStream fos = new FileOutputStream("d://aa.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
//        序列化
        Student student = new Student();
        Student student1 = new Student();
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student1);
        oos.writeObject(arrayList);
        oos.close();

//反序列化
FileInputStream fis = new FileInputStream("d://aa.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        ArrayList<Student> arrayList = (ArrayList<Student>) ois.readObject();
        ois.close();

常見字元編碼

字元流

問題的引出：

FileInputStream fis = new FileInputStream("d://aa.txt");
int data = 0;
while ((data=fis.read())!=-1){
    System.out.println((char)data);
}
fis.close();
//上述代碼當我們讀取的文件中為中文時得到亂碼。
//原因：我們是運用位元組流一個一個位元組讀取文件，而本處的文件編碼方式是utf-8（中文常見的編碼方式），每個中文字占3個位元組。當一個一個位元組讀取時出現亂碼

這種情況下我們需要字元流

字元流的父類（抽象類）：

Reader（字元輸入流）和Writer（字元輸出流）

只能用於文本文件

文件字元流

  • FileReader和FileWriter
  • 父類是InputStreamReader和OutputStreamWriter,而這兩者的父類又是Reader和Writer
  • 採用預設字元編碼

FileReader：

FileReader fr = new FileReader("d://aa.txt");
       //單個字元的讀取
//        int data = 0;
//        while ((data=fr.read())!=-1){//讀取一個字元
//            System.out.println((char)data);
//        }
//創建緩衝區讀取
//緩衝區為2字元
        char[] buf = new char[2];
        int count = 0;
        while ((count = fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        fr.close();
/*out:
你好
呀

FileWriter：

FileWriter fw = new FileWriter("d://aa.txt");
fw.write("你好嗎");
fw.flush();
fw.close();

字元緩衝流

  • 緩衝流：BufferedReader/BufferedWriter
  • 高效讀寫
  • 支持輸入換行符
  • 可以一次寫一行、讀一行
  • 可以指定緩衝區大小，也可以預設（8K）
  • 新建需要基礎字元流（文件字元流）
  • 繼承Reader和Writer

讀取：

FileReader fr = new FileReader("d://aa.txt");
       BufferedReader br = new BufferedReader(fr);
//        和上面其他類類似的方法不再重寫
//        特有的：讀一行，末尾返回null
        String s = null;
        //一行一行的讀取
        while ((s=br.readLine())!=null){
            System.out.println(s);
        }
        br.close();
//out：你好呀

寫入：

      FileWriter fw = new FileWriter("d:\\aa.txt");
      BufferedWriter bw = new BufferedWriter(fw);
//      寫入
        bw.write("好好學習");
//        寫入一個換行windows:\r\n linux:\n
        bw.newLine();
        bw.write(",天天向上");
        bw.close();
/*文件：
好好學習
,天天向上

列印流

  • PrintWriter:

    • 支持print()/println(),支持寫入後換行
    • 支持數據原樣列印
    • 繼承Writer類
    • 類似PrintStream，但是PrintWriter只能列印字元流，而PrintStream可以列印位元組流
     PrintWriter pw = new PrintWriter("d://aa.txt");
//      列印並且換行
        pw.println(97);
        pw.println(true);
//列印
        pw.print("a");
		pw.print("b");
        pw.close();
/*文件中：
97
true
ab

轉換流

  • 也叫橋轉換流：InputStreamReader/OutputStreamWriter
  • 可以將位元組流轉換為字元流
  • 可設置字元的編碼方式
  • 繼承字元流Reader/Writer
  • 創建時需要基本的文件字元流

InputStreamReader:

FileInputStream fis = new FileInputStream("d://aa.txt");
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
int data=0;
//一個一個字元讀取
while ((data=isr.read())!=-1){
    System.out.print((char)data);
}
isr.close();

OutputStreamWriter：

FileOutputStream fos = new FileOutputStream("d://aa.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
for(int i=0;i<10;i++){
    osw.write("我愛中國\r\n");
    osw.flush();
}
osw.close();

File類

  • 概念：代表物理盤符中的一個文件或者文件夾

//        分隔符
        System.out.println("路徑分割符"+File.pathSeparator);
        System.out.println("名字分割符"+File.separator);

        File file = new File("d://cc.txt");
//        判斷文件是否存在
        if(!file.exists()){
//            創建文件
            boolean b = file.createNewFile();
            System.out.println("創建結果:"+b);
        }
       if(file.exists()) {
//           直接刪除
           System.out.println("刪除結果" + file.delete());
           //使用jvm退出時刪除
           file.deleteOnExit();
       }
//       獲取文件信息
        System.out.println("絕對路徑"+file.getAbsolutePath());
       //看你創建時傳入的路徑
        System.out.println("獲取路徑"+file.getPath());
//        獲取名稱
        System.out.println("獲取名稱"+file.getName());
//        獲取父目錄
        System.out.println("獲取父目錄"+file.getParent());
//        獲取文件長度
        System.out.println("獲取文件長度"+file.length());
//        文件創建時間
        System.out.println("文件創建時間"+new Date(file.lastModified()).toString());

//        判斷文件是否可寫
        System.out.println("是否可寫"+file.canWrite());
//        是否是文件
        System.out.println("是否是文件"+file.isFile());
//        是否隱藏
        System.out.println("是否隱藏"+file.isHidden());

/*
路徑分割符;
名字分割符\
創建結果:true
刪除結果true
絕對路徑d:\cc.txt
獲取路徑d:\cc.txt
獲取名稱cc.txt
獲取父目錄d:\
獲取文件長度0
文件創建時間Thu Jan 01 08:00:00 CST 1970
是否可寫false
是否是文件false
是否隱藏false

文件夾操作：

File dir = new File("d://cc/aa");
//        判斷文件是否存在
        if(!dir.exists()){
//            創建文件夾：只能創建單集目錄
//            boolean b = dir.mkdir();
//            創建多級目錄
            boolean b = dir.mkdirs();
            System.out.println("創建結果:"+b);
        }
       if(dir.exists()) {
//           直接刪除:最下層且必須為空目錄
           System.out.println("刪除結果" + dir.delete());
           //使用jvm退出時刪除，休眠結束後刪除
           dir.deleteOnExit();
           Thread.sleep(5000);
       }
//       獲取文件信息
        System.out.println("絕對路徑"+dir.getAbsolutePath());
       //看你創建時傳入的路徑
        System.out.println("獲取路徑"+dir.getPath());
//        獲取名稱
        System.out.println("獲取名稱"+dir.getName());
//        獲取父目錄
        System.out.println("獲取父目錄"+dir.getParent());
//        文件創建時間
        System.out.println("文件創建時間"+new Date(dir.lastModified()).toString());


//        判斷是否是文件夾
        System.out.println("是否可寫"+dir.isDirectory());
//        是否隱藏
        System.out.println("是否隱藏"+dir.isHidden());
//        遍歷文件夾
        String[] file = dir.list();

FileFilter介面

  • public interface FileFIlter

    • boolean accept(File pathname)

  • 當調用File類的listFiles()方法時，支持傳入一個實現了FileFilter介面的實現類對文件進行過濾，只有滿足條件的文件才能出現在listFiles()返回值中

  • 實現過濾

File dir = new File("d://cc/aa");
File[] files= dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //如果名字以.jpg結尾返回，否則不返回
                if(pathname.getName().endsWith(".jpg")){
                    return  true;
                }
                else{
                    return  false;
                }
            }
        });

遞歸遍歷文件夾(遞歸刪除文件夾：先把文件內刪空再刪除文件夾)：

public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
    listDir(new File("d://aa"));
}

public  static  void listDir(File dir){
    File[] files = dir.listFiles();
    if(files!=null && files.length>0){
        for (File file : files) {
            if(file.isDirectory()){
                //遞歸
                listDir(file);
            }
            else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

Prorerties

  • 屬性集合

  • 特點：

  1. 存儲屬性名和屬性值
  2. 屬性名和屬性值都是字元串類型
  3. 沒有泛型
  4. 繼承Hashtable集合，具體看集合那一章筆記
  5. 和流有關
//        創建集合
        Properties properties = new Properties();
//        添加數據
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());

        //遍歷
//        1.keySet遍歷
//        properties.keySet();
//         2.entrySet遍歷
//        3.stringPropertyNames變數
        Set<String> set = properties.stringPropertyNames();
        for (String s : set) {
            System.out.println(s+":"+properties.getProperty(s));
        }
//        和流有關的辦法
//        list方法
          PrintWriter pw = new PrintWriter("d://aa.txt");
        //將properties寫入該文件
            properties.list(pw);
            pw.close();
 //store方法保存寫入該文件
        FileOutputStream fos = new FileOutputStream("d://aa.txt");
        properties.store(fos,"這是註釋");
        fos.close();
/*
{age=20, username=zhangsan}
age:20
username:zhangsan

Properties properties1 = new Properties();
FileInputStream fis = new FileInputStream("d://aa.txt");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
//{age=20, username=zhangsan}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • React筆記-Hooks(九)
    # React筆記-Hooks(九) ## Hooks ### 概念 >React Hooks 的意思是 組件儘量寫成純函數 如果需要外部功能和副作用 就用鉤子把外部代碼"鉤"進來 ### 函數組件和類組件區別 >- 函數組件沒有狀態(state) 類組件有 >- 函數組件沒有生命周期 類組件有(掛 ...
  • Redis記憶體兜底策略——記憶體淘汰及回收機制
    ## 一、模式動機 >觀察者模式用於描述對象之間的依賴關係，它引入了觀察者和觀察目標兩類不同的角色，由於提供了抽象層，它使得增加新的觀察者和觀察目標都很方便。觀察者模式廣泛應用於各種編程語言的事件處理模型中，Java語言也提供了對觀察者模式的全面支持。 - 一個對象的狀態或行為的變化將導致其他對象的 ...
  • 壞代碼味道（一）
    ### GC 優化 #### 1.防止大對象Buffer到記憶體中 **現象**：當大包請求時，YGC 耗時嚴重 **原因**：預設情況下 Zuul2 並不會緩存請求體（DirectByteBuffer），也就意味著它會先發送接收到的請求 Headers 到後端服務，之後接收到請求體再繼續發送到後端服 ...
  • 什麼是 Spring？為什麼學它？
    歡迎來到本篇文章！在這裡，我將帶領大家快速學習 Spring 的基本概念，並解答兩個關鍵問題：什麼是 Spring，以及為什麼學習 Spring。 廢話少說，下麵，我們開始吧！ ...
  • 爬蟲——伺服器渲染和客戶端渲染
    # xxxx爬蟲——伺服器渲染和客戶端渲染 [toc] ## 伺服器渲染 - 專業解釋 伺服器渲染（Server-Side Rendering，SSR）是一種在伺服器端完成頁面渲染的網頁處理技術。具體來說，就是伺服器在響應客戶端請求時，會生成頁面的HTML代碼，並將其返回給客戶端。這種方式的優點包括 ...
  • 【2023.03.20】P4710 「物理」平拋運動
    題目傳送門： >[【洛谷】P4710 [物理]平拋運動](https://www.luogu.com.cn/problem/P4710 "【洛谷】P4710 [物理]平拋運動") ## Step 1：前置芝士 您需要知道並瞭解以下芝士： 1. 數學： - 三角函數； 2. 物理： - 加速度公式； ...
  • flask_SQLAlchemy 出現了 Lost connection to MySQL server during query Mysql主機連接超時 錯誤。如何解決
    本系列前面講解了Spring的bean定義、bean實例化、bean初始化等生命周期階段。這些步驟使我們能夠瞭解bean從創建到準備好使用所經歷的過程。但是，除了這些步驟，bean的銷毀也是非常重要的一步。在本系列的最後，我們將深入探討bean的銷毀過程，包括在什麼情況下會發生銷毀、銷毀的順序以及如... ...
  • PHP 獲取無限級下級ID 無層級
    PHP 獲取無限級下級ID 無層級 非遞歸 刪除會員處有誤，修複後上傳記錄， PHP 獲取無限級下級ID 無層級 非遞歸 刪除會員處有誤，修複後上傳記錄， PHP 獲取無限級下級ID 無層級 非遞歸 刪除會員處有誤，修複後上傳記錄， PHP 獲取無限級下級ID 無層級 非遞歸 刪除會員處有誤，修複後 ...
一周排行
    -Advertisement-
    Play Games
  • Dapr Outbox 執行流程
    Dapr Outbox 是1.12中的功能。 本文只介紹Dapr Outbox 執行流程，Dapr Outbox基本用法請閱讀官方文檔 。本文中appID=order-processor，topic=orders 本文前提知識：熟悉Dapr狀態管理、Dapr發佈訂閱和Outbox 模式。 Outbo ...
  • Advanced .Net Debugging 7：托管堆與垃圾收集
    引言 在前幾章我們深度講解了單元測試和集成測試的基礎知識，這一章我們來講解一下代碼覆蓋率,代碼覆蓋率是單元測試運行的度量值,覆蓋率通常以百分比表示，用於衡量代碼被測試覆蓋的程度，幫助開發人員評估測試用例的質量和代碼的健壯性。常見的覆蓋率包括語句覆蓋率（Line Coverage）、分支覆蓋率（Bra ...
  • C#S7.NET實現西門子PLCDB塊數據採集的完整步驟
    前言 本文介紹瞭如何使用S7.NET庫實現對西門子PLC DB塊數據的讀寫，記錄了使用電腦模擬，模擬PLC，自至完成測試的詳細流程，並重點介紹了在這個過程中的易錯點，供參考。 用到的軟體： 1.Windows環境下鏈路層網路訪問的行業標準工具（WinPcap_4_1_3.exe）下載鏈接：http ...
  • WPF控制項：密碼框綁定MVVM
    從依賴倒置原則（Dependency Inversion Principle, DIP）到控制反轉（Inversion of Control, IoC）再到依賴註入（Dependency Injection, DI）的演進過程，我們可以理解為一種逐步抽象和解耦的設計思想。這種思想在C#等面向對象的編 ...
  • Python中的私有屬性與私有方法
    關於Python中的私有屬性和私有方法 Python對於類的成員沒有嚴格的訪問控制限制，這與其他面相對對象語言有區別。關於私有屬性和私有方法，有如下要點： 1、通常我們約定，兩個下劃線開頭的屬性是私有的（private）。其他為公共的（public）； 2、類內部可以訪問私有屬性（方法）； 3、類外 ...
  • C++ 訪問說明符詳解：封裝數據，控制訪問，提升安全性
    C++ 訪問說明符 訪問說明符是 C++ 中控制類成員（屬性和方法）可訪問性的關鍵字。它們用於封裝類數據並保護其免受意外修改或濫用。 三種訪問說明符： public：允許從類外部的任何地方訪問成員。 private：僅允許在類內部訪問成員。 protected：允許在類內部及其派生類中訪問成員。 示 ...
  • static_cast與dynamic_cast到底是什麼？
    寫這個隨筆說一下C++的static_cast和dynamic_cast用在子類與父類的指針轉換時的一些事宜。首先，【static_cast，dynamic_cast】【父類指針，子類指針】，兩兩一組，共有4種組合：用 static_cast 父類轉子類、用 static_cast 子類轉父類、使用 ...
  • C語言數據結構：雙向鏈表的增刪操作
    /******************************************************************************************************** * * * 設計雙向鏈表的介面 * * * * Copyright (c) 2023-2 ...
  • @ComponentScan註解的實現，Spring掃描包的過程
    相信接觸過spring做開發的小伙伴們一定使用過@ComponentScan註解 @ComponentScan("com.wangm.lifecycle") public class AppConfig { } @ComponentScan指定basePackage，將包下的類按照一定規則註冊成Be ...
  • opensips開啟python支持
    操作系統 ：CentOS 7.6_x64 opensips版本： 2.4.9 python版本：2.7.5 python作為腳本語言，使用起來很方便，查了下opensips的文檔，支持使用python腳本寫邏輯代碼。今天整理下CentOS7環境下opensips2.4.9的python模塊筆記及使用 ...
所有分類