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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

SimpleDateFormat :

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

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


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

    DataOutputStream dos = new DataOutputStream(new FileOutputStream("./fos_tmp_01.txt"));//把添加進(jìn)去的數(shù)據(jù)進(jìn)行封裝,就跟加密一樣,要想查看,就要按照添加的順序去查看
    
        byte b = 10;//變量(數(shù)據(jù))
        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ù)據(jù)
        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();//關(guān)閉資源

DataInputStream :
    
        //(輸出,輸入,就是針對(duì)當(dāng)前文件的進(jìn)出,這里是輸入,是把外面的文件的東西,輸入到當(dāng)前,且 一定要按照上面輸出的時(shí)候的順序,來(lái)讀取)
        DataInputStream dis = new DataInputStream(new FileInputStream("./fos_tmp_01.txt"));
        //讀取:要使用這個(gè)類,必須要提前知道該文件的存儲(chǔ)格式,和順序
        //讀的順序必須和寫的相同
        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();//關(guān)閉資源

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

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

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

    getParent :   

        //返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒(méi)有指定父目錄，則返回 null。
        getParent() : //說(shuō)白了,就是獲得當(dāng)前文件的目錄,就是 ./ 如 : ( E:/第二期學(xué)習(xí)課程總匯/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();//這個(gè)是創(chuàng)建文件(不是創(chuàng)建目錄) 返回值是boolean  true/false 如果有這個(gè)文件,或者是沒(méi)有這個(gè)目錄,就返回false 如果有這個(gè)目錄,沒(méi)有這個(gè)文件,創(chuàng)建成功,返回true
        System.out.println( f1.createNewFile() );

    length :

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

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

    endsWith :

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


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

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

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

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

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

    read :
        
        read();//讀取指定文件,默認(rèn)一次讀取1字節(jié),并且返回值是下一個(gè)字節(jié)的值(因?yàn)樽x取的時(shí)候,讀取指針是在頂端的,并不是在第一個(gè)字節(jié))  如果到達(dá)最后一位字節(jié)的時(shí)候(就是最后的,后面沒(méi)有了),就返回-1
        fis.read();//就讀取指定文件的第一個(gè)字節(jié)

    read_Bytes :

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

    write :

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

    write_bytes_0_tmp :

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

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

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

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

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

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

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

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

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

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

    serialVersionUID :

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


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

    ObjectOutputStream :

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

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

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