2. 程式人生 > 實用技巧 >JAVA知識點 I/O流框架簡要筆記

JAVA知識點 I/O流框架簡要筆記

阿新 • • 發佈：2020-09-15

I/O 框架

流的概念

記憶體與儲存裝置之間傳輸資料的通道

流的分類

按方向【重點】

  • 輸入流：將<儲存裝置>中的內容讀到<記憶體>中
  • 輸出流：將<記憶體>中的內容寫到<儲存裝置>中

按單位

  • 位元組流：以位元組為單位，可以讀寫所有資料
  • 字元流：以字元為單位，只能讀寫文字資料

按功能

  • 節點流：具有實際傳輸資料的讀寫功能
  • 過濾流：在節點流的基礎之上增強功能

位元組流

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

//InputStream 位元組輸入流
public int read(){}
public int read(byte[] b){}
public int read(byte[] b, int off, int len){}

// OutputStream 位元組輸出流
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b, int off, int len){}

檔案位元組流

檔案輸入流

psvm(String[] args) throws Exception{
  // 1 建立FileInputStream 並指定檔案路徑
  FileInputStream fis = new FileInputStream("d:\\abc.txt");
  // 2 讀取檔案
  // fis.read();
  // 2.1單位元組讀取
  int data = 0;
  while((data = fis.read()) != -1){
    sout((char)data);
  }
  // 2.2 一次讀取多個位元組
  byte[] buf = new byte[3]; // 大小為3的快取區
  int count = fis.read(buf); // 一次讀3個
  sout(new String(buf));
  sout(count);
  int count2 = fis.read(buf); // 再讀3個
  sout(new String(buf));
  sout(count2);
  
  // 上述優化後
  int count = 0;
  while((count = fis.read(buf)) != -1){
    sout(new String(buf, 0, count));
  }
  
  // 3 關閉
  fis.close();
}

檔案輸出流

psvm(String[] args) throws Exception{
  // 1 建立檔案位元組輸出流
  FileOutputStream fos = new FileOutputStream("路徑", true);// true表示不覆蓋 接著寫 
	// 2 寫入檔案
  fos.write(97);
  fos.write('a');
  // String string = "hello world";
  fos.write(string.getByte());
  // 3 關閉
  fos.close();
}

圖片複製案例

// 1 建立流
// 1.1 檔案位元組輸入流
FileInputStream fis = new FileInputStream("路徑");
// 1.2 檔案位元組輸出流
FileInputStream fos = new FileOutpuStream("路徑");
// 2 邊讀邊寫
byte[] buf = new byte[1024];
int count = 0;
while((count = fis.read(buf)) != -1){
  fos.write(buf, 0, count);
}
// 3 關閉
fis.close();
fos.close();

位元組緩衝流

緩衝流：BufferedInputStream/ BufferedOutputStream

  • 提高IO效率，減少訪問磁碟次數
  • 資料儲存在緩衝區中，flush是將緩衝區的內容寫入檔案中，也可以直接close
// 使用位元組緩衝流 讀取 檔案
psvm(String[] args) throws Exception{
  // 1 建立BufferedInputStream
  FileInputStream fis = new FileInputStream("路徑");
  BufferedInputStream bis = new BufferedInputStream(fis);
  // 2 讀取
  int data = 0;
  while((data = bis.read()) != -1){
    sout((char)data);
  }
  // 用自己建立的緩衝流
  byte[] buf = new byte[1024];
  int count = 0;
  while((count = bis.read(buf)) != -1){
    sout(new String(buf, 0, count));
  }
  
  // 3 關閉
  bis.close();
}


// 使用位元組緩衝流 寫入 檔案
psvm(String[] args) throws Exception{
  // 1 建立BufferedInputStream
  FileOutputStream fos = new FileOutputStream("路徑");
  BufferedOutputStream bis = new BufferedOutputStream(fos);
  // 2 寫入檔案
  for(int i = 0; i < 10; i ++){
    bos.write("hello".getBytes());// 寫入8k緩衝區
    bos.flush(); // 重新整理到硬碟
  }
  // 3 關閉
  bos.close();
}

物件流

ObjectOutputStream / ObjectInputStream

  • 增強了緩衝區功能
  • 增強了讀寫8種基本資料型別和字串的功能
  • 增強了讀寫物件的功能
    • readObject() 從流中讀取一個物件
    • writeObject(Object obj) 向流中寫入一個物件

使用流傳輸物件的過程稱為序列化、反序列化

序列化與反序列化

序列化

// 使用objectoutputStream實現序列化
psvm(String[] args){
  // 1. 建立物件流
  FileOutputStream fos = new 		 FileOutputStream("d:\\st.bin");
  ObjectOutputSream oos = new objectOutputSream(fos);
  // 2. 序列化（寫入操作）
  Student zhangsan = new Student("zs", 20);
  oos.WriteObject(zhangsan);
  // 3. 關閉
  oos.close();
  sout("序列化完畢");
}

反序列化

// 使用ObjectInputSteam實現反序列化（讀取重構物件）
psvm(String[] args){
  // 1. 建立物件流
  FileInputStream fis = new FileInputStream("d:\\stu.bin");
  ObjectInputStream ois = new ObjectInputStream(fis);
  // 2. 讀取檔案（反序列化）
  Student s = (Student)ois.readObject();
  // 3. 關閉
  ois.close();
  sout("執行完畢");
  sout(s.toString());  
}

注意事項

  1. 某個類要想序列化必須實現Serializable介面
  2. 序列化類中物件屬性要求實現Serializable介面
  3. 序列化版本號ID，保證序列化的類和反序列化的類是同一個類
  4. 使用transient修飾屬性，這個屬性就不能序列化
  5. 靜態屬性不能序列化
  6. 序列化多個物件，可以藉助集合來實現

編碼方式

UTF-8... 不贅述

字元流

// 傳統位元組流讀取
psvm(String[] args){
  // 1. 建立FileInputStream物件
  FileInputSteam fis = new FileInputStream("路徑");
  // 2. 讀取
  int data = 0;
  while((data = fis.read()) != -1){
    sout((char)data); 
  }
  // 3. 關閉
  fis.close();
}

字元流的父類（抽象類）

reader 字元輸入流

  • public int read(){}
  • public int read(char[] c){}
  • public int read(char[] b, int off, int len){}

Writer 字元輸出流

  • public void write(int n){}
  • public void write(String str){}
  • public void write(char[] c){}
// 1. 建立FileReader 檔案字元輸入流
FileReader fr = new FileReader("..");
// 2. 讀取
// 2.1 單個字元讀取
int data = 0;
while((data = fr.read()) != -1){
  sout((char)data);// 讀取一個字元
}
char[] buf = new char[2];// 字元緩衝區讀取
int count = 0;
while((count = fr.read(buf) != -1)){
  sout(new String(buf, 0, count));
}
// 3. 關閉
fr.close();

// 1. 建立FileWriter物件
FileWriter fw = new FileWriter("..");
// 2. 寫入
for(int i = 0; i < 10; i ++){
  fw.write("寫入的內容");
  fw.flush();
}
// 3. 關閉
fw.close();
sout("執行完畢");

（案例)使用上述內容進行文字檔案複製

不能複製圖片或二進位制檔案，使用位元組流可以複製任意檔案

psvm(String[] args) throws Exception{
  // 1. 建立
  FileReader fr = new FileReader("...");
  FileWriter fw = new FileWriter("...");
  // 2. 讀寫
  int data = 0;
  while((data = fr.read()) != -1){
    fw.write(data);
    fw.flush();
  }
  // 3. 關閉
  fw.close();
  fr.close();
}

字元緩衝流

BufferedReader / BufferedWriter

高效讀寫、支援輸入換行符、可一次寫一行讀一行

psvm(String[] args) throws Exception{
  // 建立緩衝流
  FileReader fr = new FileReader("..");
	BufferedReader br = new BufferedReader(fr);
  // 讀取
  // 1. 第一種方式
  char[] buf = new char[1024];
  int count = 0;
  while((count = br.read(buf)) != -1){
    sout(new String(buf, 0, count));
  }
  // 2. 第二種方式 一行一行讀取
  String line = null;
  while((line = br.readLine()) != null){
    sout(line);
  }
  
	// 關閉
  br.close();
}

psvm(String[] args){
  // 1. 建立BufferedWriter物件
  FileWriter fw = new FileWriter("..");
  BufferedWriter bw = new BufferedWriter(fw);
  // 2. 寫入
  for(int i = 0; i < 10; i ++){
    bw.write("寫入的內容");
    vw.newLine(); // 寫入一個換行符
    bw.flush();
  }
  // 3. 關閉
  bw.close(); // 此時會自動關閉fw
}

PrintWriter

封裝了print() / println() 方法 支援寫入後換行

支援資料原樣列印

psvm(String[] args){
  // 1 建立列印流
  PrintWriter pw = new PrintWriter("..");
  // 2 列印
  pw.println(12);
  pw.println(true);
  pw.println(3.14);
  pw.println('a');
  // 3 關閉
  pw.close();
}

轉換流

橋轉換流 InputStreamReader / OutputStreamWriter

可將位元組流轉換為字元流

可設定字元的編碼方式

psvm(String[] args) throws Exception{
  // 1 建立InputStreamReader物件
  FileInputStream fis = new FisInputStream("..");
  InputStreamReader isr = new InputStreamReader(fis, "utf-8");
  // 2 讀取檔案
  int data = 0;
  while((data = isr.read()) != -1){
    sout((char)data);
  }
  // 3 關閉
  isr.close();
}

psvm(String[] args) throws Exception{
  // 1 建立OutputStreamReader物件
  FileOutputStream fos = new FisOutputStream("..");
  OutputStreamWRITER osw = new OutputStreamReader(fos, "utf-8");
  // 2 寫入
  for(int i = 0; i < 10; i ++){
    osw.write("寫入內容");
    osw.flush();
  }
  // 3 關閉
  osw.close();
}

File類

概念：代表物理碟符中的一個檔案或者資料夾

/*
File類的使用
1. 分隔符
2. 檔案操作
3. 資料夾操作
*/
public class Demo{
  psvm(String[] args){
    separator();
  }
  // 1. 分隔符
  public static void separator(){
    sout("路徑分隔符" + File.pathSeparator);
    sout("名稱分隔符" + File.separator);
  }
  // 2. 檔案操作
  public static void fileOpen(){
    // 1. 建立檔案
    if(!file.exists()){ // 是否存在
    	File file = new File("...");
    	boolean b = file.creatNewFile();
    }
    
    // 2. 刪除檔案
    // 2.1 直接刪除
    file.delete(); // 成功true
    // 2.2 使用jvm退出時刪除
    file.deleteOnExit();
    
    // 3. 獲取檔案資訊
    sout("獲取絕對路徑" + file.getAbsolutePaht());
    sout("獲取路徑" + file.getPath());
    sout("獲取檔名稱" + file.getName());
    sout("獲取夫目錄" + file.getParent());
    sout("獲取檔案長度" + file.length());
    sout("檔案建立時間" + new Date(file.lashModified()).toLocalString());
    
    // 4. 判斷
    sout("是否可寫" + file.canWrite());
    sout("是否是檔案" + file.isFile());
    sout("是否隱藏" + file.isHidden());
  }
  
  
  // 資料夾操作
  public static void directoryOpe() throws Exception{
    // 1. 建立資料夾
    File dir = new File("...");
    sout(dir.toString());
    if(!dir.exists()){
      //dir.mkdir(); // 只能建立單級目錄
      dir.mkdirs(); // 建立多級目錄
    }
    
    // 2. 刪除資料夾
    // 2.1 直接刪除
    dir.delete(); // 只能刪除最底層空目錄
    // 2.2 使用jvm刪除
    dir.deleteOnExit();
    
    // 3. 獲取資料夾資訊
 		sout("獲取絕對路徑" + dir.getAbsolutePaht());
    sout("獲取路徑" + dir.getPath());
    sout("獲取檔名稱" + dir.getName());
    sout("獲取夫目錄" + dir.getParent());
    sout("獲取檔案長度" + dir.length());
    sout("資料夾建立時間" + new Date(dir.lashModified()).toLocalString());
    
    // 4. 判斷
    sout("是否是資料夾" + dir.isFile());
    sout("是否隱藏" + dir.isHidden());
    
    // 5. 遍歷資料夾
    File dir2 = new File("...");
    String[] files = dir2.list();
    for(String string : files){
      sout(string);
    }
    
    // FileFilter介面的使用
    
    File[] files2 = dir2.listFiles(new FileFilter(){
      
      @Override
      public boolean accept(File pathname){
        if(pathname.getName().endsWith(".jpg")){
          return true;
        }
        return false;
      }
    });
    for(File file : files2){
      sout(file.getName());
    }
    
  }
}

遞迴遍歷資料夾

psvm(String[] args){
  listDir(new File("d:\\myfiles"));
}
public static void listDir(File dir){
  File[] files = dir.listFiles();
  sout(dir.getAbsolutePath());
  if(files != null && files.length > 0){
    for(File file : files){
      if(file.isDirectory()){
        listDir(file); // 遞迴
      }else {
        sout(file.getAbsolutePath());
      }
    }
  }
}

遞迴刪除資料夾

public static void deleteDir(File dir){
  File[] files = dir.listFiles();
  if(files != null && files.length > 0){
    for(File file : files){
      if(file.idDirectory()){
        deleteDir(file); // 遞迴
      }else{
        // 刪除檔案
        sout(file.getAbsolutePath() + "刪除" + file.delete());
      }
    }
  }
}

相關推薦

JAVA知識點 I/O流框架簡要筆記

I/O 框架 流的概念 記憶體與儲存裝置之間傳輸資料的通道 流的分類 按方向【重點】

Java使用I/O流讀取檔案內容的方法詳解

本文例項講述了Java使用I/O流讀取檔案內容的方法。分享給大家供大家參考，具體如下：

JAVA之I/O流

I/O流 1、File類 參考API文件 2、四個基本流 基於位元組的輸入流：InputStream-->FileInputStream

Java中I/O流實現字元流、位元組流和緩衝流對檔案的輸入輸出

技術標籤：Java學習javastream Java程式中，對於資料的輸入/輸出操作以 “流(stream)” 的方式進行。 java.io包下提供了各種“流”類和介面，用以獲取不同種類的資料，並通過標準的方法輸入或輸出資料。

Java標準I/O流程式設計一覽筆錄

Java標準I/O知識體系圖： 1、I/O是什麼？ I/O 是Input/Output（輸入、輸出）的簡稱，輸入流可以理解為向記憶體輸入，輸出流是從記憶體輸出。

【Java學習筆記九】——I/O流之字元流與資料流

宣告：本文章內容主要摘選自尚矽谷宋紅康Java教程、《Java核心卷二》、廖雪峰Java教程，示例程式碼部分出自本人，更多詳細內容推薦直接觀看以上教程及書籍，若有錯誤之處請指出，歡迎交流。

java I/O流

一。分類與區別 1.根據資料流的方向分為 輸出流和輸入流 2.根據處理資料單位分為 位元組流和字元流，

JavaSE學習筆記 - I/O流詳解

I/O 概述   I/O流：對硬碟檔案進行讀寫，輸入流就是將硬碟檔案的內容讀入到記憶體中使用，輸出流就是將記憶體中的資料讀入到硬碟檔案中，以便於長期儲存。檔案是由字元或者位元組構成的，所以可以進行寫入和讀取。

Java I/O流 複製檔案速度對比

Java I/O流 複製檔案速度對比 首先來說明如何使用Java的IO流實現檔案的複製： 第一步肯定是要獲取檔案

Java I/O流實現檔案複製

技術標籤：筆記java演算法 Java I/O流實現檔案複製 1、檔案複製原理2、 檔案遍歷演算法(1)演算法分析(2)演算法原始碼

I/O流筆記（源：黑馬程式設計師）

I/O流File：它是檔案和目錄路徑名的抽象表示檔案和目錄是可以通過File封裝成物件的對於File而言，其封裝的並不是一個真正存在的檔案，僅僅是一個路徑名而已。它可以是存在的，也可以是不存在的。將來是要通過具體的

Hadoop基礎（十）： HDFS客戶端操作（三）HDFS的I/O流操作

2HDFS的I/O流操作 2.1HDFS檔案上傳 1．需求：把本地e盤上的banhua.txt檔案上傳到HDFS根目錄

I/O流

基本概念 什麼是 I/O？ 通過I/O 可以完成硬碟檔案的讀和寫。 概念圖：輸入、輸出是相對於記憶體而言的，以記憶體為參照物。

I/O流 基礎day-17

技術標籤：基礎java 1.I/O流 1.1 基本概念I/O就是Input/Output的含義，也就是輸入/輸出的含義。I/O流就是指像流水一樣不間斷地進行輸入輸出的過程。

檔案上傳獲取file的全路徑名_Java中的File類與I/O流

技術標籤：檔案上傳獲取file的全路徑名 File類java.io.File類主要用於檔案和目錄的建立、查詢和刪除等操作，實際開發中必須用到。

J-基礎-I/O流-緩衝流、轉換流、序列化流、列印流

技術標籤：java 緩衝流 提高讀寫效率。四個基本的流的增強，分為： 位元組緩衝流：BufferedInputStream，BufferedOutputStream 字元緩衝流：BufferedReader，BufferedWriter 原理： 建立流物件時，建立一個內建的

Java高階---I/O

技術標籤：I/Ojava Java高階—I/O 一、檔案的建立 File file= new File("D:\\\\soft\\\\ApiProject\\\\src\\\\IO20210129\\\\Test\\\\test.txt"); //檔案路徑

檔案I/O流、檔案、FileInputStreaam、FileOutputStream、FileReader、FileWriter的介紹和使用

一、檔案：儲存資料的地方 1、檔案流：檔案在程式中是以流的形式類操作的 類比：

java基礎：I/O學習筆記

I/O流 Java.io.file類 File類是Java程式中表示檔案和目錄（資料夾）的方式，是檔案和目錄的路徑名的抽象表示形式，我們可以使用File類對檔案和資料夾進行操作。路徑名是檔案或目錄的路徑和名稱的字串形式。

Java中的 I/O知識點

對於Java I/O來說，I意味著Input（輸入），O意味著Output（輸出）。讀書寫作並非易事，而建立一個好的I/O系統更是一項艱難的任務。