Java IO流（二）

• File類
• 字符流與字節流

File 類

1.1 File 概述

　　打開API，搜索File類。閱讀其描述：File文件和目錄路徑名的抽象表示形式。即，Java中把文件或者目錄（文件夾）都封裝成File對象。也就是說若是咱們要去操做硬盤上的文件，或者文件夾只要找到File這個類便可,那麼咱們就要研究研究File這個類中都有那些功能能夠操做文件或者文件夾呢

1.2 File類的構造函數

File(String pathname) :將一個字符串路徑封裝成File對象

 File(String parent,String child):傳入一個父級路徑和子級路徑

 File(File parent,String child):傳入一個File類型的父級路徑和子級路徑

1.2.1 案例代碼一：

package com.gao_01;
import java.io.File;
/*
 * File:文件和目錄路徑名的抽象表示形式，File 類的實例是不可變的
 * 
 * 構造方法：
 *         File(File parent, String child) 
 *         File(String pathname) 
 *         File(String parent, String child)      
 * 
 * 
 */
public class FileDemo {
    public static void main(String[] args) {
        //File(String pathname) ：將指定的路徑名轉換成一個File對象
        //File f = new File("D:\\a\\b.txt");
        
        //File(String parent, String child) : 根據指定的父路徑和文件路徑建立File對象
        //File f2 = new File("D:\\a","b.txt");
        
        //File(File parent, String child) :根據指定的父路徑對象和文件路徑建立File對象
        //File parent = new File("D:\\a");
        //File f3 = new File(parent,"b.txt");
        
        File f4 = new File(new File("D:\\a"),"b.txt");
        
    }
}

1.3 類建立和刪除功能

boolean createNewFile():指定路徑不存在該文件時時建立文件,返回true,不然返回false

boolean mkdir():當指定的單級文件夾不存在時建立文件夾並返回true，不然返回false

boolean mkdirs():當指定的多級文件夾某一級文件夾不存在時,建立多級文件夾並返回true,不然返回false

boolean delete():刪除文件或者刪除單級文件夾

1.3.1 案例代碼二：

package com.gao_01;

import java.io.File;
import java.io.IOException;

/*
 *     建立功能
 *         boolean createNewFile()  
 *         boolean mkdir()  
 *         boolean mkdirs()  
 *     刪除功能
 *         boolean delete() 
 * 
 *  絕對路徑：固定不可改變的路徑，以盤符開頭
 *  相對路徑：相對某個參照物，不能以盤符開頭
 *          在eclipse中相對路徑相對應當前項目的根目錄
 *  
 *  
 *  注意：刪除一個文件夾，這個文件夾下面不能有其餘的文件和文件夾

 */
public class FileDemo2 {
    public static void main(String[] args) throws IOException {
          File f = new File("d:\\a\\b.txt");//絕對路徑
          File f2 = new File("a.txt");//相對路徑
        
         //boolean createNewFile() : 當指定文件不存在時建立文件並返回true，不然返回false
         System.out.println(f2.createNewFile());
        
         
        //boolean mkdir()   : 當指定文件夾不存在時建立文件夾並返回true，不然返回false
        File f3 = new File("b");
        System.out.println(f3.mkdir());
        
        //boolean mkdirs() : 建立指定文件夾，當文件夾所在的目錄不存在，則順道一塊建立了
        File f4 = new File("c\\d\\e");
        System.out.println(f4.mkdir());
        System.out.println(f4.mkdirs());
        
        File f5 = new File("c.txt");
        System.out.println(f5.mkdir());
        
        //boolean delete() :當指定的文件或文件夾存在時刪除文件或者文件夾 並返回true，不然返回false
        System.out.println(f2.delete());
        System.out.println(f3.delete());

        File f6 = new File("c");
        System.out.println(f6.delete());
        
    }
}

1.4 File 類的判斷功能

boolean exists():判斷指定路徑的文件或文件夾是否存在

boolean isAbsolute():判斷當前路路徑是不是絕對路徑

boolean isDirectory():判斷當前的目錄是否存在

boolean isFile():判斷當前路徑是不是一個文件

boolean isHidden():判斷當前路徑是不是隱藏文件

1.4.1 案例代碼三：

package com.gao_01;
import java.io.File;
import java.io.IOException;

/*
 *    判斷功能
 *         boolean exists()  
 *         boolean isAbsolute()  
 *         boolean isDirectory() 
         boolean isFile()  
         boolean isHidden() 
 */
public class FileDemo3 {
    public static void main(String[] args) throws IOException {
        //method();
        //method2();
        //method3();
        
        method4();
    }

    private static void method4() {
        File f = new File("d:\\a\\b.txt");
        //boolean isHidden() :判斷File對象指向的路徑是否有隱藏屬性，若是隱藏了則返回true，不然返回false
        
        System.out.println(f.isHidden());
    }

    private static void method3() {
        File f = new File("a.txt");
        File f2 = new File("b");
        //boolean isDirectory() ：判斷File對象指向的路徑是不是文件夾，若是是則返回true，不然返回false
        //boolean isFile()  : 判斷File對象指向的路徑是不是文件，若是是則返回true，不然返回false
        
        //System.out.println(f.isDirectory());
        //System.out.println(f2.isDirectory());
        
        System.out.println(f.isFile());
        System.out.println(f2.isFile());
    }

    private static void method2() {
        //File f = new File("a.txt");
        File f2 = new File("d:\\a\b.txt");
        
        //boolean isAbsolute() :判斷File對象指向的路徑是不是絕對路徑，若是是絕對路徑則返回true，不然返回false
        System.out.println(f2.isAbsolute());
    }

    private static void method() {
        File f = new File("a.txt");
        //f.createNewFile();
        
        //boolean exists() : 判斷文件或者文件夾是否存在，若是存在則返回true，不然返回false
        System.out.println(f.exists());
    }
}

1.5 File 類的獲取功能和修更名字功能

  File getAbsoluteFile():獲取文件的絕對路徑,返回File對象

  String getAbsolutePath():獲取文件的絕對路徑,返回路徑的字符串

  String getParent():獲取當前路徑的父級路徑,以字符串形式返回該父級路徑

  File getParentFile():獲取當前路徑的父級路徑,以字File對象形式返回該父級路徑

  String getName():獲取文件或文件夾的名稱

  String getPath():獲取File對象中封裝的路徑

  long lastModified():以毫秒值返回最後修改時間

  long length():返回文件的字節數

  boolean renameTo(File dest): 將當前File對象所指向的路徑 修改成 指定File所指向的路徑

1.5.1 案例代碼四：

 package com.gao_01;

import java.io.File;
import java.io.IOException;

/*
 *    獲取功能
         File getAbsoluteFile()  
 *         String getAbsolutePath() 
 *         String getParent()  
 *         File getParentFile() 
 *         String getName() 
 *         String getPath()  
          long lastModified() 
          long length() 
      修改功能：
         boolean renameTo(File dest)
 */
public class FileDemo4 {
    public static void main(String[] args) throws IOException  {
        //method();
        //method2();
        //method3();
        
        File f = new File("d.txt");
        File f2 = new File("e.txt");
        
        //boolean renameTo(File dest) : 將當前File對象所指向的路徑 修改成 指定File所指向的路徑
        //注意：修改的文件路徑不能存在，若是存在則修改失敗
        System.out.println(f.renameTo(f2));
    }

    private static void method3() {
        File f = new File("a.txt");
        File f2 = new File("d:\\a\\b.txt");
        File f3 = new File("b");
        
        //String getName() : 獲取文件和文件夾的名稱
        //System.out.println(f.getName());
        //System.out.println(f2.getName());
        //System.out.println(f3.getName());
        
        //String getPath() : 返回建立File對象時給的路徑
        //System.out.println(f.getPath());
        //System.out.println(f2.getPath());
        //System.out.println(f3.getPath());
        
        //long lastModified() : 以毫秒值的形式返回最後修改時間
        //System.out.println(f.lastModified());
        //2514023311294
        //Date d = new Date(2514023311294L);
        //System.out.println(d.toLocaleString());
        
        //long length() : 返回文件的字節數
        System.out.println(f.length());
        System.out.println(f3.length());
    }

    private static void method2() throws IOException {
        //File f = new File("a.txt");
        
        //File f2 = new File("b","c.txt");
        //System.out.println(f2.createNewFile());
        
        File parent = new File("b");
        File f3 = new File(parent,"c.txt");
        if(!parent.exists()) {
            parent.mkdirs();
        }
        System.out.println(f3.createNewFile());
        
        //String getParent() 
        System.out.println(f3.getParent());
        //File getParentFile() 
        System.out.println(f3.getParentFile());
    }

    private static void method() {
        File f = new File("d:\\a\\b.txt");
        File f2 = new File("a.txt");
        
        //File getAbsoluteFile()  ：以File對象的形式返回當前File對象全部指向的絕對路徑
        System.out.println(f2.getAbsoluteFile());
        //String getAbsolutePath() : 返回File對象所指向的絕對路徑
        System.out.println(f2.getAbsolutePath());
    }
}

1.6 File 類的其餘獲取功能

String[] list():以字符串數組的形式返回當前路徑下全部的文件和文件夾的名稱

File[] listFiles():以File對象的形式返回當前路徑下全部的文件和文件夾的名稱

static File[] listRoots():獲取計算機中全部的盤符

1.6.1 案例代碼五：

package com.gao_01;
import java.io.File;

/*
 *     String[] list() 
     File[] listFiles() 
     static File[] listRoots() 
 */
public class FileDemo5 {
    public static void main(String[] args)  {
        //method();
        //method2();
        
        //static File[] listRoots() :  返回的是全部盤符
        File[] files = File.listRoots();
        for (File file : files) {
            System.out.println(file);
        }
    }

    private static void method2() {
        File f = new File("b");
        File f2 = new File("D:\\workspace\\myFile");
        File f3 = new File("c.txt");
        
        //File[] listFiles()
        File[] files = f3.listFiles();
        for (File file : files) {
            System.out.println(file.getName());
        }
    }

    private static void method() {
        File f = new File("b");
        File f2 = new File("D:\\workspace\\myFile");
        File f3 = new File("c.txt");
        
        //String[] list() : 返回當前路徑下全部的文件和文件夾名稱
        //注意：只有指向文件夾的File對象才能夠調用該方法
        String[] files = f3.list();
        for (int i = 0; i < files.length; i++) {
            System.out.println(files[i]);
        }
    }
}

1.7 File 類的兩個案例

1.7.1 案例代碼六：

輸出指定目錄下全部的java文件名（包含子目錄）

package com.gao_02;

import java.io.File;

/*
 * 需求：輸出指定目錄下全部的java文件名（包含子目錄）
 */
public class RecurrenceTest {
    public static void main(String[] args) {
        File f = new File("src");
        //File f = new File("src\\com\\itheima_01\\RecurrenceDemo.java");
        method(f);
    }
    
    public static void method(File file) {
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                //判斷是不是文件對象
                if(f.isFile()) {
                    if(f.getName().endsWith(".java")) {
                        System.out.println(f.getName());
                    }
                }
                else if(f.isDirectory()){
                    //是一個目錄對象
                    method(f);
                }
            }
        }
    }
    
    
    //輸出指定目錄下的全部java文件名（不包含子目錄）
    public static void method2(File file) {
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                //判斷是不是文件對象
                if(f.isFile()) {
                    if(f.getName().endsWith(".java")) {
                        System.out.println(f.getName());
                    }
                }
            }
        }
    }
    
}

1.7.2 案例代碼七

刪除指定的目錄（包含子目錄）

package com.gao_02;

import java.io.File;

/*
 * 需求：刪除指定的目錄（包含子目錄）
 * 
 * 注意：若是要刪除一個目錄，則須要先刪除這個目錄下的全部子文件和子目錄
 * 
 */
public class RecurrenceTest2 {
    public static void main(String[] args) {
        File f = new File("d:\\a");
        method(f);
    }
    
    //刪除指定目錄下全部文件和目錄
    public static void method(File file) {
        if(file.isDirectory()) {
            //幹掉本身全部的子文件和子目錄
            //獲取全部的子文件和子目錄
            File[] files = file.listFiles();
            for (File f : files) {
                if(f.isFile()) {
                    //直接幹掉他
                    System.out.println(f.getName());
                    f.delete();
                }
                else if(f.isDirectory()) {
                    //繼續查看是否還有文件和子目錄
                    method(f);
                }
            }
            
            //幹掉本身
            System.out.println(file.getName());
            file.delete();
        }
    }
}

1.7.3 案例代碼八：

將指定目錄(包含內容)複製到另外一個目錄中

package com.itheima_02;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：將指定目錄(包含內容)複製到另外一個目錄中
 * 
 * 源目錄        目標目錄
 * 
 * 
 * 分析：
 *         首先咱們要獲取源目錄下全部的文件和子目錄，
 *                 咱們能夠把源目錄封裝成一個File對象，
 *                 咱們能夠調用File類listFiles()方法，
 *                 咱們能夠獲取源目錄下全部的文件和子目錄所對應的File對象。
 *         若是咱們獲取到的是文件
 *                 先在目標目錄中建立該文件所對應的目錄，
 *                 進行文件的複製。
 *         若是咱們獲取到的是子目錄
 *                 看看子目錄下面是否還有其餘的文件和更深層次的子目錄
 * 
 * 
 * 

 */
public class RecurrenceTest3 {
    public static void main(String[] args) throws IOException  {
        //源目錄
        File src = new File("d:\\myAPI");
        //目標目錄
        File dest = new File("d:\\a");
        
        copyDir(src,dest);
    }
    
    public static void copyDir(File src,File dest) throws IOException {
        //爲了嚴謹起見，咱們首先對源目錄和目標目錄進行判斷，看他們究竟是不是目錄
        if(src.isDirectory() && dest.isDirectory()) {
            
            File newDir = new File(dest , src.getName());
            if(!newDir.exists()) {
                newDir.mkdir();
            }
                
            //獲取源目錄下全部的文件和子目錄
            File[] files = src.listFiles();
            
            for (File file : files) {
                if(file.isFile()) {
                    //若是File對象是文件，咱們就進行文件的複製
                    /*
                     * 
                     * 假設file對象指向的文件是d:\\myAPI\\classpath,
                     * 咱們要把這個文件複製到d:\\a\\myAPI
                     * 
                     * src:        d:\\myAPI
                     * dest:    d:\\a
                     * file:    d:\\myAPI\\classpath
                     * 
                     * "d:\\a" + "myAPI" =  d:\\a\\myAPI
                     * 
                     */
                    
                    //d:\\a\\myAPI
                    /*File newDir = new File(dest , src.getName());
                    if(!newDir.exists()) {
                        newDir.mkdir();
                    }*/
                    
                    //建立輸入流對象
                    FileInputStream fis = new FileInputStream(file);
                    //建立輸出流對象
                    // "d:\\a\\myAPI" + "classpath" = d:\\a\\myAPI\\classpath
                    FileOutputStream fos = new FileOutputStream(new File(newDir,file.getName()));
                    
                    byte[] bys = new byte[1024];
                    int len;
                    
                    while((len = fis.read(bys)) != -1) {
                        fos.write(bys, 0, len);
                    }
                    
                    fis.close();
                    fos.close();
                }
                else if(file.isDirectory()) {
                    //若是File對象是子目錄，遞歸，看看子目錄下面到底有什麼
                    /*
                     * src: d:\\myAPI
                     * dest: d:\\a
                     * 
                     * 新的源目錄：d:\\myAPI\\bin
                     * 新目標目錄：d:\\a\\myAPI
                     * 
                     * 
                     */
                    
                    //File newDir = new File(dest,src.getName());
                            
                    copyDir(file,newDir);
                }
            }
        }
    }
}

字符流與字節流

2.1 概述

 IO流分類：

    流向

        輸入流       讀取數據       FileReader    Reader

         輸出流     寫出數據       FileWriter     Writer

     數據類型

           字節流 

                字節輸入流   讀取數據     InputStream

                 字節輸出流   寫出數據     OutputStream

            字符流

                  字符輸入流  讀取數據     Reader

                  字符輸出流  寫出數據    Writer

2.2 利用字符流複製文本文件

利用字符流將當前工程下的IODemo.java拷貝到d盤的a文件夾下

2.2.1 案例代碼九：

package com.gao_02;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 使用字符流複製文本文件
 * 
 * 數據源        IODemo.java
 * 目的地        d:\\IODemo.java

 *     
 */
public class FileCopyDemo {
    public static void main(String[] args) throws IOException  {
        //建立字符輸入流對象
        FileReader fr = new FileReader("IODemo.java");
        //建立字符輸出流對象
        FileWriter fw = new FileWriter("d:\\IODemo.java");
        
        //一次讀寫一個字符
        
        /*int ch;
        while((ch = fr.read()) != -1) {
            fw.write(ch);
            fw.flush();
        }*/
        
        //一次讀寫一個字符數組
        int len;//用於存儲讀到的字符個數
        char[] chs = new char[1024];
        while((len = fr.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

2.2.2 字符流複製圖片的問題解析

2.3 利用字節流複製文本文件

利用字節流將當前工程下的IODemo.java拷貝到d盤下

2.3.1 案例代碼十

package com.gao_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 使用字節流複製文本文件
 * 
 * 數據源        IODemo.java
 * 目的地        d:\\a\\IODemo.java
 * 
 */
public class FileCopyDemo {
    public static void main(String[] args) throws IOException  {
        //建立字節輸入流對象
        FileInputStream fis = new FileInputStream("IODemo.java");
        //建立字節輸出流對象
        FileOutputStream fos = new FileOutputStream("d:\\a\\IODemo.java");
        
        //一次讀寫一個字節
        /*int by;
        while((by = fis.read()) != -1) {
            fos.write(by);
        }*/
        //一次讀寫一個字節數組
        int len;//存儲讀到的字節個數
        byte[] bys = new byte[1024];
        while((len = fis.read(bys)) != -1) {
            fos.write(bys,0,len);
        }
        
        
        //釋放資源
        fos.close();
        fis.close();
    }
}

2.4 複製圖片

字節流能夠操做全部類型的文件,由於全部的文件在計算機中都是以字節形式存儲

而字符流只能用來操做純文本類型的文件,不能操做字節類型的文件

2.4.1 案例代碼十一：

package com.gao_04;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 分別使用字符流和字節流複製圖片
 * 
 * 二進制文件只能使用字節流進行復制（使用windows自帶記事本打開讀不懂的）
 * 文本文件的複製便可使用字符流，也可使用字節流
 * 
 */
public class CopyImage {
    public static void main(String[] args) throws IOException  {
        //method();
        
        //建立字節輸入流對象
        FileInputStream fis = new FileInputStream("傳智學院.jpg");
        //建立字節輸出流對象
        FileOutputStream fos = new FileOutputStream("d:\\傳智學院.jpg");
        
        //一次讀寫一個字節數組
        int len;//用於存儲讀到的字節個數
        byte[] bys = new byte[1024];
        while((len = fis.read(bys)) != -1) {
            fos.write(bys,0,len);
        }
        
        //釋放資源
        fos.close();
        fis.close();
    }

    private static void method() throws FileNotFoundException, IOException {
        //建立字符輸入流對象
        FileReader fr = new FileReader("傳智學院.jpg");
        //建立字符輸出流對象
        FileWriter fw = new FileWriter("d:\\傳智學院.jpg");
        
        //一次讀寫一個字符數組
        int len;//用於存儲讀到的字符個數
        char[] chs = new char[1024];
        while((len = fr.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

2.5 複製指定目錄的全部文件到努力文件

package com.gao;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyDirTest {
    public static void main(String[] args) throws IOException {
        File src = new File("D:\\Java重點筆記及做業");
        File dest = new File("D:\\雜七雜八");
        copyDir(src, dest);
    }

    public static void copyDir(File src, File dest) throws IOException {
        if (src.isDirectory() && dest.isDirectory()) {
            File dir = new File(dest, src.getName());
            if (!dir.exists()) {
                dir.mkdir();
            }
            File[] files = src.listFiles();
            for (File file : files) {
                if (file.isFile()) {
                    copyFile(file, new File(dir, file.getName()));
                } else {
                    copyDir(file, dir);
                }
            }
        }
    }

    public static void copyFile(File file, File dir) throws IOException {
        FileInputStream fis = new FileInputStream(file);
        FileOutputStream fos = new FileOutputStream(dir);

        int len;
        byte[] by = new byte[1024];
        while ((len = fis.read(by)) != -1) {
            fos.write(by, 0, len);
        }
        fis.close();
        fos.close();
    }
}