/**
 * 一個漢字是一個字符,就是2個字節(jié),就是16位,所以,要讀取漢字,還得用字符流
 *-------------------------------------- 基礎流----------------------------------------------
 */
FileInputStream ://(字節(jié)輸入流,一次讀取1個字節(jié)(就是8位))

    FileInputStream fis = new FileInputStream("文件路徑");//字節(jié)輸入流

FileOutputStream : //(字節(jié)輸出流,一次讀取1個字節(jié)(就是8位))

    FileOutputStream fis = new FileOutputStream("文件路徑",true);//字節(jié)輸出流 true不寫默認為覆蓋指定文件的內容,寫了就是在內容后追加

FileReader : //(字符輸入流,一次讀取1個字符,就是2個字節(jié)(就是16位))
    
    FileReader fis = new FileReader("文件路徑");//字符輸入流

FileWriter : //(字符輸出流,一次讀取1個字符,就是2個字節(jié)(就是16位))
    
    FileWriter fis = new FileWeriter("文件路徑,true");//字符輸出流,true不寫默認為覆蓋指定文件的內容,寫了就是在內容后追加

/**
 *-------------------------------------- 緩沖流----------------------------------------------
 */
BufferedInputStream : //(字節(jié)輸入流的緩沖流)
    
    1.BufferedInputStream br = new BufferedInputStream( new FileInputStream("文件路徑") );//字節(jié)輸入流的緩沖流

    2.FileInputStream fis = new FileInputStream("文件路徑");//創(chuàng)建原始流  
        BufferedInputStream br = new BufferedInputStream( fis );//緩沖流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版


BufferedOutputStream : //(字節(jié)輸出流的緩沖流)

    1 BufferedOutputStream br = new BufferedOutputStream( new FileOutputStream("文件路徑,true") );//字節(jié)輸出流的緩沖流

    2.FileOutputStream fis = new FileOutputStream("文件路徑,true");//創(chuàng)建原始流 true不寫默認為覆蓋指定文件的內容,寫了就是在內容后追加
        BufferedOutputStream br = new BufferedOutputStream( fis );//緩沖流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版


BufferedReader : //(字符輸入流的緩沖流)

    1 BufferedReader br = new BufferedReader( new FileReader("文件路徑") );//字符輸入流的緩沖流

    2.FileReader fis = new FileReader("文件路徑");//創(chuàng)建原始流
        BufferedReader br = new BufferedReader( fis );//緩沖流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版

BufferedWriter : //(字符輸出流的緩沖流)

    1 BufferedWriter br = new BufferedWriter( new FileWriter("文件路徑,true") );//字符輸出流的緩沖流

    2.FileWriter fis = new FileWriter("文件路徑,true");//創(chuàng)建原始流 true不寫默認為覆蓋指定文件的內容,寫了就是在內容后追加
        BufferedWriter br = new BufferedWriter( fis );//緩沖流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版

/**
 *-------------------------------------- 轉換流----------------------------------------------
 */
InputStreamReader : //(將字節(jié)輸入流轉為字符輸入流)

    1.InputStreamReader is = new InputStreamReader( new FileInputStream("文件路徑") );//將字節(jié)輸入流,轉為字符輸入流,是下面的簡寫
    
    2.FileInputStream fis = new FileInputStream("文件路徑");//創(chuàng)建字節(jié)原始流
        InputStreamReader is = new InputStreamReader( fis );//轉換為字符流

OutputStreamWriter : //(將字節(jié)輸出流轉為字符輸出流)

    1.InputStreamWriter is = new InputStreamWriter( new FileOutputStream("文件路徑,true") );//將字節(jié)輸出流,轉為字符輸出流,是下面的簡寫,這里不寫true,就是覆蓋指定文件中的內容,寫了就是內容內容后面追加
    
    2.FileOutputStream fis = new FileOutputStream("文件路徑,true");//創(chuàng)建字節(jié)原始流
        InputStreamWriter is = new InputStreamWriter( fis );//轉換為字符流

/**
 *------------------------------------------------------------------------------------------
 */

PRintStream :
    
    //打印流
    PrintStream ps = System.out;//(打印流)盡管沒有new,是因為out是個靜態(tài)成員變量(靜態(tài)變量),在類加載的時候,成員類就被加載了,所以可以直接加載這個方法m

Geng_Gai_Wei_Zhi :
    System.setOut() : //更改輸出位置

    System.setOut(new PrintStream(new FileOutputStream("./fos_tmp_01.txt")));//這里指定了系統(tǒng)默認輸出位置,這里 是個jvm系統(tǒng),會更改系統(tǒng)默認的位置

SimpleDateFormat :

        //日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

    lastModified :
        
        //最后的修改時間
        Date t = new Date(f1.lastModified());
        System.out.println( new SimpleDateFormat("yyy-MM-dd HH:mm:ss SSS").format(t) );//返回的是時間 , 年月日,時分秒,毫秒,也就是上面指定的格式


DataOutputStream :
    
    //(輸出,輸入,就是針對當前文件的進出,這里是輸出,是把當前文件的東西,輸出到指定的文件夾中,并加密,)

    DataOutputStream dos = new DataOutputStream(new FileOutputStream("./fos_tmp_01.txt"));//把添加進去的數(shù)據進行封裝,就跟加密一樣,要想查看,就要按照添加的順序去查看
    
        byte b = 10;//變量(數(shù)據)
        short s = 11;
        int i = 12;
        long l = 100L;
        float f = 3.2f;
        double d = 2.3;
        boolean flag = false;
        char c = 'a';

        dos.writeByte(b);//添加數(shù)據
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(flag);
        dos.writeChar(c);

        dos.flush();//磕兩下
        dos.close();//關閉資源

DataInputStream :
    
        //(輸出,輸入,就是針對當前文件的進出,這里是輸入,是把外面的文件的東西,輸入到當前,且 一定要按照上面輸出的時候的順序,來讀取)
        DataInputStream dis = new DataInputStream(new FileInputStream("./fos_tmp_01.txt"));
        //讀取:要使用這個類,必須要提前知道該文件的存儲格式,和順序
        //讀的順序必須和寫的相同
        byte b = dis.readByte();//讀取資源
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        boolean flag = dis.readBoolean();
        char c = dis.readChar();

        System.out.println( b );//輸出讀取的資源
        System.out.println( s );
        System.out.println( i );
        System.out.println( l );
        System.out.println( f );
        System.out.println( d );
        System.out.println( flag );
        System.out.println( c  );

        dis.close();//關閉資源

File :
    
    //文件和目錄路徑名的抽象表示形式。(抽象就是沒有的,這里說的是內存對象里面創(chuàng)建的,并不是硬盤創(chuàng)建的)
        
    File f1 = new File("E:/第二期學習課程總匯/java/day11_IO/IO_01_FileInputStream_01.java");// 構造函數(shù)并不是創(chuàng)建新文件用的,文件是在硬盤中的,但是這里只是把文件對象復制到內存而已,然后返回找到這個文件的路徑;

    getAbsolutePath :
    
        //返回此抽象路徑名的絕對路徑名字符串
        getAbsolutePath() : //說白了,就是獲得文件的全路徑(絕對路徑) 如 : ( E:/第二期學習課程總匯/java/day11_IO/IO_01_FileInputStream_01.java )
    getName :

        //返回由此抽象路徑名表示的文件或目錄的名稱。
        getName() : //說白了就是只獲得文件的文件名,和擴展名,如 : ( IO_01_FileInputStream_01.java )

    getParent :   

        //返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒有指定父目錄，則返回 null。
        getParent() : //說白了,就是獲得當前文件的目錄,就是 ./ 如 : ( E:/第二期學習課程總匯/java/day11_IO )

    isFile :

        isFile();//判斷是不是文件 返回值是boolean   true/false
        System.out.println( f1.isFile() );//判斷f1是不是文件 true

    isDirectory :

        isDirectory();//判斷是不是目錄 返回值是boolean  true.false
        System.out.println( f1.isDirectory() ); //判斷f1是不是目錄 false

    createNewFile :

        createNewFile();//這個是創(chuàng)建文件(不是創(chuàng)建目錄) 返回值是boolean  true/false 如果有這個文件,或者是沒有這個目錄,就返回false 如果有這個目錄,沒有這個文件,創(chuàng)建成功,返回true
        System.out.println( f1.createNewFile() );

    length :

        length();//獲取文本的長度,返回值是文本的長度
        System.out.println( f1.length() );

    listFiles :
        
    File f2 = new File("E:/第二期學習課程總匯/java/day11_IO/");// 構造函數(shù)并不是創(chuàng)建新文件用的,文件是在硬盤中的,但是這里只是把文件對象復制到內存而已,然后返回找到這個文件的路徑;
        //列出子文件 就是把指定的目錄每一個文件添加到數(shù)組中,在遍歷數(shù)組
        File[] fs = f2.listFiles();//創(chuàng)建一個數(shù)組,把指定的目錄里面的文件都添加到數(shù)組,在遍歷數(shù)組
         for(File f:fs){//foreach循環(huán)(for的增強版 只能遍歷集合和數(shù)組)
            System.out.println( f.getAbsolutePath() );//返回文件的全路徑(這里是遍歷,就是把每個文件都輸出全路徑)
        }

    endsWith :

        endsWith();//篩選
        File[] fs = f2.listFiles();//創(chuàng)建一個數(shù)組,把指定的目錄里面的文件都添加到數(shù)組,在遍歷數(shù)組
        for(File f:fs){
            if (f.getAbsolutePath().endsWith(".java")) {//篩選,以.java結束的文件
                System.out.println( f.getAbsolutePath() );//獲得文件的全路徑
            }
        }


Wen_Jian_Fu_Zhi : //文件復制(數(shù)組)

    //輸入流的方法 : FileInputStream
        1.read(); 2.read(bytes);//下面有方法的例子和解釋

    //輸出流的放法 : FileOutputStream
        3.writer(); 4.write(bytes,0,tmp);//下面有方法的例子和解釋
        5. flush();//磕兩下,往輸出流里面添加懂東西了,就要磕兩下,要么容易出錯

    //字節(jié)(文本)復制
    FileInputStream :
    FileOutputStream :

    try(
            FileInputStream fis = new FileInputStream("./IO流.java");//輸入流 , 把指定文件中的數(shù)據,讀取(輸入)到當前文件中
            FileOutputStream fos = new FileOutputStream("./新建文本文檔.txt");//輸出流 , 把指定的數(shù)據,輸出到指定的文件中去
                ){
            byte[] bytes = new byte[1024];//動態(tài)聲明一個byte數(shù)組,且1024個字節(jié)
            int tmp;//為什么用int聲明?因為read(bytes);返回值是bytes這個數(shù)組中,添加元素的個數(shù)(字節(jié)數(shù)),如果達到了指定的個數(shù)(這里是1024),tmp就會為0,數(shù)組也會清空,然后依次循環(huán),且 當讀取到最后一位的時候,返回值為-1
            while((tmp = fis.read(bytes)) != -1){//這是判斷語句,當輸入流指定的文件中,讀取到最后一位的時候,就會返回-1,然后這個tmp != -1 判斷語句  就為false 就不在循環(huán)了
                fos.write(bytes,0,tmp);//將bytes數(shù)組,從下標為0開始,輸出tmp個,(tmp就代表是數(shù)組里面已添加的字節(jié)個數(shù))
            }
            fos.flush();//磕兩下,往輸出流指定的文件中添加東西,都要磕兩下
        }catch(Exception e){//捕捉異常
            e.printStackTrace();//對異常進行打印追蹤棧幀
        }

    read :
        
        read();//讀取指定文件,默認一次讀取1字節(jié),并且返回值是下一個字節(jié)的值(因為讀取的時候,讀取指針是在頂端的,并不是在第一個字節(jié))  如果到達最后一位字節(jié)的時候(就是最后的,后面沒有了),就返回-1
        fis.read();//就讀取指定文件的第一個字節(jié)

    read_Bytes :

        read(byte[] bytes);//返回值是bytes這個數(shù)組中,添加元素的個數(shù)(字節(jié)數(shù)),如果達到了數(shù)組指定的長度(字節(jié)數(shù)),(這里是1024),tmp就會為0,數(shù)組也會清空,然后接著當前讀取的位置依次循環(huán)添加,一直到讀取完最后一位,且 當讀取到最后一位的時候,返回值為-1,(一般用于遍歷,但是一次也是讀取一個,只不過會一直讀取,一直到數(shù)組滿了(達到了指定的數(shù)組長度),然后再輸出到指定的文件,然后數(shù)組清空,tmp為0,依次循環(huán),一直到讀取完指定文件的最后一個字節(jié))
        fis.read(bytes);//就是讀取第一個字節(jié),并把這個字節(jié)存入到bytes數(shù)組中

    write :

        write();
        fos.write(添加);//把元素添加到輸出流指定的文件中,可以是任何東西

    write_bytes_0_tmp :

        write(bytes,0,tmp);
        fos.write(bytes,0,tmp);//把bytes數(shù)組中的元素,從下標為0開始,添加tmp位(個)元素

    //純文本字符流復制
    FileReader :
    FileWriter :
    
        try(
            FileReader fr = new FileReader("./IO流.java");//字符輸入流 指定文件
            FileWriter fw = new FileWriter("./新建文本文檔.txt");//字符輸出流 指定文件
                ){           
                char[] chars = new char[512];//這里是char類型的數(shù)組,因為純字符流復制,就是純文本,一個漢字就是一個字符,就是兩個字節(jié),就是16位,所以這里用的是char字符型數(shù)組
                int tmp = 0;//和上面一樣,這里為什么要用int聲明?
                while(-1 != (tmp = fr.read(chars))){//遍歷循環(huán) 將輸出流指定的文件中的內容,先復制到char數(shù)組,
                    fw.write(chars,0,tmp);//把數(shù)組的內容,復制到輸出流指定的文件中,并清空數(shù)組
                }
                fw.flush();//磕兩下 輸出流的方法
        }catch(Exception e){//捕捉異常
            e.printStackTrace();
        }

Wen_Jian_Fu_Zhi : //文件復制(緩沖流)
    
    BufferedReader : //字符輸入緩沖流
        readLine :
            方法 : readLine();//一次讀取一行
                //返回值 : 返回該行內容的字符串，不包含任何行終止符，如果已到達流末尾(最后的,沒有東西了)，則返回 null
                
    BufferedWriter : //字符輸出緩沖流
        newLine :
            方法 : newLine();//新建一行,相當于換行符,
    

     try(
            BufferedReader br = new BufferedReader(new FileReader("./IO流.java"));//字符輸入流的緩沖流
            BufferedWriter bw = new BufferedWriter(new FileWriter("./新建文本文檔.txt"));//字符輸出流的緩沖流
                ){
                    String tmp = null;//為什么用String?因為里面都是字符串,讀取一行,是以字符串的形式 ,所以要用String
                    int count = 0;//這里現(xiàn)在是判斷作用,用于添加換行符(下面)
                    while(true){//while循環(huán),如果不,判斷語句是true 如果不終止,就是死循環(huán)把
                        count++;
                        tmp = br.readLine();//讀取字符輸入流指定文件的一行,并賦值給tmp
                        if (tmp == null) {//判斷,如果tmp==null  就執(zhí)行一下語句 當readLine()方法,讀取到文件尾端的時候,讀取完成,就返回null,所以,當讀取完成后就要終止循環(huán)
                            break;//終止循環(huán)
                        }
                        //另起一行開始寫,就是一個符號,在兩行之間,顯示的是換行
                        if (count > 1) {//這是判斷,除了第一行,別的我們都需要換行,這里就是判斷,如果大于1 那就是第二行,和以下行了,就需要換行
                            bw.newLine();//換行符,是在行首
                        }
                        bw.write(tmp);//添加(復制)到輸出流指定的文件中,(一次是一行),然后數(shù)組清空
                    }
                    bw.flush();//添加(復制)完,就要磕兩下
        }catch(Exception e){//捕捉異常
            e.printStackTrace();//處理異常(打印追蹤棧幀)
        }

substring :
    
    substring();//返回一個新的字符串，它是此字符串的一個子字符串。該子字符串從指定索引處的字符開始，直到此字符串末尾。
        如 : String s = "12345";
                String s1 = s.substring(1);//是從原字符串的,下標為1的那位開始,至字符串的末尾,生成一個新的字符串
                s1就是"2345";
                String s2 = "A"+s.substring(1);
                s2就是"A2345";

exists :
    
    exists();//判斷該路徑是否存在,判斷目標位置所在的盤是不是有這個目錄(或文件),返回值為boolea  true/false
    File f = new File("E:/Zuo/You/Xia");//這個目錄(文件)路徑是在內存里面的,不是硬盤里面的
        f.exists();//這里是判斷,硬盤里面是否有這個目錄(或文件)(全路徑)

mkdirs :
    
    mkdirs();//在硬盤中創(chuàng)建指定(抽象,也就是內存中)文件(或目錄)的全路徑
    f.mkdirs();//在硬盤中,就會創(chuàng)建一個跟內存(抽象的)中一樣的文件(或目錄)的全路徑
    //注意，此操作失敗時也可能已經成功地創(chuàng)建了一部分必需的父目錄。
    //就是在硬盤中創(chuàng)建 E:/Zuo/You/Xia

mkdir :
    
    mkdir();//在硬盤中,創(chuàng)建指定文件(目錄)的父路徑,而不是全路徑
    f.mkdir();//只會創(chuàng)建 Xia,但是前提得自己創(chuàng)建 E:/Zuo/You,否則不會創(chuàng)建,
    
/**
 * --------------------------序列化----------------------
 */

Serializable :
    
    //序列化
    java.io.Serializable;//實現(xiàn)這個接口的,在實例化的時候,就會同步封裝邏輯
    transient :

        //如果序列化的時候,不想所有的數(shù)據都序列化,就在該數(shù)據前面加上:transient處理,就不會參與序列化
        如 :
            transient int age; //這個數(shù)據就不會被序列化

    serialVersionUID :

        序列化后,jvm會給對象文件和class文件都生成一個相同的serialVersionUID編號,這個編號是唯一的,如果對象文件(數(shù)據)和class(邏輯)文件的serialVersionUID編號對應不上,就會報錯,如果序列化之后,沒有更改class類文件對應的類里面的數(shù)據,就不會出現(xiàn)這種問題,但是如果改了,就不行了
        所以,這個serialVersionUID編碼,可以指定,指定之后,就算我改了class文件對應的類的數(shù)據,也能對應的上,也能讀取出來
    
    static final long serialVersionUID = 1L;//這樣,不管更改沒更改,每次生成的serialVersionUID編號,都會是1,就不會出現(xiàn)對應不上去這種錯誤
    //對象對應的文件 是保存的數(shù)據
    //類對象的class文件 是保存的邏輯
    //序列化就是把 對象 保存到 硬盤 中,
    User u1 = new User("aaa");//既然是序列化,那么這個User類必須實現(xiàn)與java.io.Serializable;(Serializable)這個接口


    往指定地方(硬盤)存儲對象文件的,叫序列化
    從指定文件中(硬盤),讀取對象文件的叫,反序列化

    ObjectOutputStream :

    //序列化
        需要有個實現(xiàn)Serializable接口的類,和往指定地方(硬盤)存放這個對象文件的類,也就是ObjectOutputStream類(這個類現(xiàn)用先寫都行)
    writerObject();//輸出對象流的方法 , 把指定的對象,添加到指定的文件中
    flush();//磕兩下,輸出流都有的方法

    //往指定地方(硬盤)存儲對象文件的,叫序列化
    
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./xv_lie_hua"));//創(chuàng)建對象輸出流 并把東西保存到指定的文件("./xv_lie_hua")
    oos.writeObject(u1);//這里就是把u1這個對象,輸出到上面指定的文件中("./xv_lie_hua"),沒有會創(chuàng)建
    oos.flush();//磕兩下
    oos.close();//關閉資源

    ObjectInputStream :
        
        //反序列化
         //反序列化需要:
            對象文件,對象對應的class文件,反序列化類文件(這個類現(xiàn)寫的都行)
        readObject();//輸入對象流的方法 , 讀出指定的對象文件
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./xv_lie_hua"));//創(chuàng)建對象輸入流,把指定的對象文件,輸入到當前頁面,
        Object o = ois.readObject();//讀取里面的對象,并賦值給用Object聲明的 o 變量
        System.out.println( o );//輸出o變量,就是輸出了讀取的對象
        ois.close();//關閉資源
    }