【無標題】

Lambda

一、使用Lambda必須具有接口 且要求接口中有且僅有一個抽象方法
二、有且僅有一個抽象方法的接口稱為函數式接口
三、Lambda錶達式的標准格式： 一些參數、一個箭頭、一段代碼
四、格式：(參數列錶)->{一些重寫方法的代碼};

解釋說明格式：
()：接口中抽象方法的參數列錶 沒有參數 就空著 有參數就寫出參數 多個參數使用逗號分隔
->：傳遞的意思 把參數傳遞給方法體{}
{}：重寫接口的抽象方法的方法體

五、Lambda錶達式是可以推導 可以省略的 凡是根據上下文推導出來的內容 都可以省略書寫

可以省略的內容：

1. （參數列錶）：括號中參數列錶的數據類型 可以省略不寫
2. （參數列錶）：括號中的參數如果只有一個 那麼類型和()都可以省略
3. （一些代碼）：如果{}中的代碼只有一行 無論是否有返回值 都可以省略{}return分號。【注】：要省略{} return 分號必須一起省略

六、題目：給定一個廚子cook接口 內含唯一的抽象方法makefood 且無參數 無返回值 使用Lambda的標准格式調用invokeCook方法 打印輸出“吃飯啦！”

public class LambdaClass {
    
	public static void main(String[] args) {
    
		//使用Lambda錶達式 簡化匿名內部類的書寫
		invokeCook(()->{
    
			System.out.println("吃飯了！");
		});
	}
	
	//定義一個方法 參數傳遞Cook接口 方法內部調用Cook接口中的方法makeFood
	public static void invokeCook(Cook cook) {
    
		cook.makeFood();
	}
}
public interface Cook {
    
	//定義無參數無返回值的方法makeFood
	public abstract void makeFood();
}

Lambda錶達式有參數有返回值的練習

需求：使用數組存儲多個Person對象 對數組中的Person對象使用Arrays的sort方法通過年齡進行昇序排序

import java.util.Arrays;
import java.util.Comparator;
public class LambdaArrays {
    
	public static void main(String[] args) {
    
		//使用數組存儲多個Person對象
		Person[] arr = {
    
				new Person("柳岩",38),new Person("迪麗熱巴",18),new Person("古力娜紮",19),
		};
		//對數組中的Person對象使用Arrays的sort方法通過年齡進行昇序排序
// Arrays.sort(arr,new Comparator<Person>() {
    
// @Override
// public int compare(Person o1, Person o2) {
    
// return o1.getAge() - o2.getAge();
// } 
// });
		
		//使用Lambda錶達式 簡化匿名內部類
		Arrays.sort(arr,(Person o1, Person o2)->{
    
			return o1.getAge() - o2.getAge();
		});
		//遍曆數組
		for (Person person : arr) {
    
			System.out.println(person);
		}
		
		System.out.println("有參數有返回值的類型：===================================================");
		
		//調用invokeCalc方法 方法的參數是一個接口 可以使用匿名內部類
// invokeCalc(10, 20, new Calculator() {
    
// @Override
// public int calc(int a, int b) {
    
// return a + b;
// }
// });
		
		//使用Lambda錶達式簡化匿名內部類的書寫
		invokeCalc(120, 130, (int a,int b)->{
    
			return a + b;
		});
	}
	
	//定義一個方法 參數傳遞兩個int類型的整數 參數傳遞calculator接口 方法內部調用calculator中的方法calc計算兩個整數的和
	public static void invokeCalc(int a,int b,Calculator c) {
    
		int sum = c.calc(a, b);
		System.out.println(sum);
	}
}

public class Person {
    
	private String nameString;
	private int age;
	
	@Override
	public String toString() {
    return "Person [nameString=" + nameString + ", age=" + age + "]";}
	public Person(String nameString, int age) {
    
		super();
		this.nameString = nameString;
		this.age = age;
	}
	public Person() {
    super();}
	public String getNameString() {
    return nameString;}
	public void setNameString(String nameString) {
    this.nameString = nameString;}
	public int getAge() {
    return age;}
	public void setAge(int age) {
    this.age = age;}
}
/* * 給定一個計算器Calculator接口 內含抽象方法calc可以將兩個int數字相加得到和 使用Lambda的標准格式調用invokeCalc方法 完成120和130的相加計算 */
public interface Calculator {
    
	public abstract int calc(int a,int b);
}

遞歸

一、遞歸：指在當前方法內調用自己
二、遞歸分為兩類：直接遞歸（方法自身調用自己）間接遞歸（A方法調用B方法 B方法調用C方法 C方法調用A方法）

【注】：

1. 遞歸一定要有條件限定 保證遞歸能够停止下來 否則會發生棧內存溢出
2. 在遞歸中雖然有限定條件 但是遞歸次數不能太多 否則也會發生棧內存溢出
3. 構造方法禁止遞歸

三、遞歸的使用前提：當調用方法時 方法的主體不變 每次調用方法的參數不同 可以使用遞歸

public class DiGui {
    
	public static void main(String[] args) {
    
		//a();
		b(1);
	}
	
	/* * 在遞歸中雖然有限定條件 但是遞歸次數不能太多 否則也會發生棧內存溢出 * Exception in thread "main" java.lang.StackOverflowError * */
	private static void b(int i) {
    
		System.out.println(i);
		if (i == 20000) {
    
			return;//結束方法
		}
		b(++i);
	}

	/* * 遞歸一定要有條件限制 保證遞歸能够停下來 否則會發生棧內存溢出 * Exception in thread "main" java.lang.StackOverflowError * a方法會在棧內存中一直調用a方法 就會導致棧內存中有無數多個a方法 方法太多了 超出棧內存的大小 就會導致內存溢出的錯誤 * 【注】：當一個方法調用其他方法的時候 被調用的方法沒有執行完畢 當前方法會一直等待調用的方法執行完畢 才會繼續執行 */
	private static void a() {
    
		System.out.println("a方法！");
		a();
	}
	
	/* * 構造方法禁止遞歸 * 編譯報錯：構造方法是創建對象使用的 一直遞歸會導致內存中有無數多個對象 所以直接編譯就報錯了 */
	public void Recurison() {
    
		//Recurison();
	}
}

java.io.File

一、java.io.File類：文件和目錄路徑名的抽象錶示形式
二、java把電腦中的文件和文件夾（目錄）封裝為了一個file類 我們可以使用file類對文件和文件夾進行操作
三、我們可以使用file類的方法：創建一個文件/文件夾 删除文件/文件夾 獲取文件/文件夾 判斷文件/文件夾是否存在 對文件夾進行遍曆 獲取文件的大小
四、file類是一個與系統無關的類 任何的操作系統都可以使用這個類中的方法
五、重點：記住以下單詞：file文件 directory文件夾（目錄） path路徑

1. 路徑：
   （1）絕對路徑：是一個完整的路徑 以盤符（c:，d:）開始的路徑。如：c:\\a.txt d:\\demo\\b.txt、c:\\users\itcast\\ideaProjects\\shungyuan\\123.txt
   （2）相對路徑：是一個簡化的路徑。相對指的是相對於當前項目的根目錄（c:\\users\itcast\\ideaProjects\\shungyuan）。如果使用當前項目的根目錄 路徑可以簡化書寫：c:\\users\itcast\\ideaProjects\\shungyuan\\123.txt簡化為123.txt（可以省略項目的根目錄）

【注】：

1. 路徑是不區分大小寫
2. 路徑中的文件名稱分隔符Windows使用反斜杠/ 反斜杠是轉義字符 兩個反斜杠代錶一個普通的反斜杠

import java.io.File;
public class FileClass {
    
	public static void main(String[] args) {
    
		/* * static String pathSeparator:與系統有關的路徑分隔符 為了方便 他被錶示為一個字符串 * static char pathSeparator:與系統有關的路徑分隔符 * static String separator:與系統有關的默認名稱分隔符 為了方便 他被錶示為一個字符串 * static char separatorChar:與系統有關的默認名稱分隔符 */
		String pathSeparatorString = File.pathSeparator;
		System.out.println(pathSeparatorString);//;路徑分隔符 windows:分號； linux:冒號：
		
		String separetorString = File.separator;
		System.out.println(separetorString);//文件名稱分隔符\ Windows：反斜杠\ Linux：正斜杠\
		/* * 使用File.separator時 不能因為Windows：反斜杠\ Linux：正斜杠\ 在操作路徑時 就直接寫： * 在Windows系統：c:\develop\a\a.txt或者： * 在Linux系統：c:/develop/a/a.txt * 因為如果這樣寫的話 在Windows中可以操作 但是如果項目拿到Linux中 就不能操作了 * 所以 要這樣寫： * "c:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt" */
		show01();
		//show02("c:\\","a.txt");//c:\a.txt
		show02("d:\\","a.txt");//d:\a.txt
		show03();
	}

	/* * file類的構造方法： * File(String parent,String child):根據parent路徑名字符串和child路徑名字符串創建一個新file實例 * 參數：把路徑分成了兩個部分 * String parent:父路徑 * String child:子路徑 * 好處： * 1.父路徑和子路徑可以單獨書寫 使用起來非常靈活 父路徑和子路徑都可以變化 * 2.父路徑是file類型 可以使用file的方法對路徑進行一些操作 再使用路徑創建對象 */
	private static void show03() {
    
		File parentFile = new File("c:\\");
		File file = new File(parentFile,"hello.java");
		System.out.println(file);
	}

	/* * file類的構造方法： * File(String parent,String child):根據parent路徑名字符串和child路徑名字符串創建一個新file實例 * 參數：把路徑分成了兩個部分 * String parent:父路徑 * String child:子路徑 * 好處：父路徑和子路徑可以單獨書寫 使用起來非常靈活 父路徑和子路徑都可以變化 */
	private static void show02(String parentString,String childString) {
    
		File file = new File(parentString,childString);
		System.out.println(file);
	}

	/* * file類的構造方法： * file(String pathname):通過將給定路徑名字符串轉換為抽象路徑名來創建一個新file實例 * 參數： * String pathname:字符串的路徑名稱 * 路徑可以以文件、文件夾結尾 * 路徑可以是相對路徑 絕對路徑 * 路徑可以是存在 也可以是不存在 * 創建file對象 只是把字符串路徑封裝為file對象 不考慮路徑的真假情况 */
	private static void show01() {
    
		File f1 = new File("D:\\JAVA\\source.a.txt");//不存在的文件
		System.out.println(f1);//D:\JAVA\source.a.txt
		
		File f2 = new File("D:\\JAVA\\source");//存在的文件夾
		System.out.println(f2);//D:\JAVA\source

		File f3 = new File("Day01");
		System.out.println(f3);//Day01
	}
}

删除

file類創建删除功能的方法：

1. public boolean createNewFile()：當且僅當具有該名稱的文件尚不存在時 創建一個新的空文件
2. public boolean delete()：删除由此file錶示的文件或目錄
3. public boolean mkdir()：創建由此file錶示的目錄
4. public boolean mkdirs()：創建由此file錶示的目錄 包括任何必須但不存在的父目錄

import java.io.File;
import java.io.IOException;
public class FileDelete {
    
	public static void main(String[] args) throws IOException {
    
		show01();
		show02();
		show03();
	}

	/* * public boolean delete():删除由此file錶示的文件或目錄 * 此方法可以删除構造方法路徑中給出的文件/文件夾 * 返回值：布爾值 * true：文件/文件夾删除成功 返回true * false：文件夾中有內容 不會删除返回false 構造方法中路徑不存在false * 【注】：delete方法是直接在硬盤删除文件/文件夾 不走回收站 删除要謹慎 */
	private static void show03() {
    
		File f1 = new File("E:\\正片\\aaa");
		boolean b1 = f1.delete();
		System.out.println(b1);
		File f2 = new File("E:\\正片\\111\\222\\333");
		boolean b2 = f2.delete();
		System.out.println(b2);
	}

	/* * public boolean mkdir()：創建單級空文件夾 * public boolean mkdirs():創建單級空文件夾 多級空文件夾 * 創建文件夾的路徑和名稱在方法中給出（構造方法的參數） * 返回值：布爾值 * true：文件夾不存在 創建文件夾 返回true * false：文件夾存在 不會創建 返回false * 【注】：此方法只能創建文件夾 不能創建文件 */
	private static void show02() {
    
		File f1 = new File("E:\\正片\\aaa");
		boolean b2 = f1.mkdir();
		System.out.println("b2:" + b2);
	
		File f2 = new File("E:\\正片\\111\\222\\333");
		boolean b3 = f2.mkdirs();
		System.out.println("b3:" + b3);//不能創建 因為只能創建單級文件夾
	}

	/* * public boolean createNewFile():當且僅當具有該名稱的文件尚不存在時 創建一個新的空文件 * 創建文件的路徑和名稱在方法中給出（構造方法的參數） * 返回值：布爾值 * true：文件不存在 創建文件 返回true * false：文件存在 不會創建 返回false * 【注】： * 1.此方法只能創建文件 不能創建文件夾 * 2.創建文件的路徑必須存在 否則會拋出异常 * * public boolean createNewFile() throws IOException * createNewFile聲明拋出了IOException 我們調用這個方法 就必須得處理這個异常 要麼throws 要麼try...catch */
	private static void show01() throws IOException {
    
		File f1 = new File("E:\\正片\\1.txt");
		boolean b1 = f1.createNewFile();
		System.out.println("b1:" + b1);
	}
}

獲取

file類獲取功能的方法：

1. public String getAbsolutePath()：返回此file的絕對路徑名字符串
2. public String getPath()：將此file轉換為路徑名字符串
3. public String getName()：返回由此file錶示的文件或目錄的名稱
4. public long Length()：返回由此file錶示的文件的長度

import java.io.File;
public class FileGet {
    
	public static void main(String[] args) {
    
		show01();
		show02();
		show03();
		show04();
	}

	/* * public long Length():返回由此file錶示的文件的長度 * 獲取的是構造方法指定的文件的大小 以字節為單比特 * 【注】：文件夾是沒有大小概念的不能獲取文件夾的大小 * 如果構造方法中給出的路徑不存在 那麼Length方法返回0 */
	private static void show04() {
    
		File f1 = new File("E:\\正片");
		long l1 = f1.length();
		System.out.println(l1);//4096
	}

	/* * public String getName():返回由此file錶示的文件或目錄的名稱 * 獲取的就是構造方法傳遞路徑的結尾部分（文件/文件夾） * */
	private static void show03() {
    
		File f1 = new File("c:\\users\\itcast\\ideaProjects\\shungyuan\\123.txt");
		String nameString = f1.getName();
		System.out.println(nameString);//123.txt

		File f2 = new File("c:\\users\\itcast\\ideaProjects\\shungyuan");
		String nameString2 = f2.getName();
		System.out.println(nameString2);//shungyuan
	}

	/* * public String getPath():將此file轉換為路徑名字符串 * 獲取的構造方法中傳遞的路徑 */
	private static void show02() {
    
		File f1 = new File("c:\\users\\itcast\\ideaProjects\\shungyuan\\123.txt");
		File f2 = new File("a.txt");
		String path1 = f1.getPath();
		System.out.println(path1);//c:\ users\itcast\ideaProjects\shungyuan\123.txt
		String path2 = f2.getPath();
		System.out.println(path2);//a.txt
		
		System.out.println(f1);//c:\ users\itcast\ideaProjects\shungyuan\123.txt
		System.out.println(f1.toString());//c:\ users\itcast\ideaProjects\shungyuan\123.txt
	}

	/* * public String getAbsolutePath():返回此file的絕對路徑名字符串 * 獲取的構造方法中傳遞的路徑 * 無論路徑是絕對的還是相對的 getAbsolutePath方法返回的都是絕對路徑 */
	private static void show01() {
    
		File f1 = new File("c:\\users\\itcast\\ideaProjects\\shungyuan\\123.txt");
		String absolutePath = f1.getAbsolutePath();
		System.out.println(absolutePath);/*c:\ users\itcast\ideaProjects\shungyuan\123.txt*/
		
		File f2 = new File("a.txt");
		String absolutePath2 = f2.getAbsolutePath();
		System.out.println(absolutePath2);//D:\JAVA\source\Day19\a.txt
	}
}

遍曆

file類遍曆（文件夾）目錄功能：

1. public String[] list()：返回一個String數組 錶示該file目錄中的所有子文件或目錄
2. public File[] listFile()：返回一個file數組 錶示該file目錄中的所有子文件或目錄

【注】：

1. list方法和listFile方法遍曆的是構造方法中給出的目錄
2. 如果構造方法中給出的目錄的路徑不存在 會拋出空指針异常
3. 如果構造方法中給出的目錄的路徑不是一個目錄 會拋出空指針异常

import java.io.File;
public class FileFor {
    
	public static void main(String[] args) {
    
		show01();
		show02();
	}

	/* * public File[] listFile():返回一個file數組 錶示該file目錄中的所有子文件或目錄 * 遍曆構造方法中給出的目錄 會獲取目錄中所有文件/文件夾 把文件/文件夾封裝為file對象 多個file對象存儲到file數組中 */
	private static void show02() {
    
		File file = new File("D:\\JAVA\\source");
		File[] files = file.listFiles();
		for (File f : files) {
    
			System.out.println(f);//連隱藏文件夾都會打印輸出
		}
	}

	/* * public String[] list():返回一個String數組 錶示該file目錄中的所有子文件或目錄 * 遍曆構造方法中給出的目錄 會獲取目錄中所有文件/文件夾的名字 把獲取到的多個名稱存儲到一個String類型的數組中 */
	private static void show01() {
    
		File file = new File("D:\\JAVA\\source");
		String[] arr = file.list();
		for (String fileName : arr) {
    
			System.out.println(fileName);//連隱藏文件夾都會打印輸出
		}
	}
}

判斷

file判斷功能的方法：

1. public boolean exists()：此file錶示的文件或目錄是否實際存在
2. public boolean isDirectory()：此file錶示的是否為目錄
3. public boolean isFile()：此file錶示的是否為文件

import java.io.File;
public class FileIs {
    
	public static void main(String[] args) {
    
		show01();
		System.out.println("判斷是否為文件/文件夾：============================");
		show02();
	}

	/* * public boolean isDirectory():此file錶示的是否為目錄 * 用於判斷構造方法中給定的路徑是否以文件夾結尾 * 是：true 否：false * public boolean isFile():此file錶示的是否為文件 * 用於判斷構造方法中給定的路徑是否以文件結尾 * 是：true 否：false * 【注】：電腦的硬盤中只有文件和文件夾 所以兩個方法是互斥的 * 這兩個方法的使用前提：路徑必須是存在的 否則都返回false */
	private static void show02() {
    
		File f1 = new File("c:\\users\\itcast\\ideaProjects\\shungyuan\\123.txt");
		//System.out.println(f1.isDirectory());//false
		//System.out.println(f1.isFile());//false
		//因為這個文件不存在 所以都返回false 所以我們在用這兩個方法時 可以先判斷這個文件到底存不存在
		if (f1.exists()) {
    //不存在就沒必要獲取
			System.out.println(f1.isDirectory());//false
			System.out.println(f1.isFile());//false
		}
		
		File f2 = new File("E:\\正片");
		if (f2.exists()) {
    //不存在就沒必要獲取
			System.out.println(f2.isDirectory());//true
			System.out.println(f2.isFile());//false
		}
	}

	/* * public boolean exists():此file錶示的文件或目錄是否實際存在 * 用於判斷構造方法中的路徑是否存在 存在：true 不存在：false */
	private static void show01() {
    
		File f1 = new File("E:\\正片");
		System.out.println(f1.exists());//true
		File f2 = new File("c:\\users\\itcast\\ideaProjects\\shungyuan\\123.txt");
		System.out.println(f2.exists());//false
	}
}

練習

遍曆打印多級目錄

import java.io.File;
public class Test3 {
    
	public static void main(String[] args) {
    
		File file = new File("C:\\Users\\dc16102111\\Documents\\Tencent Files\\809476070\\FileRecv");
		getAllFile(file);
	}
	
	/* * 定義一個方法 參數傳遞file類型的目錄 * 方法中對目錄進行遍曆 */
	public static void getAllFile(File dir) {
    
		System.out.println(dir);
		File[] files = dir.listFiles();
		for (File f : files) {
    
			if(f.isDirectory()){
    //對遍曆得到的file文件f進行判斷 判斷是否是文件夾
				getAllFile(f);//f是一個文件夾 則繼續遍曆這個文件夾 我們發現 getAllFile方法就是傳遞文件夾 遍曆文件夾的方法 所以直接調用getAllFile方法即可：遞歸 自己調用自己
			} else{
    
					System.out.println(f);//f是一個文件 直接打印即可
			}
		}
	}
}

搜索文件並打印

搜索C:\Users\dc16102111\Documents\Tencent Files\809476070\FileRecv文件中.md結尾的文件 並打印輸出

import java.io.File;
public class Test4 {
    
	public static void main(String[] args) {
    
		File file = new File("C:\\Users\\dc16102111\\Documents\\Tencent Files\\809476070\\FileRecv");
		getAllFile(file);
	}
	
	/* * 定義一個方法 參數傳遞file類型的目錄 * 方法中對目錄進行遍曆 */
	public static void getAllFile(File dir) {
    
		File[] files = dir.listFiles();
		for (File f : files) {
    
			if(f.isDirectory()){
    //對遍曆得到的file文件f進行判斷 判斷是否是文件夾
				getAllFile(f);//f是一個文件夾 則繼續遍曆這個文件夾 我們發現 getAllFile方法就是傳遞文件夾 遍曆文件夾的方法 所以直接調用getAllFile方法即可：遞歸 自己調用自己
			} else{
    
				//f是一個文件 直接打印即可
				//把file對象f轉換為字符串對象
				//String nameString = f.getName();
				//String pathString = f.getPath();
				String string = f.toString();
				//把字符串轉換為小寫 更加方便判斷 比如 假設有.MD結尾的文件 也可以打印輸出
				string = string.toLowerCase();
				//調用String類中的方法endsWith判斷字符串是否是以.java結尾
				boolean b = string.endsWith(".md");
				//如果是 則打印輸出
				if (b) {
    
					System.out.println(f);//f是一個文件 直接打印即可
				}
				/*以上代碼可以簡化為鏈式編程： if (f.getName().toLowerCase().endsWith(".md")) { System.out.println(f);//f是一個文件 直接打印即可 } */
			}
		}
	}
}

過濾器實現

一、搜索C:\Users\dc16102111\Documents\Tencent Files\809476070\FileRecv文件中.md結尾的文件 並打印輸出，可以使用過濾器來實現。
二、在file類中有兩個和ListFiles重載的方法 方法的參數傳遞的就是過濾器

1. File[] listFiles(FileFilter filter)
   （1）java.io.FileFilter接口：用於抽象路徑名（File對象）的過濾器
   （2）作用：用來過濾文件 （File對象）
   （3）抽象方法：用來過濾文件的方法
   （4）boolean accept(File pathname)：測試指定抽象路徑名是否應該包含在某個路徑名列錶中

參數：File pathname：使用ListFiles方法遍曆目錄 得到的每一個文件對象

2. File[] listFiles(FilenameFilter filter)
   （1）java.io.FilenameFilter接口：實現此接口的類實例可用於過濾器文件名
   （2）作用：用於過濾文件的方法
   （3）boolean accept(File dir,String name)：測試指定文件是否應該包含在某一文件列錶中

參數：

1. File dir：構造方法中傳遞的被遍曆的目錄
2. String name：使用ListFiles方法遍曆目錄 獲取的每一個文件/文件夾的名稱

【注】：兩個過濾器接口是沒有實現類的 需要我們自己寫實現類 重寫過濾的方法accept 在方法中自己定義過濾的規則

import java.io.File;
public class Test5 {
    
	public static void main(String[] args) {
    
		File file = new File("C:\\Users\\dc16102111\\Documents\\Tencent Files\\809476070\\FileRecv");
		getAllFile(file);
	}
		
	/* * 定義一個方法 參數傳遞file類型的目錄 * 方法中對目錄進行遍曆 */
	public static void getAllFile(File dir) {
    
		File[] files = dir.listFiles(new FileFilterImpl());//傳遞過濾器對象
		for (File f : files) {
    
			if(f.isDirectory()){
    //對遍曆得到的file文件f進行判斷 判斷是否是文件夾
				getAllFile(f);//f是一個文件夾 則繼續遍曆這個文件夾 我們發現 getAllFile方法就是傳遞文件夾 遍曆文件夾的方法 所以直接調用getAllFile方法即可：遞歸 自己調用自己
			} else{
    
				System.out.println(f);//f是一個文件 直接打印即可
			}
		}
	}
}

三、過濾器：創建過濾器FileFilterImpl的實現類 重寫過濾方法accept 定義過濾規則

import java.io.File;
import java.io.FileFilter;
public class FileFilterImpl implements FileFilter{
    
	@Override
	public boolean accept(File pathname) {
    
		if (pathname.isDirectory()) {
    
			return true;
		}
		return pathname.getName().toLowerCase().endsWith(".md");
	}
}

四、必須明確兩件事：

1. 過濾器中的accept方法是誰調用的
2. accept方法的參數pathname是什麼

五、listFiles方法一共做了三件事：

1. listFiles方法會對構造方法中傳遞的目錄進行遍曆 獲取目錄中的每一個文件/文件夾 把獲取的每一個文件/文件夾封裝為File對象
2. listFiles方法會調用參數傳遞的過濾器中的方法accept
3. listFiles方法會把遍曆得到的每一個File對象 傳遞給accept方法的參數pathname

優化

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.util.jar.Attributes.Name;

public class Test6 {
    
	public static void main(String[] args) {
    
		File file = new File("C:\\Users\\dc16102111\\Documents\\Tencent Files\\809476070\\FileRecv");
		getAllFile(file);
	}
	
	/* * 定義一個方法 參數傳遞file類型的目錄 * 方法中對目錄進行遍曆 */
	public static void getAllFile(File dir) {
    
		File[] files = dir.listFiles((File d,String name) -> {
    
			//過濾規則 pathname是文件夾或是.java結尾的文件返回true
			return new File(dir,name).isDirectory() || name.toLowerCase().endsWith(".md");
		});
		
		for (File f : files) {
    
			if(f.isDirectory()){
    //對遍曆得到的file文件f進行判斷 判斷是否是文件夾
				getAllFile(f);//f是一個文件夾 則繼續遍曆這個文件夾 我們發現 getAllFile方法就是傳遞文件夾 遍曆文件夾的方法 所以直接調用getAllFile方法即可：遞歸 自己調用自己
			} else{
    
					System.out.println(f);//f是一個文件 直接打印即可
			}
		}
	}
}

IO流

一、內存：臨時存儲
二、磁盤：永久存儲

1. i：input輸入（讀取）把磁盤中的數據讀取到內存中使用
2. o：output輸出（寫入）輸出：把內存中的數據寫入到磁盤中保存
3. 流：數據（字符 字節） 1個字符=2個字節 1個字節=8個二進制比特

三、IO流最頂層的父類：

	輸入流	輸出流
字節流	字節輸入流InputStream	字節輸出流OutputStream
字符流	字符輸入流Beader	字符輸出流Writer

四、java.io.OutputStream：字節輸出流 此抽象類是錶示輸出字節流的所有類的超類，

1. 其中定義了一些子類共性的成員方法：
   （1）public void close()：關閉此輸出流並釋放與此流相關聯的任何系統資源
   （2）public void flush()：刷新此輸出流並强制任何緩沖的輸出字節被寫出
   （3）public void write(byte[] b)：將b.length字節從指定的字節數組寫入此輸出流
   （4）public void write(byte[] b,int off,int len)：從指定的字節數組寫入len字節 從偏移量off開始輸出到此輸出流
   （5）public abstract void write(int b)：將指定的字節輸出流
2. java.io.FileOutputStream extends OutputStream
   （1）FileOutputStream：文件字節輸出流
   （2）作用：把內存中的數據寫入到硬盤的文件中
   （3）構造方法：
   FileOutputStream(String name)：創建一個向具有指定名稱的文件中寫入數據的輸出文件流
   FileOutputStream(File file)：創建一個向指定file對象錶示的文件中寫入數據的文件輸出流

參數：寫入數據的目的

1. String name：目的地是一個文件的路徑
2. File file：目的地是一個文件

（4）構造方法的作用：

• 創建一個FileOutputStream對象
• 會根據構造方法中傳遞的文件/文件路徑 創建一個空的文件
• 會把FileOutputStream對象指向創建好的文件

五、數據由內存寫入硬盤的原理：java程序-》JVM（java虛擬機）-》os（操作系統）-》os調用寫數據的方法-》把數據寫入到文件中
六、字節輸出流的使用步驟：

1. 創建一個FileOutputStream對象 構造方法中傳遞寫入數據的目的地
2. 調用FileOutputStream對象中的方法write 把數據寫入到文件中
3. 釋放資源（流的使用會占用一定的內存 使用完畢要把內存清空 提高程序的效率）

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class IOStream {
    
	public static void main(String[] args) throws IOException {
    
		//1.創建一個FileOutputStream對象 構造方法中傳遞寫入數據的目的地
		FileOutputStream fos = new FileOutputStream("D:\\JAVA\\source\\Day20\\src\\a.txt");
		//2.調用FileOutputStream對象中的方法write 把數據寫入到文件中
		//public abstract void write(int b):將指定的字節輸出流
		fos.write(97);
		//3.釋放資源（流的使用會占用一定的內存 使用完畢要把內存清空 提高程序的效率）
		fos.close();
	}
}

字節輸入流

一、java.io.InputStream：字節輸入流。此抽象類是錶示字節輸入流的所有類的超類二、定義了所有子類共性的方法：

1. int read()：從輸入流中讀取數據的下一個字節
2. int read(byte[] b)：從輸入流中讀取一定數量的字節 並將其存儲在緩沖區數組b中
3. void close()：關閉此輸入流並釋放與該流關聯的所有系統資源

三、java.io.FileInputStream extends InputStream

1. FileInputStream：文件字節輸入流
2. 作用：把硬盤文件中的數據讀取到內存中使用

四、構造方法：

1. FileInputStream(String name)
2. FileInputStream(File file)

參數：讀取文件的數據源

1. String name:文件的路徑
2. File file:文件

五、構造方法的作用：

1. 會創建一個FileInputStream對象
2. 會把FileInputStream對象指定構造方法中要讀取的文件

六、讀取數據的原理：java程序-》JVM-》os-》os讀取數據的方法-》讀取文件
七、字節輸入流的使用步驟：

1. 創建FileInputStream對象 構造方法中綁定要讀取的數據源
2. 使用FileInputStream對象中的方法read 讀取文件
3. 釋放資源

import java.io.FileInputStream;
import java.io.IOException;
public class InputStream {
    
	public static void main(String[] args) throws IOException {
    
		// * 1.創建FileInputStream對象 構造方法中綁定要讀取的數據源
		FileInputStream fis = new FileInputStream("D:\\JAVA\\source\\Day20\\src\\b.txt");
		// * 2.使用FileInputStream對象中的方法read 讀取文件
		// * int read():讀取文件中的一個字節並返回 讀取到文件的末尾返回-1
// int len = fis.read();//97
// System.out.println(len);
// len = fis.read();
// System.out.println(len);//每讀取一次指針向後移一比特 所以每寫一次代碼就是往後讀一比特 讀完了返回-1
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);
// len = fis.read();
// System.out.println(len);//-1
// 
		/* * 發現以上讀取文件是一個重複的過程 所以可以使用循環優化 * 不知道文件中有多少字節 使用while循環 while循環結束條件：讀取到-1時結束 * 布爾錶達式(len = fis.read()) != -1的含義： * 1.fis.read():讀取一個字節 * 2.len = fis.read():把讀取到的字節賦值給變量len * 3.(len = fis.read()) != -1：判斷變量len是否不等於-1 */
		int len = 0;//記錄讀取到的字節
		while ((len = fis.read()) != -1) {
    
			System.out.println(len);
		}
		fis.close();
	}
}

字節輸入流一次讀取多個字節的方法

一、int read(byte[] b)：從輸出流中讀取一定數量的字節 並將其存儲在緩沖區數組b中
二、明確兩件事：

1. 方法的參數byte[]的作用：緩沖作用 存儲每次讀取到的多個字節的個數 提高了讀取效率 數組的長度一般定義為1024（1kb）或1024的整數倍
2. 方法的返回值int是什麼：每次讀取的有效字節個數

三、當使用字節流讀取中文字符時 可能不會顯示完整的字符 因為一個中文字符可能占用多個字節存儲
四、一個中文 在gbk編碼下占用兩個字節 在utf-8編碼下占用三個字節

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
public class InputStreamRead {
    
	public static void main(String[] args) throws IOException {
    
		// * 1.創建FileInputStream對象 構造方法中綁定要讀取的數據源
		FileInputStream fis = new FileInputStream("D:\\JAVA\\source\\Day20\\src\\b.txt");
		//2.使用FileInputStream對象中的方法read 讀取文件
		// * int read(byte[] b):從輸出流中讀取一定數量的字節 並將其存儲在緩沖區數組b中
// byte[] bytes = new byte[2];
// int len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// /*
// * String類的構造方法：
// * String(byte[] bytes):把字節數組轉換為字符串
// * String(byte[] bytes,int offset,int length):把字節數組的一部分轉化為字符串 offset：數組的開始索引 length：轉換的字節個數
// */
// //System.out.println(Arrays.toString(bytes));//[49, 48]
// System.out.println(new String(bytes));//10
// 
// len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// System.out.println(new String(bytes));//0A
// 
// len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// System.out.println(new String(bytes));//BC
// 
// len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// System.out.println(new String(bytes));//DE
// 
// len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// System.out.println(new String(bytes));//BC
// 
// len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// System.out.println(new String(bytes));//你
// 
// len = fis.read(bytes);
// System.out.println(len);//2 每次讀取的字節數的個數
// System.out.println(new String(bytes));//好
// 
// len = fis.read(bytes);
// System.out.println(len);//-1
// System.out.println(new String(bytes));//好

		/* * 發現以上讀取是一個重複的過程 可以使用循環優化 * 不知道文件中有多少字節 所以使用while循環 while循環結束的條件：讀取到-1結束 */
		byte[] bytes = new byte[1024];//存儲讀取到的多個字節
		int len = 0;//記錄每次讀取的有效字節個數
		while ((len = fis.read(bytes)) != -1) {
    
			//System.out.println(new String(bytes));//因為D:\\JAVA\\source\\Day20\\src\\b.txt文件中的內容沒有1024個字節
			//這麼多 所以輸出打印的內容會有很多空格 為了改進 我們可以使用String(byte[] bytes,int offset,int length):把字節數組的一部分轉化為字符串
			System.out.println(new String(bytes,0,len));
		}
		
		fis.close();//釋放資源
	}
}

一次寫多個字節的方法

一、public void write(byte[] b)：將b.length字節從指定的字節數組寫入此輸出流
二、public void write(byte[] b,int off,int len)：從指定的字節數組寫入len字節 從偏移量off開始輸出到此輸出流

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class OutputStream {
    
	public static void main(String[] args) throws IOException {
    
		//1.創建一個FileOutputStream對象 構造方法中傳遞寫入數據的目的地
		FileOutputStream fos = new FileOutputStream(new File("D:\\JAVA\\source\\Day20\\src\\b.txt"));
		//2.調用FileOutputStream對象中的方法write 把數據寫入到文件中
		//假設要求在文件中顯示100
		fos.write(49);
		fos.write(48);
		fos.write(48);
		
		/* * public void write(byte[] b,int off,int len):從指定的字節數組寫入len字節 從偏移量off開始輸出到此輸出流 * 一次寫多個字節 * 如果寫的第一個字節是整數（0-127） 那麼顯示的時候會查詢ASCII錶 * 如果寫的第一個字節是負數 那第一個字節會和第二個字節 第三個字節和第四個字節……每兩個字節組成一個中文顯示 查詢系統默認碼錶GBK 如果有一個單的 就查詢ASCII錶顯示 */
		byte[] bytes = {
    65,66,67,68,69};//100ABCDE
		//byte[] bytes = {-65,-66,-67,68,69};//100烤紻E
		fos.write(bytes);
		
		/* * public void write(byte[] b,int off,int len):從指定的字節數組寫入len字節 從偏移量off開始輸出到此輸出流 * int off:數組的開始索引 * int len:寫幾個字節 */
		fos.write(bytes,1,2);//100ABCDEBC
		
		/* * 寫入字符的方法：可以使用String類中的方法把字符串轉換為字節數組 * byte[] getBytes():把字符串轉換為字節數組 */
		byte[] bytes2 = "你好".getBytes();
		System.out.println(Arrays.toString(bytes2));//[-60, -29, -70, -61]
		fos.write(bytes2);//100ABCDEBC你好
		//3.釋放資源（流的使用會占用一定的內存 使用完畢要把內存清空 提高程序的效率）
		fos.close();
	}
}

追加寫/續寫字節

一、追加寫/續寫：使用兩個參數的構造方法：

1. FileOutputStream(String name,boolean append)：創建一個向具有指定name的文件中寫入數據的輸出文件流
2. FileOutputStream(File file,boolean append)：創建一個向指向file對象錶示的文件中寫入數據的文件輸出流

參數：

1. String name,File file：寫入數據的目的地
2. boolean append：追加寫開關
   true：創建對象不會覆蓋源文件 繼續在文件的末尾追加寫數據
   false：創建一個新文件 覆蓋源文件

二、如何換行：寫換行符號

Windows：\r\n
linux：/n
mac：/r

import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamWrite {
    
	public static void main(String[] args) throws IOException {
    
		FileOutputStream fos = new FileOutputStream("D:\\JAVA\\source\\Day20\\src\\c.txt",true);
		fos.write("你好".getBytes());//每點擊一次運行 D:\\JAVA\\source\\Day20\\src\\c.txt文件就會寫一次你好
		fos.write("\r\n".getBytes());//每點擊一次運行 D:\\JAVA\\source\\Day20\\src\\c.txt文件就會換行寫一次你好
		fos.close();
	}
}

字符輸入流

一、java.io.Reader：字符輸入流 是字符輸入流的最頂層的父類 定義了一些共性的成員方法 是一個抽象類
二、共性的成員方法：

1. int read()：讀取單個字符並返回
2. int read(char[] cbuf)：一次讀取多個字符 將字符讀入數組
3. void close()：關閉該流並釋放與之關聯的所有資源

三、java.io.FileReader extends InputStreamReader extends Reader

1. FileReader：文件字符輸入流
2. 作用：把硬盤文件中的數據以字符的方式讀取到內存中

四、構造方法：

1. FileReader(String fileName)
2. FileReader(File file)

參數：讀取文件的數據源

1. String fileName：文件的路徑
2. File file：一個文件

五、FileReader構造方法的作用：

1. 創建一個FileReader對象
2. 會把FileReader對象指向要讀取的文件

六、字符輸入流的使用步驟：

1. 創建FileReader對象 構造方法中綁定要讀取的數據源
2. 使用FileReader對象中的方法read讀取文件
3. 釋放資源

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class Reader {
    
	public static void main(String[] args) throws IOException {
    
		// * 1.創建FileReader對象 構造方法中綁定要讀取的數據源
		FileReader fr = new FileReader("D:\\JAVA\\source\\Day20\\src\\b.txt");
		// * 2.使用FileReader對象中的方法read讀取文件
		// * int read():讀取單個字符並返回
// int len = 0;
// while ((len = fr.read()) != -1) {
    
// System.out.println((char)len);
// }
		
		//為演示第二種方法 將上述代碼注釋
		// * int read(char[] cbuf):一次讀取多個字符 將字符讀入數組
		char[] cs = new char[1024];//存儲讀取到的多個字符
		int len = 0;//記錄的是每次讀取的有效字符個數
		while ((len = fr.read(cs)) != -1) {
    
			/* * String類的構造方法： * String(char[] value):把字符數組轉換為字符串 * String(char[] value,int offset,int count):把字符數組的一部分轉換為字符串 offset數組的開始索引 count轉換的個數 */
			System.out.println(new String(cs,0,len));
		}
		// * 3.釋放資源
		fr.close();
	}
}

字符輸出流

一、java.io.Writer：字符輸出流 是所有字符輸出流的最頂層的父類 是一個抽象類
二、共性的成員方法：

1. void write(int c)：寫入單個字符
2. void write(char[] cbuf)：寫入字符數組
3. abstract void write(char[] cbuf,int off,int len)：寫入字符數組的某一部分 off數組的開始索引 len寫的字符個數
4. void write(String str)：寫入字符串
5. void write(String str,int off,int len)：寫入字符串的某一部分 off字符串的開始索引 len寫的字符個數
6. void flush()：刷新該流的緩沖
7. void close()：關閉此流 但要先刷新他

三、java.io.FileWriter extends OutputStreamWriter extends Writer

1. FileWriter：文件字符輸出流
2. 作用：把內存中字符數據寫入到文件中

四、構造方法：

1. FileWriter(File file)：根據給定的File對象構造一個FileWriter對象
2. FileWriter(String fileName)：根據給定的文件名構造一個FileWriter對象

參數：寫入數據的目的地

1. File file：是一個文件
2. String fileName：文件的路徑

五、構造方法的作用：

1. 會創建一個FileWriter對象
2. 會根據構造方法中傳遞的文件的路徑 創建文件
3. 會把FileWriter對象指向創建好的文件

六、字符輸出流的使用步驟：

1. 創建一個FileWriter對象 構造方法中綁定要寫入數據的目的地
2. 使用FileWriter中的方法write 把數據寫入到內存緩沖區中（字符轉換為字節的過程）
3. 使用FileWriter中的方法flush 把內存緩沖區中的數據刷新到文件中
4. 釋放資源（會先把內存緩沖區中的數據刷新到文件中）

七、flush方法和close方法的區別：

1. flush：刷新緩沖區 流對象可以繼續使用
2. close：先刷新緩沖區 然後通知系統釋放資源 流對象不可以再被使用了

import java.io.FileWriter;
import java.io.IOException;
public class Writer {
    
	public static void main(String[] args) throws IOException {
    
		// * 1.創建一個FileWriter對象 構造方法中綁定要寫入數據的目的地
		FileWriter fw = new FileWriter("D:\\JAVA\\source\\Day20\\src\\c.txt");
		// * 2.使用FileWriter中的方法write 把數據寫入到內存緩沖區中（字符轉換為字節的過程）
		// * void write(int c):寫入單個字符
		fw.write(97);
		// * 3.使用FileWriter中的方法flush 把內存緩沖區中的數據刷新到文件中
		// * void flush():刷新該流的緩沖
		//fw.flush();//可以不寫這條語句 寫fw.close();也會先把內存緩沖區中的數據刷新到文件中
		
		// * void write(char[] cbuf):寫入字符數組
		char[] cs = {
    'a','b','c','d','e'};
		fw.write(cs);

		// * abstract void write(char[] cbuf,int off,int len):寫入字符數組的某一部分 off數組的開始索引 len寫的字符個數
		fw.write(cs,1,3);
		
		// * void write(String str):寫入字符串
		fw.write("傳智播客");
		
		// * void write(String str,int off,int len):寫入字符串的某一部分 off字符串的開始索引 len寫的字符個數
		fw.write("黑馬程序員",2,3);
		
		// * 4.釋放資源（會先把內存緩沖區中的數據刷新到文件中）
		fw.close();
	}
}

追加續寫字符

一、續寫：追加寫：使用兩個參數的構造方法

1. FileWriter(String fileName,boolean append)
2. FileWriter(File file,boolean append)

參數：

1. String fileName,boolean append：寫入數據的目的地的
2. File file,boolean append：續寫開關
   true：不會創建新的文件覆蓋源文件 可以續寫
   false：創建新的文件覆蓋源文件

二、換行：使用換行符號

Windows：\r\n
linux：/n
mac：/r

import java.io.FileWriter;
import java.io.IOException;
public class XuXieAndHuanHang {
    
	public static void main(String[] args) throws IOException {
    
		FileWriter fw =new FileWriter("D:\\JAVA\\source\\Day20\\src\\c.txt",true);
		for (int i = 0; i < 10; i++) {
    
			fw.write("HelloWorld" + i + "\r\n");
		}
		
		fw.close();
	}
}

文件複制練習：一讀一寫

一、明確：

1. 數據源：E:\正片\DSC_0087.jpg
2. 數據的目的地：D:\JAVA\source\Day20\src

二、文件複制步驟：

1. 創建一個字節輸入流對象 構造方法中綁定要讀取的數據源
2. 創建一個字節輸出流對象 構造方法中綁定要寫入的目的地
3. 使用字節輸入流對象中的方法read讀取文件
4. 使用字節輸出流中的方法write 把讀取到的字節寫入到目的地的文件中
5. 釋放資源

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
    
	public static void main(String[] args) throws IOException {
    
		// * 1.創建一個字節輸入流對象 構造方法中綁定要讀取的數據源
		FileInputStream fis = new FileInputStream("E:\\正片\\DSC_0087.jpg");
		// * 2.創建一個字節輸出流對象 構造方法中綁定要寫入的目的地
		FileOutputStream fos = new FileOutputStream("C:\\");
		//一次讀取一個字節 寫入一個字節的方式
		// * 3.使用字節輸入流對象中的方法read讀取文件
// int len = 0;
// while ((len = fis.read()) != -1) {
    
// // * 4.使用字節輸出流中的方法write 把讀取到的字節寫入到目的地的文件中
// fos.write(len);
// }
		
		//方法二：使用數組緩沖讀取多個字節 寫入多個字節
		byte[] bytes = new byte[1024];
		// * 3.使用字節輸入流對象中的方法read讀取文件
		int len = 0;//每次讀取的有效字節個數
		while ((len = fis.read(bytes)) != -1) {
    
			// * 4.使用字節輸出流中的方法write 把讀取到的字節寫入到目的地的文件中
			fos.write(bytes,0,len);
		}
		
		// * 5.釋放資源(先關閉寫的流 在關閉讀的流 因為寫完了肯定讀完了 讀完了不一定寫完了)
		fos.close();
		fis.close();
	}
}

异常處理

一、在JDK1.7之前使用trycatchfinally處理流中的异常
二、格式：

try{
    
	可是會產生异常的代碼
}catch(异常類變量 變量名){
    
	异常的處理邏輯
}finally{
    
	一定會執行的代碼
	資源釋放
}

import java.io.FileWriter;
import java.io.IOException;
public class TryCatch {
    
	public static void main(String[] args) {
    
		//提高變量fw的作用域 讓finally可以使用
		//變量在定義時 可以沒有值 但是使用的時候必須有值
		//fw =new FileWriter("D:\\JAVA\\source\\Day20\\src\\c.txt",true);如果執行失敗 fw沒有值 fw.close會報錯
		FileWriter fw = null;
		try {
    
			//可能會產生异常的代碼
			fw =new FileWriter("D:\\JAVA\\source\\Day20\\src\\c.txt",true);
			for (int i = 0; i < 10; i++) {
    
				fw.write("HelloWorld" + i + "\r\n");
			}
			
		} catch (Exception e) {
    
			//异常的處理邏輯
			System.out.println(e);
		}finally {
    
			//一定會執行的代碼
			//如果創建對象失敗了 fw的默認值是Null null是不能調用方法的 會拋出空指針异常 需要增加一個判斷 不是null再把資源釋放
			if (fw != null) {
    
				try {
    
					fw.close();//fw.close方法聲明拋出了IOException异常對象 所以我們就得處理這個异常對象 要麼try catch 要麼throws
				} catch (IOException e) {
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

jdk7新特性

一、在try的後邊可以增加一個()，在括號中可以定義流對象，那麼這個流對象的作用域就在try中有效
二、try中的代碼執行完畢 會自動把流對象釋放 不用寫finally
三、格式：

try(定義流對象；定義流對象...){
    
		可能會產生异常的代碼
}catch(异常類變量 變量名){
    
		异常的處理邏輯
}

import java.io.FileWriter;
public class JDK7 {
    
	public static void main(String[] args) {
    
		try(FileWriter fw =new FileWriter("D:\\JAVA\\source\\Day20\\src\\d.txt",true);)
		{
    
			//可能會產生异常的代碼
			for (int i = 0; i < 10; i++) {
    
				fw.write("HelloWorld" + i + "\r\n");
			}
			
		} catch (Exception e) {
    
			//异常的處理邏輯
			System.out.println(e);
		}
	}
}

JDK9新特性

一、try的前面可以定義流對象 try後面的()中可以直接引入流對象的名稱（變量名）
二、在try代碼執行完畢之後 流對象也可以釋放掉 不用寫finally
三、格式：

A a = new A();
B b = new B();
try(a,b){
    
	可能會出現异常的代碼
}catch(异常類變量 變量名){
    
	异常的處理邏輯
}

import java.io.FileWriter;
public class JDK9 {
    
	public static void main(String[] args) {
    
		FileWriter fw =new FileWriter("D:\\JAVA\\source\\Day20\\src\\d.txt",true);
		
		try(try)//我這是JDK8 不支持這個特性
		{
    
			//可能會產生异常的代碼
			for (int i = 0; i < 10; i++) {
    
				fw.write("HelloWorld" + i + "\r\n");
			}
			
		} catch (Exception e) {
    
			//异常的處理邏輯
			System.out.println(e);
		}
	}
}

java.util.Properties

一、java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>
二、Properties類錶示了一個持久的屬性集 Properties可保存在流中或從流中加載
三、Properties集合是一個唯一和IO流相結合的集合
四、可以使用Properties集合中的方法store 把集合中的臨時數據持久化寫入到硬盤中存儲
五、可以使用Properties集合中的方法load 把硬盤中保存的文件（鍵值對） 讀取到集合中使用
六、屬性列錶中每個鍵及其對應值都是一個字符串
七、Properties集合是一個雙列集合 key和value默認都是字符串

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class ProperttiesClass {
    
	public static void main(String[] args) throws IOException {
    
		show01();
		show02();
		show03();
	}

	/* * 可以使用Properties集合中的方法load 把硬盤中保存的文件（鍵值對） 讀取到集合中使用 * void load(InputStream inStream) * void load(Reader reader) * 參數： * InputStream inStream：字節輸入流 不能讀取含有中文的鍵值對 * Reader reader：字符輸入流 能讀取含有中文的鍵值對 * 使用步驟： * 1.創建Properties集合對象 * 2.使用Properties集合對象中的方法load讀取保存鍵值對的文件 * 3.遍曆Properties集合 * 【注】： * 1.存儲鍵值對的文件中 鍵與值默認的連接符號可以使用= 空格 和其他符號 * 2.存儲鍵值對的文件中 可以使用#進行注釋 被注釋的鍵值對不會再被讀取 * 3.存儲鍵值對的文件中 鍵與值默認都是字符串 不用再加引號 */
	private static void show03() throws IOException {
    
		// * 1.創建Properties集合對象
		Properties properties = new Properties();
		// * 2.使用Properties集合對象中的方法load讀取保存鍵值對的文件
		properties.load(new FileReader("D:\\JAVA\\source\\Day20\\src\\pro.txt"));
		// * 3.遍曆Properties集合
		Set<String> set = properties.stringPropertyNames();
		for (String key : set) {
    
			String valueString = properties.getProperty(key);
			System.out.println(key + "=" + valueString);//在文檔中 在迪麗熱巴前面加上了# 讀取文件的時候 就不會輸出打印迪麗熱巴 我不知道為啥還是會顯示
		}
	}

	/* * 可以使用Properties集合中的方法store 把集合中的臨時數據 持久化寫入到硬盤中存儲 * void store(OutputStream out,String comments) * void store(Writer writer,String comments) * 參數： * OutputStream out:字節輸出流 不能寫入中文 * Writer writer：字符輸出流 可以寫中文 * String comments：注釋 用來解釋說明保存的文件是做什麼用的 不能使用中文 會產生亂碼 默認是Unicode編碼 一般使用" "空字符串 * 使用步驟： * 1.創建Properties集合對象 添加數據 * 2.創建字節輸出流/字符輸出流對象 構造方法中綁定要輸出的目的地 * 3.使用Properties集合中的方法store 把集合中的臨時數據 持久化寫入到硬盤中存儲 * 4.釋放資源 */
	private static void show02() throws IOException {
    
		//創建Properties集合對象 添加數據
		Properties properties = new Properties();
		properties.setProperty("趙麗穎","168");
		properties.setProperty("迪麗熱巴","165");
		properties.setProperty("古力娜紮","160");

		// * 2.創建字節輸出流/字符輸出流對象 構造方法中綁定要輸出的目的地
		FileWriter fw = new FileWriter("D:\\JAVA\\source\\Day20\\src\\pro.txt");
		
		// * 3.使用Properties集合中的方法store 把集合中的臨時數據 持久化寫入到硬盤中存儲
		properties.store(fw, "save data");
		
		//釋放資源
		fw.close();
	}

	/* * 使用Properties集合存儲數據 遍曆取出Properties集合中的數據 * Properties集合是一個雙列集合 key和value默認都是字符串 * Properties集合有一些操作字符串的特有方法 * Object setProperty(String key,String value):調用Hashtable的方法put * String getProperty(String key):通過key找到value值 此方法相當於Map集合中的get(key)方法 * Set<String> stringPropertyNames():返回此屬性列錶中的鍵值 其中該鍵及其對應值是字符串 此方法相當於Map集合中的keySet方法 */
	private static void show01() {
    
		//創建Properties集合對象
		Properties properties = new Properties();
		//使用setProperties往集合中添加數據
		properties.setProperty("趙麗穎","168");
		properties.setProperty("迪麗熱巴","165");
		properties.setProperty("古力娜紮","160");

		//使用stringPropertyNames把Properties集合中的鍵取出 存儲到一個Set集合中
		Set<String> set = properties.stringPropertyNames();
		
		//遍曆Set集合 取出Properties集合的每一個鍵
		for (String key : set) {
    
			//使用getProperty方法通過key獲取value
			String valueString = properties.getProperty(key);
			System.out.println(key + "=" +valueString);
		}
	}
}