File類概述和構造方法

File類的概述
    檔案和目錄路徑名的抽象表示形式
構造方法
  public File(String pathname)
  public File(String parent,String child)
  public File(File parent,String child)
 
import java.io.File;
 
/*
 * 我們要想實現IO的操作，就必須知道硬碟上檔案的表現形式。
 * 而Java就提供了一個類File供我們使用。
 *
 * File:檔案和目錄(資料夾)路徑名的抽象表示形式
 * 構造方法：
 * File(String pathname)：根據一個路徑得到File物件
 * File(String parent, String child):根據一個目錄和一個子檔案/目錄得到File物件
 * File(File parent, String child):根據一個父File物件和一個子檔案/目錄得到File物件
 */
public class FileDemo {
public static void main(String[] args) {
// File(String pathname)：根據一個路徑得到File物件
// 把e:\\demo\\a.txt封裝成一個File物件
File file = new File("E:\\demo\\a.txt");
 
// File(String parent, String child):根據一個目錄和一個子檔案/目錄得到File物件
File file2 = new File("E:\\demo", "a.txt");
 
// File(File parent, String child):根據一個父File物件和一個子檔案/目錄得到File物件
File file3 = new File("e:\\demo");
File file4 = new File(file3, "a.txt");
 
// 以上三種方式其實效果一樣
}
}
 
 
 
File類的成員方法

建立功能
  public boolean createNewFile()
  public boolean mkdir()
  public boolean mkdirs()
刪除功能
  public boolean delete()
重新命名功能
  public boolean renameTo(File dest)
 
建立功能

/*
 *建立功能：
 *public boolean createNewFile():建立檔案 如果存在這樣的檔案，就不建立了
 *public boolean mkdir():建立資料夾 如果存在這樣的資料夾，就不建立了
 *public boolean mkdirs():建立資料夾,如果父資料夾不存在，會幫你創建出來
 *
 *騎白馬的不一定是王子，可能是班長。
 *注意：你到底要建立檔案還是資料夾，你最清楚，方法不要調錯了。
 */
public class FileDemo {
public static void main(String[] args) throws IOException {
// 需求：我要在e盤目錄下建立一個資料夾demo
File file = new File("e:\\demo");
System.out.println("mkdir:" + file.mkdir());
 
// 需求:我要在e盤目錄demo下建立一個檔案a.txt
File file2 = new File("e:\\demo\\a.txt");
System.out.println("createNewFile:" + file2.createNewFile());
 
// 需求：我要在e盤目錄test下建立一個檔案b.txt
// Exception in thread "main" java.io.IOException: 系統找不到指定的路徑。
// 注意：要想在某個目錄下建立內容，該目錄首先必須存在。
// File file3 = new File("e:\\test\\b.txt");
// System.out.println("createNewFile:" + file3.createNewFile());
 
// 需求:我要在e盤目錄test下建立aaa目錄
// File file4 = new File("e:\\test\\aaa");
// System.out.println("mkdir:" + file4.mkdir());
 
// File file5 = new File("e:\\test");
// File file6 = new File("e:\\test\\aaa");
// System.out.println("mkdir:" + file5.mkdir());
// System.out.println("mkdir:" + file6.mkdir());
 
// 其實我們有更簡單的方法
File file7 = new File("e:\\aaa\\bbb\\ccc\\ddd");
System.out.println("mkdirs:" + file7.mkdirs());
 
// 看下面的這個東西：
File file8 = new File("e:\\liuyi\\a.txt");
System.out.println("mkdirs:" + file8.mkdirs());
}
}
 
 
 
 
 
 
刪除功能

/*
 * 刪除功能:public boolean delete()
 *
 * 注意：
 * A:如果你建立檔案或者資料夾忘了寫碟符路徑，那麼，預設在專案路徑下。
 * B:Java中的刪除不走回收站。
 * C:要刪除一個資料夾，請注意該資料夾內不能包含檔案或者資料夾
 */
public class FileDemo {
public static void main(String[] args) throws IOException {
// 建立檔案
// File file = new File("e:\\a.txt");
// System.out.println("createNewFile:" + file.createNewFile());
 
// 我不小心寫成這個樣子了
File file = new File("a.txt");
System.out.println("createNewFile:" + file.createNewFile());
 
// 繼續玩幾個
File file2 = new File("aaa\\bbb\\ccc");
System.out.println("mkdirs:" + file2.mkdirs());
 
// 刪除功能：我要刪除a.txt這個檔案
File file3 = new File("a.txt");
System.out.println("delete:" + file3.delete());
 
// 刪除功能：我要刪除ccc這個資料夾
File file4 = new File("aaa\\bbb\\ccc");
System.out.println("delete:" + file4.delete());
 
// 刪除功能：我要刪除aaa資料夾
// File file5 = new File("aaa");
// System.out.println("delete:" + file5.delete());
 
File file6 = new File("aaa\\bbb");
File file7 = new File("aaa");
System.out.println("delete:" + file6.delete());
System.out.println("delete:" + file7.delete());
}
}
 
重新命名功能

 
/*
 * 重新命名功能:public boolean renameTo(File dest)
 * 如果路徑名相同，就是改名。
 * 如果路徑名不同，就是改名並剪下。
 *
 * 路徑以碟符開始：絕對路徑c:\\a.txt
 * 路徑不以碟符開始：相對路徑a.txt
 */
public class FileDemo {
public static void main(String[] args) {
// 建立一個檔案物件
// File file = new File("林青霞.jpg");
// // 需求：我要修改這個檔案的名稱為"東方不敗.jpg"
// File newFile = new File("東方不敗.jpg");
// System.out.println("renameTo:" + file.renameTo(newFile));
 
File file2 = new File("東方不敗.jpg");
File newFile2 = new File("e:\\林青霞.jpg");
System.out.println("renameTo:" + file2.renameTo(newFile2));
}
}
 
判斷功能

/*
 * 判斷功能:
 * public boolean isDirectory():判斷是否是目錄
 * public boolean isFile():判斷是否是檔案
 * public boolean exists():判斷是否存在
 * public boolean canRead():判斷是否可讀
 * public boolean canWrite():判斷是否可寫
 * public boolean isHidden():判斷是否隱藏
 */
public class FileDemo {
public static void main(String[] args) {
// 建立檔案物件
File file = new File("a.txt");
 
System.out.println("isDirectory:" + file.isDirectory());// false
System.out.println("isFile:" + file.isFile());// true
System.out.println("exists:" + file.exists());// true
System.out.println("canRead:" + file.canRead());// true
System.out.println("canWrite:" + file.canWrite());// true
System.out.println("isHidden:" + file.isHidden());// false
}
}
 
基本獲取功能

 
public String getAbsolutePath()
public String getPath()
public String getName()
public long length()
public long lastModified()
高階獲取功能
public String[] list()
public File[] listFiles()
 
/*
 * 獲取功能：
 * public String getAbsolutePath()：獲取絕對路徑
 * public String getPath():獲取相對路徑
 * public String getName():獲取名稱
 * public long length():獲取長度。位元組數
 * public long lastModified():獲取最後一次的修改時間，毫秒值
 */
public class FileDemo {
public static void main(String[] args) {
// 建立檔案物件
File file = new File("demo\\test.txt");
 
System.out.println("getAbsolutePath:" + file.getAbsolutePath());
System.out.println("getPath:" + file.getPath());
System.out.println("getName:" + file.getName());
System.out.println("length:" + file.length());
System.out.println("lastModified:" + file.lastModified());
 
// 1416471971031
Date d = new Date(1416471971031L);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
}
}
 
 
高階功能

import java.io.File;
 
/*
 * 獲取功能：
 * public String[] list():獲取指定目錄下的所有檔案或者資料夾的名稱陣列
 * public File[] listFiles():獲取指定目錄下的所有檔案或者資料夾的File陣列
 */
public class FileDemo {
public static void main(String[] args) {
// 指定一個目錄
File file = new File("e:\\");
 
// public String[] list():獲取指定目錄下的所有檔案或者資料夾的名稱陣列
String[] strArray = file.list();
for (String s : strArray) {
System.out.println(s);
}
System.out.println("------------");
 
// public File[] listFiles():獲取指定目錄下的所有檔案或者資料夾的File陣列
File[] fileArray = file.listFiles();
for (File f : fileArray) {
System.out.println(f.getName());
}
}
}
 
 
File類練習

判斷E盤目錄下是否有後綴名為.jpg的檔案，如果有，就輸出此檔名稱
import java.io.File;
 
/*
 * 判斷E盤目錄下是否有後綴名為.jpg的檔案，如果有，就輸出此檔名稱
 *
 * 分析：
 * A:封裝e判斷目錄
 * B:獲取該目錄下所有檔案或者資料夾的File陣列
 * C:遍歷該File陣列，得到每一個File物件，然後判斷
 * D:是否是檔案
 * 是：繼續判斷是否以.jpg結尾
 * 是：就輸出該檔名稱
 * 否：不搭理它
 * 否：不搭理它
 */
public class FileDemo {
public static void main(String[] args) {
// 封裝e判斷目錄
File file = new File("e:\\");
 
// 獲取該目錄下所有檔案或者資料夾的File陣列
File[] fileArray = file.listFiles();
 
// 遍歷該File陣列，得到每一個File物件，然後判斷
for (File f : fileArray) {
// 是否是檔案
if (f.isFile()) {
// 繼續判斷是否以.jpg結尾
if (f.getName().endsWith(".jpg")) {
// 就輸出該檔名稱
System.out.println(f.getName());
}
}
}
}
}
 
 
實現二；

 
/*
 * 判斷E盤目錄下是否有後綴名為.jpg的檔案，如果有，就輸出此檔名稱
 * A:先獲取所有的，然後遍歷的時候，依次判斷，如果滿足條件就輸出。
 * B:獲取的時候就已經是滿足條件的了，然後輸出即可。
 *
 * 要想實現這個效果，就必須學習一個介面：檔名稱過濾器
 * public String[] list(FilenameFilter filter)
 * public File[] listFiles(FilenameFilter filter)
 */
public class FileDemo2 {
public static void main(String[] args) {
// 封裝e判斷目錄
File file = new File("e:\\");
 
// 獲取該目錄下所有檔案或者資料夾的String陣列
// public String[] list(FilenameFilter filter)
String[] strArray = file.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
// return false;
// return true;
// 通過這個測試，我們就知道了，到底把這個檔案或者資料夾的名稱加不加到陣列中，取決於這裡的返回值是true還是false
// 所以，這個的true或者false應該是我們通過某種判斷得到的
// System.out.println(dir + "---" + name);
// File file = new File(dir, name);
// // System.out.println(file);
// boolean flag = file.isFile();
// boolean flag2 = name.endsWith(".jpg");
// return flag && flag2;
return new File(dir, name).isFile() && name.endsWith(".jpg");
}
});
 
// 遍歷
for (String s : strArray) {
System.out.println(s);
}
}
}
 
改成
 
 
 
 
/*
 * 需求：把E:\評書\三國演義下面的視訊名稱修改為
 * 00?_介紹.avi
 *
 * 思路：
 * A:封裝目錄
 * B:獲取該目錄下所有的檔案的File陣列
 * C:遍歷該File陣列，得到每一個File物件
 * D:拼接一個新的名稱，然後重新命名即可。
 */
public class FileDemo {
public static void main(String[] args) {
// 封裝目錄
File srcFolder = new File("E:\\評書\\三國演義");
 
// 獲取該目錄下所有的檔案的File陣列
File[] fileArray = srcFolder.listFiles();
 
// 遍歷該File陣列，得到每一個File物件
for (File file : fileArray) {
// System.out.println(file);
// E:\評書\三國演義\三國演義_001_[評書網-今天很高興,明天就IO了]_桃園三結義.avi
// 改後：E:\評書\三國演義\001_桃園三結義.avi
String name = file.getName(); // 三國演義_001_[評書網-今天很高興,明天就IO了]_桃園三結義.avi
 
int index = name.indexOf("_");
String numberString = name.substring(index + 1, index + 4);
// System.out.println(numberString);
 
// int startIndex = name.lastIndexOf('_');
// int endIndex = name.lastIndexOf('.');
// String nameString = name.substring(startIndex + 1, endIndex);
// System.out.println(nameString);
int endIndex = name.lastIndexOf('_');
String nameString = name.substring(endIndex);
 
String newName = numberString.concat(nameString); // 001_桃園三結義.avi
// System.out.println(newName);
 
File newFile = new File(srcFolder, newName); // E:\\評書\\三國演義\\001_桃園三結義.avi
 
// 重新命名即可
file.renameTo(newFile);
}
}
}
 
遞迴

 
遞迴解決問題的思想
   找到出口
   找到規律
求階乘案例
  普通for迴圈
  遞迴實現
  畫記憶體圖
  斷點檢視執行流程
 
遞迴
方法定義中呼叫方法本身的現象
 
Public void show(){
  Show();
  System.exit(0);
  return;
}
 
遞迴注意實現
  要有出口，否則就是死遞迴
  次數不能太多，否則就記憶體溢位
  構造方法不能遞迴使用
 
/*
 * 遞迴：方法定義中呼叫方法本身的現象
 *
 * 方法的巢狀呼叫，這不是遞迴。
 * Math.max(Math.max(a,b),c);
 *
 * public void show(int n) {
 * if(n <= 0) {
 * System.exit(0);
 * }
 * System.out.println(n);
 * show(--n);
 * }
 *
 * 注意事項：
 * A:遞迴一定要有出口，否則就是死遞迴
 * B:遞迴的次數不能太多，否則就記憶體溢位
 * C:構造方法不能遞迴使用
 *
 * 舉例：
 * A:從前有座山，山裡有座廟，廟裡有個老和尚和小和尚，老和尚在給小和尚講故事，故事是：
 * 從前有座山，山裡有座廟，廟裡有個老和尚和小和尚，老和尚在給小和尚講故事，故事是：
 * 從前有座山，山裡有座廟，廟裡有個老和尚和小和尚，老和尚在給小和尚講故事，故事是：
 * 從前有座山，山裡有座廟，廟裡有個老和尚和小和尚，老和尚在給小和尚講故事，故事是：
 * ...
 * 廟掛了,或者山崩了
 * B:學程式設計  -- 高薪就業 -- 掙錢 -- 娶媳婦 -- 生娃娃 -- 放羊 -- 掙學費
 *  學程式設計  -- 高薪就業 -- 掙錢 -- 娶媳婦 -- 生娃娃 -- 放羊 -- 掙學費
 * 學程式設計  -- 高薪就業 -- 掙錢 -- 娶媳婦 -- 生娃娃 -- 放羊 -- 掙學費
 * 學程式設計  -- 高薪就業 -- 掙錢 -- 娶媳婦 -- 生娃娃 -- 放羊 -- 掙學費
 * ...
 * 娶不到媳婦或者生不了娃娃
 */
public class DiGuiDemo {
// public DiGuiDemo() {
// DiGuiDemo();
// }
}
 
 
 
 
 
 
遞迴的思路

 
 
記憶體圖

 
/*
 * 需求：請用程式碼實現求5的階乘。
 * 下面的知識要知道：
 * 5! = 1*2*3*4*5
 * 5! = 5*4!
 *
 * 有幾種方案實現呢?
 * A:迴圈實現
 * B:遞迴實現
 * a:做遞迴要寫一個方法
 * b:出口條件
 * c:規律
 */
public class DiGuiDemo {
public static void main(String[] args) {
int jc = 1;
for (int x = 2; x <= 5; x++) {
jc *= x;
}
System.out.println("5的階乘是：" + jc);
System.out.println("5的階乘是："+jieCheng(5));
}
/*
 * 做遞迴要寫一個方法:
 * 返回值型別：int
 * 引數列表：int n
 * 出口條件:
 * if(n == 1) {return 1;}
 * 規律: 
 * if(n != 1) {return n*方法名(n-1);}
 */
public static int jieCheng(int n){
if(n==1){
return 1;
}else {
return n*jieCheng(n-1);
}
}
}
 
 
案例

請大家把E:\JavaSE目錄下所有的java結尾的檔案的絕對路徑給輸出在控制檯。

/*
 * 需求：請大家把E:\JavaSE目錄下所有的java結尾的檔案的絕對路徑給輸出在控制檯。
 *
 * 分析：
 * A:封裝目錄
 * B:獲取該目錄下所有的檔案或者資料夾的File陣列
 * C:遍歷該File陣列，得到每一個File物件
 * D:判斷該File物件是否是資料夾
 * 是：回到B
 * 否：繼續判斷是否以.java結尾
 * 是：就輸出該檔案的絕對路徑
 * 否：不搭理它
 */
public class FilePathDemo {
public static void main(String[] args) {
// 封裝目錄
File srcFolder = new File("E:\\JavaSE");
 
// 遞迴功能實現
getAllJavaFilePaths(srcFolder);
}
 
private static void getAllJavaFilePaths(File srcFolder) {
// 獲取該目錄下所有的檔案或者資料夾的File陣列
File[] fileArray = srcFolder.listFiles();
 
// 遍歷該File陣列，得到每一個File物件
for (File file : fileArray) {
// 判斷該File物件是否是資料夾
if (file.isDirectory()) {
getAllJavaFilePaths(file);
} else {
// 繼續判斷是否以.java結尾
if (file.getName().endsWith(".java")) {
// 就輸出該檔案的絕對路徑
System.out.println(file.getAbsolutePath());
}
}
}
}
}
 
 
 
遞迴刪除帶內容的目錄

/*
 * 需求：遞迴刪除帶內容的目錄
 *
 * 目錄我已經給定：demo
 *
 * 分析：
 * A:封裝目錄
 * B:獲取該目錄下的所有檔案或者資料夾的File陣列
 * C:遍歷該File陣列，得到每一個File物件
 * D:判斷該File物件是否是資料夾
 * 是：回到B
 * 否：就刪除
 */
public class FileDeleteDemo {
public static void main(String[] args) {
// 封裝目錄
File srcFolder = new File("demo");
// 遞迴實現
deleteFolder(srcFolder);
}
 
private static void deleteFolder(File srcFolder) {
// 獲取該目錄下的所有檔案或者資料夾的File陣列
File[] fileArray = srcFolder.listFiles();
 
if (fileArray != null) {
// 遍歷該File陣列，得到每一個File物件
for (File file : fileArray) {
// 判斷該File物件是否是資料夾
if (file.isDirectory()) {
deleteFolder(file);
} else {
System.out.println(file.getName() + "---" + file.delete());
}
}
 
System.out
.println(srcFolder.getName() + "---" + srcFolder.delete());
}
}
}
IO流概述

IO流用來處理裝置之間的資料傳輸
   上傳檔案和下載檔案
Java對資料的操作是通過流的方式
Java用於操作流的物件都在IO包中
 
 
IO流分類

按照資料流向
   輸入流	讀入資料
   輸出流	寫出資料
按照資料型別
   位元組流
   字元流
什麼情況下使用哪種流呢?
   如果資料所在的檔案通過windows自帶的記事本開啟並能讀懂裡面的內容，就用字元流。其他用位元組流。
  如果你什麼都不知道，就用位元組流
 
 
IO流常用基類

位元組流的抽象基類：
InputStream ，OutputStream。
字元流的抽象基類：
Reader ， Writer。
注：由這四個類派生出來的子類名稱都是以其父類名作為子類名的字尾。
如：InputStream的子類FileInputStream。
如：Reader的子類FileReader。
 
位元組流寫資料

 
OutputStream
    FileOutputStream
往一個文字檔案中寫一句話：”helloworld”
    分析發現其實更適合用字元流，但是由於位元組流先出現，所以，我們考慮先使用位元組流後面再講會什麼出現字元流。
FileOutputStream的構造方法
FileOutputStream(File file)
FileOutputStream(String name)
 
 
/*
 * IO流的分類：
 * 流向：
 * 輸入流讀取資料
 * 輸出流 寫出資料
 * 資料型別：
 * 位元組流
 * 位元組輸入流讀取資料InputStream
 * 位元組輸出流寫出資料OutputStream
 * 字元流
 * 字元輸入流讀取資料Reader
 * 字元輸出流寫出資料Writer
 *
 * 注意：一般我們在探討IO流的時候，如果沒有明確說明按哪種分類來說，預設情況下是按照資料型別來分的。
 *
 * 需求：我要往一個文字檔案中輸入一句話："hello,io"
 *
 * 分析：
 * A:這個操作最好是採用字元流來做，但是呢，字元流是在位元組流之後才出現的，所以，今天我先講解位元組流如何操作。
 * B:由於我是要往檔案中寫一句話，所以我們要採用位元組輸出流。
 *
 * 通過上面的分析後我們知道要使用：OutputStream
 * 但是通過檢視API，我們發現該流物件是一個抽象類，不能例項化。
 * 所以，我們要找一個具體的子類。
 * 而我們要找的子類是什麼名字的呢?這個時候，很簡單，我們回想一下，我們是不是要往檔案中寫東西。
 * 檔案是哪個單詞：File
 * 然後用的是位元組輸出流，聯起來就是：FileOutputStream
 * 注意：每種基類的子類都是以父類名作為字尾名。
 * XxxOutputStream
 * XxxInputStream
 * XxxReader
 * XxxWriter
 * 檢視FileOutputStream的構造方法：
 * FileOutputStream(File file)
 *FileOutputStream(String name)
 *
 * 位元組輸出流操作步驟：
 * A:建立位元組輸出流物件
 * B:寫資料
 * C:釋放資源
 */
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
// 建立位元組輸出流物件
// FileOutputStream(File file)
// File file = new File("fos.txt");
// FileOutputStream fos = new FileOutputStream(file);
// FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
 * 建立位元組輸出流物件了做了幾件事情：
 * A:呼叫系統功能去建立檔案
 * B:建立fos物件
 * C:把fos物件指向這個檔案
 */
//寫資料
fos.write("hello,IO".getBytes());
fos.write("java".getBytes());
//釋放資源
//關閉此檔案輸出流並釋放與此流有關的所有系統資源。
fos.close();
/*
 * 為什麼一定要close()呢?
 * A:讓流物件變成垃圾，這樣就可以被垃圾回收器回收了
 * B:通知系統去釋放跟該檔案相關的資源
 */
//java.io.IOException: Stream Closed
//fos.write("java".getBytes());
}
}
 
位元組流寫資料的方式

public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)
 
 
/*
 * 位元組輸出流操作步驟：
 * A:建立位元組輸出流物件
 * B:呼叫write()方法
 * C:釋放資源
 *
 * public void write(int b):寫一個位元組
 * public void write(byte[] b):寫一個位元組陣列
 * public void write(byte[] b,int off,int len):寫一個位元組陣列的一部分
 */
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 建立位元組輸出流物件
// OutputStream os = new FileOutputStream("fos2.txt"); // 多型
FileOutputStream fos = new FileOutputStream("fos2.txt");
 
// 呼叫write()方法
//fos.write(97); //97 -- 底層二進位制資料-- 通過記事本開啟 -- 找97對應的字元值 -- a
// fos.write(57);
// fos.write(55);
//public void write(byte[] b):寫一個位元組陣列
byte[] bys={97,98,99,100,101};
fos.write(bys);
//public void write(byte[] b,int off,int len):寫一個位元組陣列的一部分
fos.write(bys,1,3);
//釋放資源
fos.close();
}
}
 
 
位元組流寫資料常見問題

資料寫成功後，為什麼要close()?
如何實現資料的換行?
如何實現資料的追加寫入?
 
/*
 * 如何實現資料的換行?
 * 為什麼現在沒有換行呢?因為你只寫了位元組資料，並沒有寫入換行符號。
 * 如何實現呢?寫入換行符號即可唄。
 * 剛才我們看到了有寫文字檔案開啟是可以的，通過windows自帶的那個不行，為什麼呢?
 * 因為不同的系統針對不同的換行符號識別是不一樣的?
 * windows:\r\n
 * linux:\n
 * Mac:\r
 * 而一些常見的個高階記事本，是可以識別任意換行符號的。
 *
 * 如何實現資料的追加寫入?
 * 用構造方法帶第二個引數是true的情況即可
 */
public class FileOutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 建立位元組輸出流物件
// FileOutputStream fos = new FileOutputStream("fos3.txt");
// 建立一個向具有指定 name 的檔案中寫入資料的輸出檔案流。如果第二個引數為 true，則將位元組寫入檔案末尾處，而不是寫入檔案開始處。
FileOutputStream fos = new FileOutputStream("fos3.txt", true);
 
// 寫資料
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\r\n".getBytes());
}
 
// 釋放資源
fos.close();
}
}
 
 
 
 
 
 
 
 
異常處理

 
/*
 * 加入異常處理的位元組輸出流操作
 */
public class FileOutputStreamDemo4 {
public static void main(String[] args) {
// 分開做異常處理
// FileOutputStream fos = null;
// try {
// fos = new FileOutputStream("fos4.txt");
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }
//
// try {
// fos.write("java".getBytes());
// } catch (IOException e) {
// e.printStackTrace();
// }
//
// try {
// fos.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
 
// 一起做異常處理
// try {
// FileOutputStream fos = new FileOutputStream("fos4.txt");
// fos.write("java".getBytes());
// fos.close();
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// } catch (IOException e) {
// e.printStackTrace();
// }
 
// 改進版
// 為了在finally裡面能夠看到該物件就必須定義到外面，為了訪問不出問題，還必須給初始化值
FileOutputStream fos = null;
try {
// fos = new FileOutputStream("z:\\fos4.txt");
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果fos不是null，才需要close()
if (fos != null) {
// 為了保證close()一定會執行，就放到這裡了
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
 
位元組流讀取資料

inputStream
   FileInputStream
把剛才寫的資料讀取出來顯示在控制檯
FileInputStream的構造方法
  FileInputStream(File file)
  FileInputStream(String name)
FileInputStream的成員方法
  public int read()
  public int read(byte[] b)
 
 
/*
 * 位元組輸入流操作步驟：
 * A:建立位元組輸入流物件
 * B:呼叫read()方法讀取資料，並把資料顯示在控制檯
 * C:釋放資源
 *
 * 讀取資料的方式：
 * A:int read():一次讀取一個位元組
 * B:int read(byte[] b):一次讀取一個位元組陣列
 */
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
// FileInputStream(String name)
// FileInputStream fis = new FileInputStream("fis.txt");
FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
 
// // 呼叫read()方法讀取資料，並把資料顯示在控制檯
// // 第一次讀取
// int by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
//
// // 第二次讀取
// by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
//
// // 第三次讀取
// by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
// // 我們發現程式碼的重複度很高，所以我們要用迴圈改進
// // 而用迴圈，最麻煩的事情是如何控制迴圈判斷條件呢?
// // 第四次讀取
// by = fis.read();
// System.out.println(by);
// // 第五次讀取
// by = fis.read();
// System.out.println(by);
// //通過測試，我們知道如果你讀取的資料是-1，就說明已經讀取到檔案的末尾了
 
// 用迴圈改進
// int by = fis.read();
// while (by != -1) {
// System.out.print((char) by);
// by = fis.read();
// }
 
// 最終版程式碼
int by = 0;
// 讀取，賦值，判斷
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
 
// 釋放資源
fis.close();
}
}
 
 
 
 
 
把當前專案目錄下的a.txt內容複製到當前專案目錄下的b.txt中

 
/*
 * 複製文字檔案。
 *
 * 資料來源：從哪裡來
 * a.txt--讀取資料--FileInputStream
 *
 * 目的地：到哪裡去
 * b.txt--寫資料--FileOutputStream
 *
 * java.io.FileNotFoundException: a.txt (系統找不到指定的檔案。)
 *
 * 這一次複製中文沒有出現任何問題，為什麼呢?
 * 上一次我們出現問題的原因在於我們每次獲取到一個位元組資料，就把該位元組資料轉換為了字元資料，然後輸出到控制檯。
 * 而這一次呢?確實通過IO流讀取資料，寫到文字檔案，你讀取一個位元組，我就寫入一個位元組，你沒有做任何的轉換。
 * 它會自己做轉換。
 */
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封裝資料來源
FileInputStream fis = new FileInputStream("a.txt");
// 封裝目的地
FileOutputStream fos = new FileOutputStream("b.txt");
 
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
 
// 釋放資源(先關誰都行)
fos.close();
fis.close();
}
}
 
把c盤下的a.txt的內容複製到d盤下的b.txt中

 
/*
 * 需求：把c盤下的a.txt的內容複製到d盤下的b.txt中
 *
 * 資料來源：
 * c:\\a.txt--讀取資料--FileInputStream
 * 目的地：
 * d:\\b.txt--寫出資料--FileOutputStream
 */
public class CopyFileDemo2 {
public static void main(String[] args) throws IOException {
// 封裝資料來源
FileInputStream fis = new FileInputStream("c:\\a.txt");
// 封裝目的地
FileOutputStream fos = new FileOutputStream("d:\\b.txt");
 
// 複製資料
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
 
// 釋放資源
fos.close();
fis.close();
}
}
 
 
 
 
把e:\\林青霞.jpg內容複製到當前專案目錄下的mn.jpg中

/*
 * 需求：把e:\\林青霞.jpg內容複製到當前專案目錄下的mn.jpg中
 *
 * 資料來源：
 * e:\\林青霞.jpg--讀取資料--FileInputStream
 * 目的地：
 * mn.jpg--寫出資料--FileOutputStream
 */
public class CopyImageDemo {
public static void main(String[] args) throws IOException {
// 封裝資料來源
FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
// 封裝目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
 
// 複製資料
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
 
// 釋放資源
fos.close();
fis.close();
}
}
 
 
複製視訊

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
/*
 * 需求：把e:\\哥有老婆.mp4複製到當前專案目錄下的copy.mp4中
 *
 * 資料來源：
 * e:\\哥有老婆.mp4--讀取資料--FileInputStream
 * 目的地：
 * copy.mp4--寫出資料--FileOutputStream
 */
public class CopyMp4Demo {
public static void main(String[] args) throws IOException {
// 封裝資料來源
FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
// 封裝目的地
FileOutputStream fos = new FileOutputStream("copy.mp4");
 
// 複製資料
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
 
// 釋放資源
fos.close();
fis.close();
}
}
一次一個陣列讀取

 
import java.io.FileInputStream;
import java.io.IOException;
 
/*
 * 一次讀取一個位元組陣列：int read(byte[] b)
 * 返回值其實是實際讀取的位元組個數。
 */
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 建立位元組輸入流物件
// FileInputStream fis = new FileInputStream("fis2.txt");
FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
 
// 讀取資料
// 定義一個位元組陣列
// 第一次讀取
// byte[] bys = new byte[5];
// int len = fis.read(bys);
// // System.out.println(len);
// // System.out.println(new String(bys));
// // System.out.println(new String(bys, 0, len));
// System.out.print(new String(bys, 0, len));
//
// // 第二次讀取
// len = fis.read(bys);
// // System.out.println(len);
// // System.out.println(new String(bys));
// // System.out.println(new String(bys, 0, len));
// System.out.print(new String(bys, 0, len));
//
// // 第三次讀取
// len = fis.read(bys);
// // System.out.println(len);
// // System.out.println(new String(bys));
// // System.out.println(new String(bys, 0, len));
// System.out.print(new String(bys, 0, len));
//
// // 第四次讀取
// len = fis.read(bys);
// // System.out.println(len);
// // System.out.println(new String(bys, 0, len));
// System.out.print(new String(bys, 0, len));
// // 程式碼重複了，用迴圈改進
// // 但是，我不知道結束條件
// // len = fis.read(bys);
// // System.out.println(len);
// // len = fis.read(bys);
// // System.out.println(len);
// // 如果讀取到的實際長度是-1，就說明沒有資料了
 
// byte[] bys = new byte[115]; // 0
// int len = 0;
// while ((len = fis.read(bys)) != -1) {
// System.out.print(new String(bys, 0, len));
// // System.out.print(new String(bys)); //千萬要帶上len的使用
// }
 
// 最終版程式碼
// 陣列的長度一般是1024或者1024的整數倍
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
 
// 釋放資源
fis.close();
}
}
 
 
 
 
 
 
 
 
 
 
二次比較

 
 
 
位元組流讀取資料兩種方式圖解比較

一次讀取一個位元組
一次讀取一個位元組陣列
每次可以讀取多個數據，提高了操作效率
 
字元陣列讀取

/*
 * 需求：把c:\\a.txt內容複製到d:\\b.txt中
 *
 * 資料來源：
 * c:\\a.txt--讀取資料--FileInputStream
 * 目的地：
 * d:\\b.txt--寫出資料--FileOutputStream
 */
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封裝資料來源
FileInputStream fis = new FileInputStream("c:\\a.txt");
FileOutputStream fos = new FileOutputStream("d:\\b.txt");
 
// 複製資料
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
 
// 釋放資源
fos.close();
fis.close();
}
}
 
 

mp4複製到當前專案目錄下的copy.mp4

 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
/*
 * 需求：把e:\\哥有老婆.mp4複製到當前專案目錄下的copy.mp4中
 *
 * 資料來源：
 * e:\\哥有老婆.mp4--讀取資料--FileInputStream
 * 目的地：
 * copy.mp4--寫出資料--FileOutputStream
 */
public class CopyMp4Demo {
public static void main(String[] args) throws IOException {
// 封裝資料來源
FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
// 封裝目的地
FileOutputStream fos = new FileOutputStream("copy.mp4");
 
// 複製資料
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
 
// 釋放資源
fos.close();
fis.close();
}
}
 
 
位元組緩衝流

位元組流一次讀寫一個數組的速度明顯比一次讀寫一個位元組的速度快很多，這是加入了陣列這樣的緩衝區效果，java本身在設計的時候，也考慮到了這樣的設計思想(裝飾設計模式後面講解)，所以提供了位元組緩衝區流
 
 
位元組緩衝輸出流
   BufferedOutputStream
位元組緩衝輸入流
  BufferedInputStream
 
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
/*
 * 通過定義陣列的方式確實比以前一次讀取一個位元組的方式快很多，所以，看來有一個緩衝區還是非常好的。
 * 既然是這樣的話，那麼，java開始在設計的時候，它也考慮到了這個問題，就專門提供了帶緩衝區的位元組類。
 * 這種類被稱為：緩衝區類(高效類)
 * 寫資料：BufferedOutputStream
 * 讀資料：BufferedInputStream
 *
 * 構造方法可以指定緩衝區的大小，但是我們一般用不上，因為預設緩衝區大小就足夠了。
 *
 * 為什麼不傳遞一個具體的檔案或者檔案路徑，而是傳遞一個OutputStream物件呢?
 * 原因很簡單，位元組緩衝區流僅僅提供緩衝區，為高效而設計的。但是呢，真正的讀寫操作還得靠基本的流物件實現。
 */
public class BufferedOutputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 簡單寫法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
 
// 寫資料
bos.write("hello".getBytes());
 
// 釋放資源
bos.close();
}
}
 
讀資料操作

/*
 * 注意：雖然我們有兩種方式可以讀取，但是，請注意，這兩種方式針對同一個物件在一個程式碼中只能使用一個。
 */
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"bos.txt"));
 
// 讀取資料
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
 
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
 
// 釋放資源
bis.close();
}
}
 
 
 
 
 
 
 
 
 
 
 
 
四種讀寫的比較

/*
 * 需求：把e:\\哥有老婆.mp4複製到當前專案目錄下的copy.mp4中
 *
 * 位元組流四種方式複製檔案：
 * 基本位元組流一次讀寫一個位元組：共耗時：117235毫秒
 * 基本位元組流一次讀寫一個位元組陣列： 共耗時：156毫秒
 * 高效位元組流一次讀寫一個位元組： 共耗時：1141毫秒
 * 高效位元組流一次讀寫一個位元組陣列： 共耗時：47毫秒
 */
public class CopyMp4Demo {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// method1("e:\\哥有老婆.mp4", "copy1.mp4");
// method2("e:\\哥有老婆.mp4", "copy2.mp4");
// method3("e:\\哥有老婆.mp4", "copy3.mp4");
method4("e:\\哥有老婆.mp4", "copy4.mp4");
long end = System.currentTimeMillis();
System.out.println("共耗時：" + (end - start) + "毫秒");
}
 
// 高效位元組流一次讀寫一個位元組陣列：
public static void method4(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
 
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
 
bos.close();
bis.close();
}
 
// 高效位元組流一次讀寫一個位元組：
public static void method3(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
 
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
 
}
 
bos.close();
bis.close();
}
 
// 基本位元組流一次讀寫一個位元組陣列
public static void method2(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
 
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
 
fos.close();
fis.close();
}
 
// 基本位元組流一次讀寫一個位元組
public static void method1(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
 
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
 
fos.close();
fis.close();
}
}
 
總結

1:遞迴(理解)
(1)方法定義中呼叫方法本身的現象
舉例：老和尚給小和尚講故事，我們學程式設計
(2)遞迴的注意事項；
A:要有出口，否則就是死遞迴
B:次數不能過多，否則記憶體溢位
C:構造方法不能遞迴使用
(3)遞迴的案例：
A:遞迴求階乘
C:遞迴輸出指定目錄下所有指定字尾名的檔案絕對路徑
D:遞迴刪除帶內容的目錄(小心使用)
 
2:IO流(掌握)
(1)IO用於在裝置間進行資料傳輸的操作
(2)分類：
A:流向
輸入流	讀取資料
輸出流	寫出資料
B:資料型別
位元組流
位元組輸入流
位元組輸出流
字元流
字元輸入流
字元輸出流
注意：
a:如果我們沒有明確說明按照什麼分，預設按照資料型別分。
b:除非檔案用windows自帶的記事本開啟我們能夠讀懂，才採用字元流，否則建議使用位元組流。
(3)FileOutputStream寫出資料
A:操作步驟
a:建立位元組輸出流物件
b:呼叫write()方法
c:釋放資源
B:程式碼體現：
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("hello".getBytes());
fos.close();
C:要注意的問題?
a:建立位元組輸出流物件做了幾件事情?
b:為什麼要close()?
c:如何實現資料的換行?
d:如何實現資料的追加寫入?
(4)FileInputStream讀取資料
A:操作步驟
 
 
作業
晚上作業一個碟符裡面有一張圖片拷貝另一個碟符裡面（4種方式）