Java（8）I/O

時間  2020-11-26
標籤 java 面試 windows 數組 網絡 多線程 app dom ide 單元測試 欄目 Java 简体版
原文   原文鏈接

目錄

1、File類

一、File類概述

  • java.io.File類：一個java.io.File類的對象，表示文件和文件目錄路徑（就是文件夾）
  • File 能新建、刪除、重命名文件和目錄，但 File 不能訪問文件內容自己。若是須要訪問文件內容自己，則須要使用輸入/輸出流。
  • 想要在Java程序中表示一個真實存在的文件或目錄，那麼必須有一個File對 象，可是Java程序中的一個File對象，可能沒有一個真實存在的文件或目錄。

  • 經典應用場景：File對象能夠做爲參數傳遞給流的構造器。

二、File類實例化

  • 構造器
構造器 描述
File(String pathname) 由路徑名稱來建立
File(String parent, String child) 由上層目錄路徑+文件名來建立
File(File parent, String child) 由上層文件名+文件名來建立
File(URI uri) 由uri來建立

  • 路徑java

    • 絕對路徑：是一個固定的路徑,從盤符開始
    • 相對路徑：是相對於某個位置開始。在IDEA中是相對於當前的module

  • 路徑分隔符面試

    • windows和DOS系統默認使用「\」來表示
    • UNIX和URL使用「/」來表示
    • Java程序支持跨平臺運行，所以路徑分隔符要慎用。爲了解決這個隱患，File類提供了一個常量：public static final String separator，根據操做系統，動態的提供分隔符。
    • 舉例
    File file1 = new File("d:\\atguigu\\info.txt");

File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");

File file3 = new File("d:/atguigu");

三、File類經常使用方法

  • **獲取
方法 描述
getAbsolutePath() 獲取絕對路徑
getPath() 獲取路徑
getName() 獲取名
getParent() 獲取上層文件目錄路徑。若無，返回null
length() 獲取文件長度（即：字節數）。不能獲取目錄的長度。
lastModified() 獲取最後一次的修改時間，毫秒值
下面兩個是針對目錄的
public String[] list() 獲取指定目錄下的全部文件或者文件目錄的名稱數組
public File[] listFiles() 獲取指定目錄下的全部文件或者文件目錄的File數組
  • 重命名

public boolean renameTo(File dest)：把文件重命名爲指定的文件路徑。（實際上就是把file1的內容複製到file2，並把file1刪除）windows

對於 file1.renameTo(file2)要求：file1存在，file2不存在數組

  • 判斷
方法 描述
isDirectory() 判斷是不是文件目錄
isFile() 判斷是不是文件
exists() 判斷是否存在
canRead() 判斷是否可讀
canWrite() 判斷是否可寫
isHidden() 判斷是否隱藏
  • 建立和刪除
方法 描述 注意事項
public boolean createNewFile() 建立文件 若文件存在，則不建立，返回false
public boolean mkdir() 建立文件目錄 若是此文件目錄存在，就不建立；
若是此文件目錄的上層目錄不存在，也不建立
public boolean mkdirs() 建立文件目錄 若是上層文件目錄不存在，一併建立
public boolean delete() 刪除文件或者文件夾 Java中的刪除不走回收站
要刪除的文件目錄內不能包含文件或文件目錄

若是你建立文件或者 文件 目錄沒有寫盤符路徑 ， 那麼 ，默認在項目路徑下。網絡

2、IO流的原理

一、IO流的原理

  • I/O是input/output的縮寫，IO技術用於設備之間的數據傳輸。（如。讀/寫文件、網絡通信）
  • Java程序中，數據的輸入/輸出操做以「流(stream)」 的方式進行。
  • java.io包下提供了各類「流」類和接口，用以獲取不一樣種類的數據，並經過標準的方法輸入或輸出數據。

二、input和output的理解

  • 首先對於入和出，咱們是站在程序的角度來講的，想象本身身處程序內部。
  • input：磁盤、光盤等存儲設備的數據----->程序、內存
  • output：程序、內存中的數據----->磁盤、光盤等存儲設備

3、IO流的分類

一、分類

  • √√√按操做的數據單位不一樣分爲：字節流（8bit）、字符流（16bit）。字節流適合操做圖片、視頻等文件，字符流適合操做文本文件。多線程

  • 按數據流的流向不一樣分爲：輸入流、輸出流。app

  • 按流的角色不一樣分爲：**節點流、處理流。dom

    • 節點流：直接從數據源或目的地讀寫數據。也叫文件流ide

    • 處理流：不直接鏈接到數據源或目的地，而是「鏈接」在已存 在的流（節點流或處理流）之上，經過對數據的處理爲程序提 供更爲強大的讀寫功能單元測試

二、圖示

三、四個抽象基類

抽象基類 字節流 字符流
輸入流 InputStream Reader
輸出流 OutputStream Writer

四、IO流體系

4、FileReader和FileWriter

一、IDEA中單元測試方法和main()下相對路徑對比

  • 單元測試方法下的相對路徑是：相較於當前module而言
  • main()下的相對路徑：相較於當前工程而言

二、使用FileReader讀入數據

  • 最初的代碼實現
public void test1() throws IOException {
        //1.實例化File類,指明要操做的對象.這一步的目的是創建硬盤中的文件和Java中類的對應關係.
        File file = new File("hello1.txt");

        //2.提供具體的流.參數的做用就是幫助咱們並鏈接上文件這個"大水庫"
        FileReader fileReader = new FileReader(file);

        //3.用流讀取到內存
        //read():返回讀入的字符,是int須要轉換爲char.到了文件結尾返回-1
        int read = fileReader.read();
        while (read != -1) {
            System.out.print((char) read);
            read = fileReader.read();
        }

        //4.關閉流
        fileReader.close();
    }
    //整個過程結合圖示去理解很合理
  • 改進後的代碼實現
/*
    優化:
        1.第三部能夠在語法上的優化,可是效率實際上是同樣的
        2.爲了保證關閉操做必定執行,使用try-catch-finally
        3.讀入的文件必定要存在,不然會出現:FileNotFoundException
    */
public void test2() {

        FileReader fileReader = null;
        try {
            File file = new File("hello1.txt");

            fileReader = new FileReader(file);

            //改進1
            int read;
            while ((read = fileReader.read()) != -1){
                System.out.print((char) read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null)
                    fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
  • 使用緩衝流改進（這個是用的最多的★★★★★）
//使用數組
char[] charBuffer = new char[5];
int len;//記錄每次讀入到charBuffer數組中的字符個數
while ((len = fileReader.read(charBuffer)) != -1){
    for (int i = 0; i < len; i++) {//這裏要用len(讀取的字符數)二不是數組的長度
        System.out.print(charBuffer[i]);
    }
}

//固然for循環也能夠換位String的構造器來把字符串數組轉換爲String
String string = new String(charBuffer, 0, len);
System.out.print(string);

三、使用FileWriter寫出數據

  • 代碼實現
File file = new File("hello2.txt");
FileWriter fw = new FileWriter(file);
fw.write("i have a dream!");
fw.close();
//最後用try-catch處理一下異常，上面的步驟更清晰一些
  • 說明
    • 輸出時，File能夠不存在，不會報異常。
    • File對應的硬盤的文件若是不存在，自動建立
    • File對應的硬盤的文件若是存在
      • 若是流使用的構造器是FileWriter(file, false)/FileWriter(file)，對原有的文件進行覆蓋
      • 若是流使用的構造器是FileWriter(file, true)，對原有的文件進行追加

四、使用FileReader和FileWriter複製文本文件

  • 代碼實現
public void test5() throws IOException {
        File srcFile = new File("hello2.txt");
        File destFile = new File("hello3.txt");

        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);

        char[] charBuffer = new char[5];
        int len;
        while ((len = fr.read(charBuffer)) != -1) {
            fw.write(charBuffer, 0, len);//和用String來取是相似的★★★★★
        }

        fw.close();
        fr.close();
}
//最後用try-catch處理一下異常，上面的步驟更清晰一些

五、使用FileReader和FileWriter不能處理圖片的複製的測試

  • 當把hello.txt文本文件改成圖片文件時，發現代碼是能夠正常運行，可是複製結果並不對，新圖片打不開。
  • 這是由於，圖片是用字節來存儲的。用字符流來處理顯然不行。

5、FileInputStream和FileOutputStream

一、用FileInputStream和FileOutputStream處理文本文件會怎樣？

  • 結論
    • 輸出到控制檯時：英文不亂碼，中文可能會亂碼
    • 單純複製，而不在內存層面查看：不會亂碼，是能夠的。
  • 解釋
    • 對於英文，utf-8和gbk都是用一個字節（4bit位）來存一個字母，所以每一個字母都是完完整整的存入byte數組，從而能完整的複製過去。
    • 對於中文，utf-8中用的是三個字節來存一個漢字，那麼字節數組中的數據在輸出時，不肯定在哪裏截斷，就會出現一部分字的亂碼。

二、肯定使用字符流仍是字節流

  • 對於文本文件（.txt, .java, .cpp），使用字符流
  • 對於非文本文件（.jpg, .mp3, .mp4, .avi, .doc, .ppt...），使用字節流

三、用FileInputStream和FileOutputStream複製圖片

  • 同「使用FileReader和FileWriter複製文本文件」，只要
    • 使用FileInputStream和FileOutputStream
    • 把數組改成byte數組

6、緩衝流

一、緩衝流有哪些

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

二、做用

  • 提升讀寫速度

三、緣由

  • 在使用這些流類時，會建立一個內部緩衝區數組，缺省使用8192個字節(8Kb)的緩衝區。
  • 當讀取數據時，數據按塊讀入緩衝區，其後的讀操做則直接訪問緩衝區。
  • 當使用BufferedInputStream讀取字節文件時，BufferedInputStream會一次性從文件中讀取8192個(8Kb)，存在緩衝區中，直到緩衝區裝滿了，才從新從文件中讀取下一個8192個字節數組。
  • 向流中寫入字節時，不會直接寫到文件，先寫到緩衝區中直到緩衝區寫滿， BufferedOutputStream纔會把緩衝區中的數據一次性寫到文件裏。
  • 使用方法 flush()能夠強制將緩衝區的內容所有寫入輸出流。
  • 若是是帶緩衝區的流對象的close()方法，不但會關閉流，還會在關閉流以前刷 新緩衝區，關閉後不能再寫出。
    • 填坑：本身寫代碼的時候忘記關閉流操做，致使複製的圖片打不開的緣由就是，沒有關閉流，緩衝區內還有一部分數據沒能複製過去。

四、使用緩衝流複製圖片

public void test() throws IOException {
        //1.建立File
        File srcFile = new File("img1.png");
        File destFile = new File("img2.png");

        //2.建立流
        //2.1建立文件流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        //2.2建立字節流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //3.複製
        byte[] bytes = new byte[10];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //4.關閉流
        bis.close();
        bos.close();
}
  • 關閉外層的流的同時，會自動關閉內層的流。因此只寫外層的關閉操做就能夠。

五、使用緩衝流複製文本文件

public void test1() throws IOException {
        //1.建立文件和流
        BufferedReader br = new BufferedReader(new FileReader(new File("hello1.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));

//        //2.複製
//        char[] chars = new char[10];
//        int len;
//        while ((len = br.read(chars)) != -1) {
//            bw.write(chars, 0, len);
//        }


        // 複製:用String來實現★★★★★★★★★★★
        String data;//可是是不帶換行的,能夠用一如下兩種方法實現
        while ((data = br.readLine()) != null) {
//          //方法一★★★★★★★★
//            bw.write(data + "\n");
            //方法二★★★★★★★★
            bw.write(data);
            bw.newLine();
        }

        //3.關閉
        br.close();
        bw.close();
    }

六、練習：統計文本每一個字符出現次數

7、轉換流

一、什麼是轉換流

  • 轉換流提供了在字節流和字符流之間的轉換
  • 轉換流屬於字符流
  • Java API提供了兩個轉換流
    • InputStreamReader：將InputStream轉換爲Reader
      • 構造器一：public InputStreamReader(InputStream in)默認使用utf-8字符集
      • 構造器二：public InputSreamReader(InputStream in,String charsetName)能夠本身選擇字符集。
    • OutputStreamWriter：將Writer轉換爲OutputStream
      • 構造器和上面相似
  • 字節流中的數據都是字符時，轉成字符流操做更高效。
  • 不少時候咱們使用轉換流來處理文件亂碼問題。實現編碼和解碼的功能。

二、編碼與解碼

  • 編碼：字節、字節數組--->字符數組、字符串
  • 解碼：字符數組、字符串--->字節、字節數組

三、字符集

  • 什麼是編碼表：計算機只能識別二進制數據，早期由來是電信號。爲了方便應用計算機，讓它能夠識 別各個國家的文字。就將各個國家的文字用數字來表示，並一一對應，造成一張表。 這就是編碼表。
  • 常見編碼表
按照地區輔助記憶 編碼表 描述
美國 ASCII 用一個字節的7位來表示全部英文和符號
歐洲 ISO8859-1 用一個字節的8位表示全部歐洲語言的字母
中國 GB2312
GBK		 最多兩個字節編碼全部漢字
升級版，加入了更多的漢字
國際通用 Unicode
UTF-8		 Unicode編碼是對UTF-8/16的統稱
用1-4個字節表示人類全部文字

四、轉換流的做用示意圖

五、練習題

  • 綜合使用：將文本文件從utf-8轉換爲gbk編碼
  • 代碼實現
@Test
    public void test2() throws Exception {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2.讀寫過程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }

        //3.關閉資源
        isr.close();
        osw.close();
    }

8、標準輸入輸出流（瞭解）

一、簡介

  • 標準輸入流：System.in。默認輸入設備是鍵盤。類型是InputStream。
  • 標準輸出流：System.out。默認輸出設備是控制檯。類型是PrintStream，是OutputStream的子類。

2.練習

  • 題目：從鍵盤輸入字符串，要求將讀取到的整行字符串轉成大寫輸出。而後繼續 進行輸入操做，直至當輸入「e」或者「exit」時，退出程序。
  • 代碼實現
public class Exercise {
    public static void main(String[] args) {//idea不支持在單元測試中輸入內容,因此改用main()來測試
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

            while (true) {
                System.out.println("請輸入字符串: ");
                String data = br.readLine();
                if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                    System.out.println("程序結束");
                    break;
                }
                String upperCase = data.toUpperCase();
                System.out.println(upperCase);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

9、打印流（瞭解）

一、打印流簡介

  • 實現將基本數據類型的數據格式轉化爲字符串來輸出
  • 包含兩個：PrintStream和PrintWriter
    • 提供了一系列重載的print()和println()方法，用於多種數據類型的輸出
    • System.out返回的是PrintStream的實例

二、代碼演示

  • 把標準輸出流(控制檯輸出)改爲文件
PrintStream ps = null; 
try {
	FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt")); // 建立打印輸出流,設置爲自動刷新模式(寫入換行符或字節 '\n' 時都會刷新輸出緩衝區) 
    ps = new PrintStream(fos, true); 
    if (ps != null) {// 把標準輸出流(控制檯輸出)改爲文件 
        System.setOut(ps); 
    }

	for (int i = 0; i <= 255; i++) { // 輸出ASCII字符
		System.out.print((char) i); 
        if (i % 50 == 0) { // 每50個數據一行 
            System.out.println(); // 換行 
        }
    } 
} catch (FileNotFoundException e) { 
    e.printStackTrace(); 
} finally {
    if (ps != null) { 
        ps.close(); 
    } 
}

10、數據流（瞭解）

一、簡介

  • 引入：爲了方便地操做Java語言的基本數據類型和String的數據，可使用數據流

  • 數據流有兩個類：(用於讀取和寫出基本數據類型、String類的數據，方便持久化）

    • DataInputStream 和 DataOutputStream

    • DataInputStream中的方法

      boolean readBoolean()

      char readChar()

      double readDouble()

      long readLong()

      String readUTF()

      byte readByte()

      float readFloat()

      short readShort()

      int readInt() void

      readFully(byte[] b)

    • DataOutputStream中的方法

      將上述的方法的read改成相應的write便可

二、練習

練習：將內存中的字符串、基本數據類型的變量寫出到文件中。

    注意：處理異常的話，仍然應該使用try-catch-finally.
     */
    @Test
    public void test3() throws IOException {
        //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("劉建辰");
        dos.flush();//刷新操做，將內存中的數據寫入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        //3.
        dos.close();


    }
    /*
    將文件中存儲的基本數據類型變量和字符串讀取到內存中，保存在變量中。

    注意點：讀取不一樣類型的數據的順序要與當初寫入文件時，保存的數據的順序一致！

     */
    @Test
    public void test4() throws IOException {
        //1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);

        //3.
        dis.close();

    }

11、對象流

一、簡介

  • 包含：兩個類ObjectInputStream和ObjectOutputStream
  • 是：用於存儲和讀取基本數據類型數據或對象的處理流
  • 強大之處：能夠把Java中的對象寫入到數據源中，也能把對象從數據源中還原回來。

二、對象的序列化★★★★★

  • 什麼是對象的序列化機制（面試題）

    • 一方面，對象的序列化機制容許內存中的Java對象轉換爲平臺無關的二進制流。從而容許吧二進制流持久化到磁盤，或，經過網絡傳給另外一個網絡節點；
    • 另外一方面，其餘程序獲取了二進制流，就能夠恢復成原來的Java對象。

  • 序列化的好處：可將任何實現了Serializable接 使其在保存和傳輸時可被還原。

三、代碼實現String類的對象的序列化和反序列化

public class ObjectInputOutputStream {
    /*
    代碼實現String類的對象的序列化和反序列化
     */

    @Test//序列化
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try {
            //1.造流和文件
            oos = new ObjectOutputStream(new FileOutputStream(new File("objectString.dat")));
            //2.寫出
            oos.writeObject(new String("我愛你中國"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.關閉流
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(new File("objectString.dat")));

            Object readObject = ois.readObject();
            System.out.println(readObject);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、自定義類的序列化

  • 要求
    • 實現Serializable接口（這是一個標識接口，內部沒有方法）
    • 提供一個全局常量public static final long serialVersionUID = xxxxxxxxL;
      • 若是類沒有顯示定義這個靜態常量，它的值是Java運行時環境根據類的內部細節自 動生成的。若類的實例變量作了修改，serialVersionUID 可能發生變化。故建議， 顯式聲明。
    • 還要保證類的因此屬性也是可序列化的。
      • 基本數據類型是可序列化的
  • 注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修飾的成員變量
    • 由於static修飾的變量是類全部的
    • 不想序列化的就能夠用transient

五、面試題

  • 談談你對java.io.Serializable接口的理解，咱們知道它用於序列化， 是空方法接口，還有其它認識嗎？
    • 實現了Serializable接口的對象，可將它們轉換成一系列字節，並可在之後 徹底恢復回原來的樣子。這一過程亦可經過網絡進行。這意味着序列化機 制能自動補償操做系統間的差別。換句話說，能夠先在Windows機器上創 建一個對象，對其序列化，而後經過網絡發給一臺Unix機器，而後在那裏 準確無誤地從新「裝配」。沒必要關心數據在不一樣機器上如何表示，也沒必要 關心字節的順序或者其餘任何細節。
    • 因爲大部分做爲參數的類如String、Integer等都實現了 java.io.Serializable的接口，也能夠利用多態的性質，做爲參數使接口更 靈活。

12、RandomAccessFile

一、簡介

  • RandomAccessFile，隨機存取文件流，直接繼承於java.lang.Object類。
  • 隨機：RandomAccessFile 對象包含一個記錄指針，用以標示當前讀寫處的位置。 RandomAccessFile 類對象能夠自由移動記錄指針
    • long getFilePointer()：獲取文件記錄指針的當前位置
    • void seek(long pos)：將文件記錄指針定位到 pos 位置（這是他的靈魂所在）
      • 應用場景：能夠多線程斷點下載同一文件再拼接起來；下載不完，下次接着下載。
  • 存取：實現了DataInput、DataOutput兩個接口，因此這個類既能夠讀也能夠寫**。
    • 能夠用構造器裏的參數決定是輸出流仍是輸入流。
      • public RandomAccessFile(File file, String mode)
      • public RandomAccessFile(String name, String mode)
    • mode參數指定了訪問模式
      • r: 以只讀方式打開 （經常使用）
      • rw：打開以便讀取和寫入 （經常使用）
      • rwd:打開以便讀取和寫入；同步文件內容的更新
      • rws:打開以便讀取和寫入；同步文件內容和元數據的更新

二、用RandomAccessFile類實現文本文件的複製

@Test
public void test1() throws IOException {
    //用參數mode標識,讓類表明輸入
    RandomAccessFile r = new RandomAccessFile(new File("hello1.txt"), "r");
    //用參數mode標識,讓類表明輸出
    RandomAccessFile rw = new RandomAccessFile(new File("hello5.txt"), "rw");

    byte[] bytes = new byte[1024];
    int len;
    while ((len=r.read(bytes)) != -1){
        rw.write(bytes,0,len);
    }

    r.close();
    rw.close();
}

三、用 RandomAccessFile做爲輸出流時的特色

  • 若是寫出到的文件不存在，就建立
  • 若是寫出到的文件存在，會對原文從頭開始進行覆蓋，能覆蓋多少算多少。

四、如何使用 RandomAccessFile對文本文件實現插入效果

/*
    使用RandomAccessFile實現數據的插入效果
     */
    @Test
    public void test3() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//將指針調到角標爲3的位置
        //保存指針3後面的全部數據到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //調回指針，寫入「xyz」
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //將StringBuilder中的數據寫入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();
    }

十3、第三方jar包的使用

一、爲何使用

  • 第三方jar包提供了不少方便高效的API，方便咱們開發中使用，實際開發中也是用這些jar包來提升工做效率，而不僅是根據JDK提供的API，由於有些不夠簡練。

二、IDEA中導入第三方jar包

  • 當前module下建立名爲lib或libs的directory
  • 複製第三方jar包到lib目錄
  • 右鍵jar包，選擇 add as library
  • 搞定

三、用第三方jar包實現文件複製

public class JarTest {
    public static void main(String[] args) throws IOException {
        File srcFile = new File("s6_IO/hello1.txt");
        File destFile = new File("s6_IO/hello6.txt");

        FileUtils.copyFile(srcFile,destFile);

    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程