前言

在這個動不動就讓你cmd，讓你%temp%的時代里面，你還在用你的滑鼠和cv嗎？還要一個一個的去打開檔案夾，cv檔案嗎？你low爆了，來看看不一樣的我們咋搞得，

檔案的傳輸

??在我們得認知中，有多少和以前得我一樣，覺得cv嗯真香，沒有什么cv不了得，可是有沒有想過cv滑鼠難得點，尤其是，筆記本沒有滑鼠，用觸摸板得我，很難受鴨！
??那么我們今天一起看看沒有滑鼠得cv檔案叭，

File類

一、 File類的定義

??① File類主要是Java為檔案這一塊的操作(洗掉，復制，粘貼，新增)而設計的相關類，
??② File類的包名是java.io，用的時候需要導包，它實作了Serializable，Comparable兩大介面便于可序列化和比較，

概述

它是檔案和目錄路徑名的抽象表示
檔案和目錄是可以通過File封裝成物件的
對于File而言，其封裝的并不是一個真正存在的檔案，僅僅是一個路徑名而已，它可以是存在的，也可以是不存在的，將來是要通過具體的操作把這個路徑的內容轉換為具體存在的

底層原始碼定義

public class File implements Serializable, Comparable<File>
{
}

二、File類的構造方法(常用)

1、File類的使用

上面表格中的實體不太好看，可以看看下面的代碼，因為在表格中換行不太行，就直接連在一起的格式不好看，

public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname)：通過將給定的路徑名字串轉換為抽象路徑名來創建新的 File實體，
        File f1 = new File("E:\\pier\\java.txt");
        System.out.println(f1);

        //File(String parent, String child)：從父路徑名字串和子路徑名字串創建新的 File實體，
        File f2 = new File("E:\\pier","java.txt");
        System.out.println(f2);

        //File(File parent, String child)：從父抽象路徑名和子路徑名字串創建新的 File實體，
        File f3 = new File("E:\\pier");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

注意輸出的是你的 File路徑，不確定你的路徑是否擁有，
結果

E:\pier\java.txt
E:\pier\java.txt
E:\pier\java.txt

2、File類的創建和使用

這里由于上面的表格的教訓我就不在后面寫實體了，需要實體的自己去看后面的帶代碼

創建檔案

創建檔案代碼實體

注：如果有人想要偷懶只想要一根斜線的話，可以使用 /
使用兩根\的主要目的是為了防止出現和\n這類符號出現歧義的情況所采取的

 public static void main(String[] args) throws IOException {
        //需求1：我要在E:\\pier目錄下創建一個檔案java.txt
        File f1 = new File("E:\\pier\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("--------");

        //需求2：我要在E:\\pier目錄下創建一個目錄JavaSE
        File f2 = new File("E:\\pier\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("--------");

        //需求3：我要在E:\\pier目錄下創建一個多級目錄JavaWEB\\HTML
        File f3 = new File("E:\\pier\\JavaWEB\\HTML");
//        System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());
        System.out.println("--------");

        //需求4：我要在E:\\pier目錄下創建一個檔案javase.txt
        File f4 = new File("E:\\pier\\javase.txt");
//        System.out.println(f4.mkdir());
        System.out.println(f4.createNewFile());
    }

判斷功能

獲取功能

判斷和獲取代碼實體

public static void main(String[] args) {
        //創建一個File物件
        File f = new File("myFile\\java.txt");

//        public boolean isDirectory()：測驗此抽象路徑名表示的File是否為目錄
//        public boolean isFile()：測驗此抽象路徑名表示的File是否為檔案
//        public boolean exists()：測驗此抽象路徑名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

//        public String getAbsolutePath()：回傳此抽象路徑名的絕對路徑名字串
//        public String getPath()：將此抽象路徑名轉換為路徑名字串
//        public String getName()：回傳由此抽象路徑名表示的檔案或目錄的名稱
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

//        public String[] list()：回傳此抽象路徑名表示的目錄中的檔案和目錄的名稱字串陣列
//        public File[] listFiles()：回傳此抽象路徑名表示的目錄中的檔案和目錄的File物件陣列
        File f2 = new File("E:\\pier");

        String[] strArray = f2.list();
        for(String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }

洗掉

public static void main(String[] args) throws IOException {
//        File f1 = new File("E:\\pier\\java.txt");
        //需求1：在當前模塊目錄下創建java.txt檔案
        File f1 = new File("myFile\\java.txt");
//        System.out.println(f1.createNewFile());

        //需求2：洗掉當前模塊目錄下的java.txt檔案
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在當前模塊目錄下創建pier目錄
        File f2 = new File("myFile\\pier");
//        System.out.println(f2.mkdir());

        //需求4：洗掉當前模塊目錄下的pier目錄
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在當前模塊下創建一個目錄pier,然后在該目錄下創建一個檔案java.txt
        File f3 = new File("myFile\\pier");
//        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\pier\\java.txt");
//        System.out.println(f4.createNewFile());

        //需求6：洗掉當前模塊下的目錄pier
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }

I/O流

曾幾何時，我們就聽過IO流的大名，在各種各樣的語言中聽聞這個詞，俗話說戀戀不忘，必有回響，今天它來了，下面我們嗯看一張圖，來使用三遍讀書法一探究竟這個所謂的IO流，

上圖小結:不管是字符流和位元組流，我們都差不多分為Input和Out兩種，對應的就是輸入輸出流嘛，我們對于檔案的操作大嘎子也就是這幾種方式，一種對檔案的讀取，一種就是對檔案的寫入，
首先我們再來看一看什么叫做IO流，百度給的定義:流是一種抽象概念，它代表了資料的無結構化傳遞，按照流的方式進行輸入輸出，資料被當成無結構的位元組序或字符序列，從流中取得資料的操作稱為提取操作，而向流中添加資料的操作稱為插入操作，用來進行輸入輸出操作的流就稱為IO流，換句話說，IO流就是以流的方式進行輸入輸出，
說白了不就是你和檔案的的不解之謎不就是IO流嗎？
Java之中的IO流不就是Java程式和作業系統之間的通信用的方法嗎？

位元組流

• 位元組流抽象基類

  • InputStream：這個抽象類是表示位元組輸入流的所有類的超類
  • OutputStream：這個抽象類是表示位元組輸出流的所有類的超類
  • 子類名特點：子類名稱都是以其父類名作為子類名的后綴

• 位元組輸出流

  • FileOutputStream(String name)：創建檔案輸出流以指定的名稱寫入檔案

• 使用位元組輸出流寫資料的步驟

  • 創建位元組輸出流物件(呼叫系統功能創建了檔案，創建位元組輸出流物件，讓位元組輸出流物件指向檔案)
  • 呼叫位元組輸出流物件的寫資料方法
  • 釋放資源(關閉此檔案輸出流并釋放與此流相關聯的任何系統資源)
    示例代碼

public static void main(String[] args) throws IOException {
        //創建位元組輸出流物件
        //FileOutputStream(String name)：創建檔案輸出流以指定的名稱寫入檔案
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        /*
            做了三件事情：
                A:呼叫系統功能創建了檔案
                B:創建了位元組輸出流物件
                C:讓位元組輸出流物件指向創建好的檔案
         */
        //void write(int b)：將指定的位元組寫入此檔案輸出流
        fos.write(97);
        //最后都要釋放資源(一定要記得釋放資源)
        //void close()：關閉此檔案輸出流并釋放與此流相關聯的任何系統資源，
        fos.close();
    }

位元組流寫資料的三種方式

代碼實體

public static void main(String[] args) throws IOException {
        //FileOutputStream(String name)：創建檔案輸出流以指定的名稱寫入檔案
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");

//       	  void write(int b)：將指定的位元組寫入此檔案輸出流
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);

//            void write(byte[] b)：將 b.length位元組從指定的位元組陣列寫入此檔案輸出流
//        byte[] bys = {97, 98, 99, 100, 101};
        //byte[] getBytes()：回傳字串對應的位元組陣列
        byte[] bys = "abcde".getBytes();
//        fos.write(bys);

        //void write(byte[] b, int off, int len)：將 len位元組從指定的位元組陣列開始，從偏移量off開始寫入此檔案輸出流
//        fos.write(bys,0,bys.length);
        fos.write(bys,1,3);

        //釋放資源
        fos.close();
    }

• 位元組流寫資料如何實作換行

  • windows:\r\n
  • linux:\n
  • mac:\r

• 位元組流寫資料如何實作追加寫入

  • public FileOutputStream(String name,boolean append)
  • 創建檔案輸出流以指定的名稱寫入檔案，如果第二個引數為true ，則位元組將寫入檔案的末尾而不是開頭
    代碼實體

 	public static void main(String[] args) throws IOException {
        //創建位元組輸出流物件
//        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);

        //寫資料
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }

        //釋放資源
        fos.close();
    }

看完了寫資料，小伙伴們有去嘗試嗎？我們寫過資料怎么拿出來呢？

位元組流讀資料的兩種方式
??①一次一個位元組資料
直接上代碼

public static void main(String[] args) throws IOException {
        //創建位元組輸入流物件
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        int by;
        /*
            fis.read()：讀資料
            by=fis.read()：把讀取到的資料賦值給by
            by != -1：判斷讀取到的資料是否是-1
         */
        while ((by=fis.read())!=-1) {
            System.out.print((char)by);
        }

        //釋放資源
        fis.close();
    }

??①一次一個位元組陣列

public static void main(String[] args) throws IOException {
        //創建位元組輸入流物件
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        /*
            hello\r\n
            world\r\n

            第一次：hello
            第二次：\r\nwor
            第三次：ld\r\nr

         */

        byte[] bys = new byte[1024]; //1024及其整數倍
        int len;
        while ((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //釋放資源
        fis.close();
    }

字符流

為什么會出現字符流

• 字符流的介紹

  由于位元組流操作中文不是特別的方便，所以Java就提供字符流

  字符流 = 位元組流 + 編碼表

• 中文的位元組存盤方式

  用位元組流復制文本檔案時，文本檔案也會有中文，但是沒有問題，原因是最終底層操作會自動進行位元組拼接成中文，如何識別是中文的呢？

  漢字在存盤的時候，無論選擇哪種編碼存盤，第一個位元組都是負數

這里提到了編碼表，給大家放一個我整理的編碼表詳解在這里叭

字串中的編碼解碼問題

注意字符流的輸入輸出基本上差不多，但是細微的差距基本上都是在他們所傳的引數差異，可以重點注意一下，這里就不寫實體了，詳情可以參考上面的位元組流，基本上差不多，
構造方法

** 寫資料的五種方法**

重繪和關閉

讀取

檔案的復制

上面的字符流和位元組流大體的都搞清楚了，那么我們怎么來復制檔案呢？

復制文本檔案，其實就把文本檔案的內容從一個檔案中讀取出來(資料源)，然后寫入到另一個檔案中(目的地)
位元組流復制

public static void main(String[] args) throws IOException {
        //根據資料源創建位元組輸入流物件
        FileInputStream fis = new FileInputStream("E:\\pier\\酒家.txt");
        //根據目的地創建位元組輸出流物件
        FileOutputStream fos = new FileOutputStream("Test復制\\酒家.txt");
		//兩種讀取方式均可，但第二種按照位元組讀取更快
        /*//讀寫資料，復制文本檔案(一次讀取一個位元組，一次寫入一個位元組)
        int by;
        while ((by=fis.read())!=-1) {
            fos.write(by);
        }*/
        //讀寫資料，復制文本檔案(一次讀取一個位元組陣列)
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }

        //釋放資源
        fos.close();
        fis.close();
    }

字符流復制檔案

字符流復制Java檔案有奇效喲

public static void main(String[] args) throws IOException {
        //根據資料源創建字符輸入流物件
        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
        //根據目的地創建字符輸出流物件
        FileWriter fw = new FileWriter("myCharStream\\Copy.java");

        //讀寫資料，復制檔案
//        int ch;
//        while ((ch=fr.read())!=-1) {
//            fw.write(ch);
//        }

        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }

        //釋放資源
        fw.close();
        fr.close();
    }

緩沖流

緩沖流又分為兩種
??①位元組緩沖流

• BufferOutputStream：該類實作緩沖輸出流， 通過設定這樣的輸出流，應用程式可以向底層輸出流寫入位元組，而不必為寫入的每個位元組導致底層系統的呼叫

• BufferedInputStream：創建BufferedInputStream將創建一個內部緩沖區陣列， 當從流中讀取或跳過位元組時，內部緩沖區將根據需要從所包含的輸入流中重新填充，一次很多位元組

構造方法介紹

代碼示例

 public static void main(String[] args) throws IOException {
        //位元組緩沖輸出流：BufferedOutputStream(OutputStream out)
 
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));
        //寫資料
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //釋放資源
        bos.close();
    

        //位元組緩沖輸入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));

        //一次讀取一個位元組資料
//        int by;
//        while ((by=bis.read())!=-1) {
//            System.out.print((char)by);
//        }

        //一次讀取一個位元組陣列資料
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //釋放資源
        bis.close();
    }

??②字符緩沖流

• BufferedWriter：將文本寫入字符輸出流，緩沖字符，以提供單個字符，陣列和字串的高效寫入，可以指定緩沖區大小，或者可以接受默認大小，默認值足夠大，可用于大多數用途

• BufferedReader：從字符輸入流讀取文本，緩沖字符，以提供字符，陣列和行的高效讀取，可以指定緩沖區大小，或者可以使用默認大小， 默認值足夠大，可用于大多數用途

字符緩沖流構造方法

字符緩沖流特有功能

代碼實體

public static void main(String[] args) throws IOException {
        //根據資料源創建字符緩沖輸入流物件
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        //根據目的地創建字符緩沖輸出流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));

        //讀寫資料，復制檔案
        //使用字符緩沖流特有功能實作
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //釋放資源
        bw.close();
        br.close();
    }

IO流小結

InputStream類是一個抽象類 ,是所有位元組輸入流類的父類，

OutputStream類是一個抽象類，是所有位元組輸出流的父類

InputStream的常見子類有：
FileInputStream:看這個名字就知道用于從檔案中讀取資訊，
ByteArrayInputStream: 位元組陣列輸入流,
ObjectInputStream：序列化時使用 一般和ObjectOutputStream一起使用
FilterInputStream: 過濾輸入流,為基礎的輸入流提供一些額外的操作，

OutputStream的常見子類有：
FileOutPutStream: 檔案輸出流對檔案進行操作
ByteArrayOutputStream: 位元組陣列輸出流
ObjectOutputStream: 序列化時使用 一般和OjbectInputStream一起使用
FilterOutputStream:過濾輸出流,為基礎的輸出流提供一些額外的操作，

看位元組流和字符流的輸入輸出

現在你覺得自己學的怎么樣呀，要是覺得自己學的還可以，可以嘗試著去自己做個點名器了呀
結果類似這樣

寫好了別來坑我呀，別有事可以鐘無艷，但無事就別搞我!

你今天學廢了嗎？