package cn.tedu.file;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

/*本類用來測試文件類 File*/
public class TestFile {
    public static void main(String[] args) throws IOException {
        //1.創(chuàng)建File文件對象
        /*1.構(gòu)造函數(shù)的參數(shù)是String類型的pathname(路徑名)
        * 這個(gè)路徑可以是文件路徑,也可以是文件夾路徑*/
        /*2.\在代碼中有特殊的意義,所以想要真正表示這是一個(gè)\,需要用\進(jìn)行轉(zhuǎn)義*/
        //注意:此處需要自己手動(dòng)在D盤創(chuàng)建對應(yīng)目錄下的1.txt,并添加內(nèi)容
        //注意:創(chuàng)建1.txt時(shí),需要設(shè)置系統(tǒng)顯示文件后綴名,如果沒設(shè)置,文件名應(yīng)該是1
        //注意:File需要導(dǎo)包:import java.io.File;
        File file = new File("D:\\ready\\1.txt");

        //2.測試常用方法
        //2.1文件與文件夾屬性測試
        System.out.println(file.length());//12,獲取指定文件的字節(jié)量大小
        System.out.println(file.exists());//true,判斷指定文件是否存在
        System.out.println(file.isFile());//true,判斷指定內(nèi)容是否為文件
        System.out.println(file.isDirectory());//false,判斷指定內(nèi)容是否為文件夾
        System.out.println(file.getName());//1.txt,獲取指定內(nèi)容的名字
        System.out.println(file.getParent());//D:\ready,獲取指定內(nèi)容的上級
        System.out.println(file.getAbsolutePath());//D:\ready\1.txt,獲取指定內(nèi)容的絕對路徑

        //2.2創(chuàng)建與刪除
        file = new File("D:\\ready\\2.txt");
        /*如果指定創(chuàng)建文件的文件夾不存在,會(huì)報(bào)錯(cuò):java.io.IOException
        * 系統(tǒng)找不到指定的路徑,由于可能會(huì)發(fā)生異常,所以調(diào)用時(shí)需要拋出異常 */
        //在windows中創(chuàng)建不存在的文件2.txt,成功返回true
        System.out.println(file.createNewFile());//true

        file = new File("D:\\ready\\m");
        System.out.println(file.mkdir());//true,創(chuàng)建不存在的單層文件夾m
        file = new File("D:\\ready\\a\\b\\c");
        System.out.println(file.mkdirs());//true,創(chuàng)建不存在的多層文件夾a/b/c

        System.out.println(file.delete());//c被刪除,刪除文件或者空文件夾
        file  = new File("D:\\ready\\a");
        System.out.println(file.delete());//false,因?yàn)閍目錄里還有b目錄
        file  = new File("D:\\ready\\2.txt");
        System.out.println(file.delete());//true,刪除2.txt文件成功

        //2.3 文件列表測試
        file = new File("D:\\ready");
        String[] listName = file.list();
        System.out.println(Arrays.toString(listName));

        File[] fs = file.listFiles();
        System.out.println(Arrays.toString(fs));
        System.out.println(fs[0].length());

    }
}

package cn.tedu.file;

import java.io.*;

/*本類用于練習(xí)字節(jié)輸入流*/
public class TestIn {
    public static void main(String[] args) {
        //method();//字節(jié)流的讀取
        method2();//高效字節(jié)流的讀取
    }

    //本方法用于測試高效字節(jié)流的讀取
    private static void method2() {
        //定義一個(gè)在本方法中都生效的局部變量in,注意手動(dòng)初始化，值為null
        InputStream in = null;
        try {
            //1.創(chuàng)建高效字節(jié)輸入流對象
//            InputStream in = new BufferedInputStream(
//                    new FileInputStream(new File("E:\\ready\\1.txt")));
              in = new BufferedInputStream
                      (new FileInputStream("E:\\ready\\1.txt"));
            //2.使用流進(jìn)行讀取
            int b;
            while ((b= in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {//關(guān)流操作寫在finally{}中
            //3.流用完以后一定要關(guān)閉?。?！
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    //本方法用于測試字節(jié)流的讀取
    private static void method() {
        //創(chuàng)建一個(gè)在本方法都生效的局部變量注意手動(dòng)初始化
        InputStream in = null;
        try {
            //1.創(chuàng)建字節(jié)輸入流對象用于讀取
            //InputStream in = new InputStream();//報(bào)錯(cuò)原因：抽象類不可實(shí)例化
            //InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
            in = new FileInputStream("E:\\ready\\1.txt");
            //2.開始讀取
            /*read()每次調(diào)用都會(huì)讀取一個(gè)字節(jié)，如果讀到了數(shù)據(jù)的末尾，返回-1*/
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
            //需求：需要循環(huán)讀取文件中的所有內(nèi)容，直至讀完
            //定義變量，記錄讀到的數(shù)據(jù)
            int b;
            while((b=in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();//打印錯(cuò)誤信息
        /*try-catch結(jié)構(gòu)中的第三個(gè)部分：finally{}
        * 這部分不論是否捕獲到異常，是一定會(huì)被執(zhí)行到的代碼，常用于關(guān)流*/
        }finally {
            try {
                //3.釋放資源，流資源用完必須釋放！??！
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.file;

import java.io.*;

/*本類用于測試字符流的讀取*/
public class TestIn2 {
    public static void main(String[] args) {
        //method();//測試普通字符輸入流
        method2();//測試高效字符輸入流
    }
    //創(chuàng)建一個(gè)用于測試高效字符輸入流的方法
    private static void method2() {
        //1.定義一個(gè)在本方法都生效的局部變量，手動(dòng)初始化值null
        Reader in=null;
        try{
            //1.創(chuàng)建高效字符讀取流對象
            //in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
            in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
            //2.使用流對象
            int b;
            while((b=in.read())!=-1){
                System.out.println(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //3.關(guān)閉流對象
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //創(chuàng)建一個(gè)用于測試普通字符輸入流的方法
    private static void method() {
        //1.1創(chuàng)建一個(gè)在本方法中都生效的局部變量，注意初始化值null
        Reader in = null;
        try {
            //1.2創(chuàng)建字符輸入流對象，注意需要捕獲異常
            //Reader in = new Reader();//報(bào)錯(cuò)原因：抽象父級不可實(shí)例化
            //in = new FileReader(new File("E:\\ready\\1.txt"));
            in = new FileReader("E:\\ready\\1.txt");
            //2.使用流對象
            //System.out.println(in.read());
            //需求：循環(huán)讀取文件中的所有內(nèi)容，只要不是-1，就說明還有數(shù)據(jù)，繼續(xù)讀取
            //3.1定義變量，記錄讀取到的數(shù)據(jù)
            int b;
            while((b = in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {//3.關(guān)流
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.file;

import java.io.*;

/*本類用于測試字節(jié)輸出流*/
public class TestOut {
    public static void main(String[] args) {
        method();//用于測試普通字節(jié)輸出流
        //method2();//用于測試高效字節(jié)輸出流
    }
    //創(chuàng)建一個(gè)用于測試高效字節(jié)輸出流的方法
    private static void method2() {
        //1.創(chuàng)建一個(gè)在本方法都生效的局部變量，注意手動(dòng)初始化
        OutputStream out = null;
        try{
            //2.創(chuàng)建高效字節(jié)輸出流對象
//          out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
            out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
            //3.使用流對象--進(jìn)行寫出操作
            out.write(97);
            out.write(97);
            out.write(97);
        }catch (Exception e){
            e.printStackTrace();
        }finally {//關(guān)流操作要放在finally{}中
            try {
                //4.關(guān)流
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //創(chuàng)建一個(gè)用于測試普通字節(jié)輸出流的方法
    private static void method() {
        //1.創(chuàng)建一個(gè)在本方法中都生效的局部變量，注意手動(dòng)初始化null
        OutputStream out = null;
        //2.創(chuàng)建try-catch-finally結(jié)構(gòu)，因?yàn)镮O操作可能會(huì)產(chǎn)生異常
        try{
            //3.創(chuàng)建普通字節(jié)輸出流對象
            //out = new FileOutputStream(new File("E:\\ready\\2.txt"));
            //out = new FileOutputStream("E:\\ready\\2.txt");
            out = new FileOutputStream("E:\\ready\\2.txt",true);
            //4.使用流對象--進(jìn)行寫出操作
            out.write(99);//對應(yīng)ASCII碼表中的a
            out.write(99);//對應(yīng)ASCII碼表中的b
            out.write(99);//對應(yīng)ASCII碼表中的c
        }catch (Exception e){
            e.printStackTrace();
        }finally {//如果想要代碼一定會(huì)執(zhí)行，需要寫在finally中
            try {
                //5.關(guān)流操作
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.file;

import java.io.*;

/*本類用于測試字符輸出流*/
public class TestOut2 {
    public static void main(String[] args) {
        //method();//用于測試普通字符輸出流
        method2();//用于測試高效字符輸出流
    }
    //創(chuàng)建一個(gè)用于測試高效字符輸出流的方法
    private static void method2() {
        //1.創(chuàng)建一個(gè)在本方法都生效的局部變量，值為null,注意手動(dòng)初始化?。?！
        Writer out = null;
        //2.由于程序可能會(huì)拋出異常，所以需要寫一個(gè)try-catch-finally結(jié)構(gòu)
        try{//存放可能會(huì)拋出異常的代碼
            //3.創(chuàng)建普通字符輸出流對象
            //out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
            //out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
            out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
            //4.使用流對象
            out.write(100);
            out.write(100);
            out.write(100);
            out.write(100);
            out.write(100);
        }catch (Exception e){//匹配并捕獲異常
            e.printStackTrace();//如果捕獲到異常就打印錯(cuò)誤信息
        }finally {//一定會(huì)被執(zhí)行到的代碼塊，常用于關(guān)流
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //創(chuàng)建一個(gè)用于測試普通字符輸出流的方法
    private static void method() {
        //1.創(chuàng)建一個(gè)在本方法都生效的局部變量，值為null,注意手動(dòng)初始化！??！
        Writer out = null;
        //2.由于程序可能會(huì)拋出異常，所以需要寫一個(gè)try-catch-finally結(jié)構(gòu)
        try{//存放可能會(huì)拋出異常的代碼
            //3.創(chuàng)建普通字符輸出流對象
            //out = new FileWriter(new File("E:\\ready\\2.txt"));
            //out = new FileWriter("E:\\ready\\2.txt");
            out = new FileWriter("E:\\ready\\2.txt",true);
            //4.使用流對象
            out.write(98);
            out.write(98);
            out.write(98);
            out.write(98);
        }catch (Exception e){//匹配并捕獲異常
            e.printStackTrace();//如果捕獲到異常就打印錯(cuò)誤信息
        }finally {//一定會(huì)被執(zhí)行到的代碼塊，常用于關(guān)流
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.file;

import java.io.*;
import java.util.Scanner;

/*本類用于練習(xí)文件復(fù)制綜合案例*/
public class TestCopyFile {
    public static void main(String[] args) {
        //1.提示并接收用戶輸入的源文件路徑和目標(biāo)位置
        System.out.println("請您輸入源文件路徑：");
        String f = new Scanner(System.in).nextLine();
        System.out.println("請您輸入目標(biāo)位置：");
        String t = new Scanner(System.in).nextLine();
        //2.調(diào)用方法完成文件的復(fù)制
        //ZFCopy(f,t);//用字符流完成復(fù)制案例
        ZJCopy(f,t);//用字節(jié)流完成復(fù)制案例
    }
    private static void ZJCopy(String f,String t) {
        //1.定義在整個(gè)方法中都生效的局部變量，手動(dòng)初始化值為null
        InputStream in = null;
        OutputStream out = null;
        //2.由于代碼可能會(huì)發(fā)生異常，所以需要try-catch-finally結(jié)構(gòu)
        try{
            //3.1創(chuàng)建高效/緩沖字節(jié)輸入流，參數(shù)是f
            in = new BufferedInputStream(new FileInputStream(f));
            //3.2創(chuàng)建高效/緩沖字節(jié)輸出流，參數(shù)是t
            out = new BufferedOutputStream(new FileOutputStream(t));

            //4.創(chuàng)建好流對象以后就可以通過流對象完成業(yè)務(wù)了
            //4.1定義變量保存讀到的數(shù)據(jù)
            int b;
            //4.2使用循環(huán)完成復(fù)制操作
            while((b=in.read())!=-1){
                out.write(b);
            }
            System.out.println("恭喜您~文件復(fù)制成功~");
        }catch(Exception e){
            System.out.println("很抱歉~文件復(fù)制失敗~");
            e.printStackTrace();
        }finally {
            //5.關(guān)流
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void ZFCopy(String f,String t) {
        //1.定義在整個(gè)方法中都生效的局部變量，手動(dòng)初始化值為null
        Reader in = null;
        Writer out = null;
        //2.由于代碼可能會(huì)發(fā)生異常，所以需要try-catch-finally結(jié)構(gòu)
        try{
            //3.1創(chuàng)建高效/緩沖字符輸入流,傳入的參數(shù)是源文件的路徑
            in = new BufferedReader(new FileReader(f));
            //3.2創(chuàng)建高效/緩沖字符輸出流，傳入的參數(shù)是目標(biāo)文件的路徑
            out = new BufferedWriter(new FileWriter(t));

            //4.拿到流對象以后，就可以使用流對象來完成業(yè)務(wù)了
            //4.1定義變量用來記錄讀到的數(shù)據(jù)
            int b;
            //4.2循環(huán)讀取目標(biāo)文件，直到返回值為-1，沒有數(shù)據(jù)時(shí)結(jié)束循環(huán)
            while((b=in.read())!=-1){
                out.write(b);/*將本次循環(huán)從源文件讀到的內(nèi)容寫出到目標(biāo)文件中*/
            }
            System.out.println("恭喜您！文件復(fù)制成功！");
        }catch (Exception e){
            System.out.println("很抱歉！文件復(fù)制失??！");
            e.printStackTrace();
        }finally {
            /*關(guān)流是有順序的：如果有多個(gè)流，最后創(chuàng)建的流最先關(guān)閉
            * 多條關(guān)流語句需要各自try-catch*/
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

--FileInputStream 子類,操作文件的字節(jié)輸入流,普通類
--BufferedInputStream 子類,緩沖字節(jié)輸入流,普通類

--FileReader,子類,操作文件的字符輸入流,普通類
--BufferedReader,子類,緩沖字符輸入流,普通類

--FileOutputStream 子類,操作文件的字節(jié)輸出流,普通類
--BufferedOutputStream 子類,緩沖字節(jié)輸出流,普通類

--FileWriter,子類,操作文件的字符輸出流,普通類
--BufferedWriter,子類,緩沖字符輸出流,普通類