Java細數IO流底層原理到方法使用

2022-05-17 10:00:12

一、什麼是IO流

輸入流和輸出流。

輸入流：資料從資料來源（檔案）到程式（記憶體）的路徑
輸出流：資料從程式（記憶體）到資料來源（檔案）的路徑

二、常用的檔案操作

學習目標：建立檔案物件相關構造器和方法

new File（String pathname）//根據路徑構建一個File物件

new File（File parent，String child）//根據父目錄檔案+子路徑構建

new File（String parent，String child）//根據父目錄+子路徑構建

學習任務：在E槽下，建立檔案news1.txt、news2.txt、news3.txt用三種不同方式建立。

三種方式簡單看一下就行，後面會經常遇到。

new File（String pathname）//根據路徑構建一個File物件

package com.file;
import java.io.*;
public class FileCreate {
    public static void main(String[] args) {
            //方式 1 new File(String pathname)
            String filePath = "e:\news1.txt";
            File file = new File(filePath);
            try {
                //建立新檔案
                file.createNewFile();
                System.out.println("檔案建立成功");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
}

new File（File parent，String child）//根據父目錄檔案+子路徑構建

package com.file;
import java.io.*;
public class FileCreate {
    public static void main(String[] args) {
        //方式 2 new File(File parent,String child) //根據父目錄檔案+子路徑構建
        //e:\news2.txt
            File parentFile = new File("e:\");
            String fileName = "news2.txt";
           //這裡的 file 物件，在 java 程式中，只是一個物件
           //只有執行了 createNewFile 方法，才會真正的，在磁碟建立該檔案
            File file = new File(parentFile, fileName);
            try {
                file.createNewFile();
                System.out.println("建立成功~");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
}

new File（String parent，String child）//根據父目錄+子路徑構建

package com.file;
import java.io.*;
public class FileCreate {
    public static void main(String[] args) {
        //方式 3 new File(String parent,String child) //根據父目錄+子路徑構建
            String parentPath = "e:\";
            String fileName = "news3.txt";
            File file = new File(parentPath, fileName);
            try {
                file.createNewFile();
                System.out.println("建立成功~");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
}

三、獲取檔案的相關資訊

getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory

學習任務：獲取檔案的大小、檔名、路徑、父File，是檔案還是目錄（目錄本質也是檔案，一種特殊的檔案），是否存在

四、目錄的操作和檔案刪除

學習任務：

判斷e:news1.txt是否存在，如果存在就刪除
判斷e:\demo02是否存在，存在就刪除，否則提示不存在
判斷e:\demoabc目錄是否存在，如果存在就提示已經存在，否則就建立

package com.collection;
import java.io.File;
public class Delete {
    public static void main(String[] args) {
        String filePath="e:\news1.txt";
        File file=new File(filePath);
        if(file.exists()){
            file.delete();
        }else {
            System.out.println("否則檔案不存在~");
        }
    }
}

package com.collection;
import java.io.File;
public class Delete {
    public static void main(String[] args) {
        String filePath="e:\demo02";
        File file=new File(filePath);
        if(file.exists()){
            if(file.delete()){
                System.out.println(filePath+"刪除成功");
            }
            else{
                System.out.println(filePath+"刪除失敗");
            }
        }else {
            System.out.println("否則目錄不存在~");
        }
    }
}

package com.collection;
import java.io.*;
public class Delete {
    public static void main(String[] args) {
        String directoryPath="e:\demo\a\b\c";
        File file=new File(directoryPath);
        if(file.exists()) {
            System.out.println(directoryPath + "存在。。");
        }
        else {
            if (file.mkdirs()){
                System.out.println(directoryPath+"建立成功。。");
            }else{
                System.out.println(directoryPath+"建立失敗。。");
            }
        }
    }
}

按運算元據單位不同分為：位元組流（8bit）二進位制檔案，字元流（按字元）文字檔案

按資料流的流向不同分為：輸入流，輸出流

按流的角色的不同分為：節點流，處理流/包裝流

位元組流：InputStream，OutputStream

字元流：Reader，Writer

五、IO流體系圖-常用的類

六、FileInputStream常用方法

學習任務：請使用 FileInputStream 讀取 hello.txt 檔案，並將檔案內容顯示

先在E槽下建立hello.txt輸入內容hello world

package com.FileInputStream;
import java.io.FileInputStream;
import java.io.IOException;
//位元組流檔案的輸入程式
public class FileInputStream_ {
    public static void main(String[] args) {
        String filePath="e:\hello.txt";
        int readData=0;
        FileInputStream fileInputStream=null;
        try {
            //建立 FileInputStream 物件，用於讀取檔案
            fileInputStream=new FileInputStream(filePath);
            //從該輸入流讀取一個位元組的資料。 如果沒有輸入可用，此方法將阻止。
            //如果返回-1 , 表示讀取完畢
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char)readData);//轉成 char 顯示
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //關閉檔案流
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

七、FileOutputStream常用方法

學習任務：請使用 FileOutputStream 在 abc.txt 檔案，中寫入 “hello，world”. 如果檔案不存在，會建立檔案(注意：前提是目錄已經存在.)

package com.hspedu.outputstream_;
import java.io.*;
public class FileOutputStream01 {
    public static void main(String[] args) {
        String filePath = "D:\abc.txt";
        FileOutputStream fileOutputStream = null;
        try {
            //得到 FileOutputStream 物件 物件
            //1. new FileOutputStream(filePath) 建立方式，當寫入內容是，會覆蓋原來的內容
            // 2. new FileOutputStream(filePath, true) 建立方式，當寫入內容是，是追加到檔案後面
            fileOutputStream = new FileOutputStream(filePath);
            //寫入一個位元組
            //fileOutputStream.write('H');
            //寫入字串
            String str = "hello,world!";
            //str.getBytes() 可以把 字串-> 位元組陣列
            //fileOutputStream.write(str.getBytes());
            /*
             write(byte[] b, int off, int len) 將 len 位元組從位於偏移量 off 的指定位元組陣列寫入此檔案輸出流
             */
            fileOutputStream.write(str.getBytes(), 0, 3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

學習任務：程式設計完成圖片/音樂的拷貝

package com.hspedu.outputstream_;
import java.io.*;
public class FileCopy {
    public static void main(String[] args) {
        String srcFilePath="e:\9030.jpg";
        String destFilePath="e:\9031.jpg";
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        try {
            fileInputStream=new FileInputStream(srcFilePath);
            fileOutputStream=new FileOutputStream(destFilePath);
            //定義一個位元組陣列,提高讀取效果
            byte[] buf=new byte[1024];
            int readLen=0;
            while ((readLen=fileInputStream.read(buf))!=-1){
                fileOutputStream.write(buf,0,readLen);
            }
            System.out.println("拷貝成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(fileInputStream!=null){
                    fileInputStream.close();
                }
                if(fileOutputStream!=null){
                    fileInputStream.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

八、FileReader常用方法

new FileReader(File/String)
read：每次讀取單個字元，返回該字元，如果到檔案末尾返回-1
read（char[]）：批次讀取多個字元到陣列，返回讀取到的字元數，如果到檔案末尾返回-1
相關API：
new String（char[]）:將char[]轉換成String
new String（char[],off,len）:將char[]的指定部分轉換成String

九、FileWriter常用方法

new FileWriter(File/String):覆蓋模式，相當於流的指標在首端
new FileWriter(File/String,true):追加模式，相當於流的指標在尾端
write(int)：寫入單個字元
write(char[]):寫入指定陣列
write(char[],off,len):寫入指定陣列的指定部分
write(string)：寫入單個字元
write(string[],off,len):寫入字串的指定部分
相關API：String類：toCharArray:將String轉換成char[]
FileWriter使用後，必須要關閉（close）或重新整理（flush）, 否則寫入不到指定的檔案！

學習任務：使用 FileReader 從 story.txt ，這一步先在story.txt存在資料，然後在埠輸出資料顯示出來

package com.reader_;
import java.io.FileReader;
import java.io.IOException;
public class ReadFile01 {
    public static void main(String[] args) {
        String filePath="e:\story.txt";
        FileReader fileReader=null;
        int data=0;
        //建立FileReader物件
        try{
            fileReader =new FileReader(filePath);
            //迴圈讀取 使用 read, 單個字元讀取
            while((data=fileReader.read())!=-1){
                //data數值為整數型，強制轉換為字元
                System.out.print((char)data);
            }
        }catch(
                IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(fileReader!=null){
                    //關閉檔案流
                    fileReader.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

學習任務：字元陣列讀取檔案

package com.reader_;
import java.io.FileReader;
import java.io.IOException;
public  class ReadFile02 {
    public static void main(String[] args) {
        String filePath="e:\story.txt";
        FileReader fileReader=null;
        int readLen=0;
        char[] buf=new char[8];
        //建立FileReader物件
        try{
            fileReader =new FileReader(filePath);
            //迴圈讀取 使用 read(buf), 返回的是實際讀取到的字元數
            //如果返回-1, 說明到檔案結束
            while((readLen=fileReader.read(buf))!=-1){
                System.out.print(new String(buf,0,readLen));
            }
        }catch(
                IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(fileReader!=null){
                    fileReader.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

學習任務：使用 FileWriter 將 “風雨之後，定見彩虹” 寫入到 note.txt 檔案中

package com.hspedu.writer_;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_ {
    public static void main(String[] args) {
        String filePath="e:\noth.txt";
        FileWriter fileWriter=null;
        char[] chars={'a','b','c'};
        try {
            fileWriter = new FileWriter(filePath);
            //3) write(int):寫入單個字元
            fileWriter.write('H');
            // 4) write(char[]):寫入指定陣列
            fileWriter.write(chars);
            // 5) write(char[],off,len):寫入指定陣列的指定部分
            fileWriter.write("程式設計師飛鳥".toCharArray(), 0, 3);
            // 6) write（string）：寫入整個字串
            fileWriter.write(" 你好廣州");
            fileWriter.write("風雨之後，定見彩虹");
            // 7) write(string,off,len):寫入字串的指定部分
            fileWriter.write("上海天津", 0, 2);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                //對應 FileWriter , 一定要關閉流，或者 flush 才能真正的把資料寫入檔案裡面
                fileWriter.flush();//關閉檔案流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程式結束~");
    }
}

到此這篇關於Java細數IO流基礎到方法使用的文章就介紹到這了,更多相關Java IO流內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！