day20-----------IO流（傳智視頻）

遞歸思想

兔子問題

package cn.itcast_02;

/*
 * 有一對兔子，從出生後第3個月起每月都生一對兔子，小兔子長到第三個月後每月又生一對兔子，假如兔子都不死，問第二十個月的兔子對數爲多少？
 * 分析：咱們要想辦法找規律
 * 			兔子對數
 * 第一個月： 	1
 * 第二個月：	1
 * 第三個月：	2
 * 第四個月：	3	
 * 第五個月：	5
 * 第六個月：	8
 * ...
 * 
 * 因而可知兔子對象的數據是：
 * 		1,1,2,3,5,8...
 * 規則：
 * 		A:從第三項開始，每一項是前兩項之和
 * 		B:並且說明前兩項是已知的
 * 
 * 如何實現這個程序呢?
 * 		A:數組實現
 * 		B:變量的變化實現
 * 		C:遞歸實現
 * 
 * 假如相鄰的兩個月的兔子對數是a,b
 * 第一個相鄰的數據：a=1,b=1
 * 第二個相鄰的數據：a=1,b=2
 * 第三個相鄰的數據：a=2,b=3
 * 第四個相鄰的數據：a=3,b=5
 * 看到了：下一次的a是之前的b，下一次是之前的a+b	
 */
public class DiGuiDemo2 {
	public static void main(String[] args) {
		// 定義一個數組
		int[] arr = new int[20];
		arr[0] = 1;
		arr[1] = 1;
		// arr[2] = arr[0] + arr[1];
		// arr[3] = arr[1] + arr[2];
		// ...
		for (int x = 2; x < arr.length; x++) {
			arr[x] = arr[x - 2] + arr[x - 1];
		}
		System.out.println(arr[19]);// 6765
		System.out.println("----------------");

		int a = 1;
		int b = 1;
		for (int x = 0; x < 18; x++) {
			// 臨時變量存儲上一次的a
			int temp = a;
			a = b;
			b = temp + b;
		}
		System.out.println(b);
		System.out.println("----------------");

		System.out.println(fib(20));
	}

	/*
	 * 方法： 返回值類型：int 參數列表：int n 出口條件： 第一個月是1，第二個月是1 規律： 從第三個月開始，每個月是前兩個月之和
	 */
	public static int fib(int n) {
		if (n == 1 || n == 2) {
			return 1;
		} else {
			return fib(n - 1) + fib(n - 2);
		}
	}
}

遞歸輸出指定目錄下全部的java文件的絕對路徑案例

package cn.itcast_03;

import java.io.File;

/*
 * 需求：請你們把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());
				}
			}
		}
	}
}

遞歸刪除帶內容的目錄案例

package cn.itcast_03;

import java.io.File;

/*
 * 需求：遞歸刪除帶內容的目錄
 * 
 * 目錄我已經給定：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流

 •‍‍什麼狀況下使用哪一種流呢?  •

  若是數據所在的文件經過windows自帶的記事本打開並能讀懂裏面的內容，就用字符流。其餘用字節流。 

•   若是你什麼都不知道，就用字節流   ‍ ‍

FileOutputStream寫入數據

package cn.itcast_01;

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

/*
 * 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());
	}
}

FileOutputStream的write()的三個方法

package cn.itcast_01;

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

/*
 * 字節輸出流操做步驟：
 * 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();
	}
}

FileOutputStream寫出數據實現換行和追加寫入

package cn.itcast_01;

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

/*
 * 如何實現數據的換行?
 * 		爲何如今沒有換行呢?由於你值寫了字節數據，並無寫入換行符號。
 * 		如何實現呢?寫入換行符號便可唄。
 * 		剛纔咱們看到了有寫文本文件打開是能夠的，經過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();
	}
}

FileOutputStream寫出數據加入異常處理

package cn.itcast_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 加入異常處理的字節輸出流操做
 */
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();
				}
			}
		}
	}
}

FileInputStream讀取數據

package cn.itcast_02;

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

/*
 * 字節輸入流操做步驟：
 * 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();
	}
}

字節流複製文本文件案例

package cn.itcast_03;

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

/*
 * 複製文本文件。
 * 
 * 數據源：從哪裏來
 * 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();
	}
}

計算機是如何識別把兩個字節拼接爲中文的呢

package cn.itcast_03;

import java.util.Arrays;

/*
 * 計算機是如何識別何時該把兩個字節轉換爲一箇中文呢?
 * 在計算機中中文的存儲分兩個字節：
 * 		第一個字節確定是負數。
 * 		第二個字節常見的是負數，可能有正數。可是沒影響。
 */
public class StringDemo {
	public static void main(String[] args) {
		// String s = "abcde";
		// // [97, 98, 99, 100, 101]

		String s = "我愛你中國";
		// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

		byte[] bys = s.getBytes();
		System.out.println(Arrays.toString(bys));
	}
}

字節流複製文本文件案例

package cn.itcast_03;

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

/*
 * 需求：把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();
	}
}

字節流複製圖片案例

package cn.itcast_03;

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

/*
 * 需求：把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();
	}
}

字節流複製視頻案例

package cn.itcast_03;

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();
	}
}

FileInputStream讀取數據一次一個字節數組

package cn.itcast_02;

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();
	}
}

FileInputStream讀取數據的兩種方式比較圖解

字節複製文本文件案例

package cn.itcast_04;

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

/*
 * 需求：把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();
	}
}

字節流複製視頻案例

package cn.itcast_04;

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();
	}
}

BufferedOutputStream寫出數據

package cn.itcast_05;

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();
	}
}

package cn.itcast_05;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/*
 * 注意：雖然咱們有兩種方式能夠讀取，可是，請注意，這兩種方式針對同一個對象在一個代碼中只能使用一個。
 */
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();
	}
}

字節流四種方式複製MP4並測試效率

package outdemo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把F:\\technology\\720.mp4複製到當前項目目錄下的copy.mp4中
 * 
 * 字節流四種方式複製文件：
 * 基本字節流一次讀寫一個字節：	共耗時：193370毫秒
 * 基本字節流一次讀寫一個字節數組： 共耗時：192毫秒
 * 高效字節流一次讀寫一個字節： 共耗時：1222毫秒
 * 高效字節流一次讀寫一個字節數組： 共耗時：172毫秒
 */


public class CopyMp4 {

	public static void main(String[] args) throws IOException {
		
		method1("F:\\technology\\720.mp4","copy1.mp4");
		method2("F:\\technology\\720.mp4","copy2.mp4");
		method3("F:\\technology\\720.mp4","copy3.mp4");
		method4("F:\\technology\\720.mp4","copy4.mp4");
	}
	// 高效字節流一次讀寫一個字節數組：
	private static void method4(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(srcString));
		BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(destString));
		byte[] by = new byte[20480000];
		int len = 0;
		while ((len=fis.read(by))!=-1){
			fos.write(by,0,len);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("Buffer 數組--共耗時：" + (end - start) + "毫秒");
	}
	// 高效字節流一次讀寫一個字節：
	private static void method3(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(srcString));
		BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(destString));
		int byt = 0;
		while ((byt=fis.read())!=-1){
			fos.write(byt);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("Buffer 字節--共耗時：" + (end - start) + "毫秒");
	}
	// 基本字節流一次讀寫一個字節數組
	private static void method2(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);
		byte[] by = new byte[20480000];
		int byt = 0;
		while ((byt=fis.read(by))!=-1){
			fos.write(by,0,byt);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("字節 數組--共耗時：" + (end - start) + "毫秒");
	}
	// 基本字節流一次讀寫一個字節
	private static void method1(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		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();
		long end = System.currentTimeMillis();
		System.out.println("字節--共耗時：" + (end - start) + "毫秒");
	}

}

day20 總結

1:遞歸(理解)
	(1)方法定義中調用方法自己的現象
		舉例：老和尚給小和尚講故事，咱們學編程
	(2)遞歸的注意事項；
		A:要有出口，不然就是死遞歸
		B:次數不能過多，不然內存溢出
		C:構造方法不能遞歸使用
	(3)遞歸的案例：
		A:遞歸求階乘
		B:兔子問題
		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:操做步驟
			a:建立字節輸入流對象
			b:調用read()方法
			c:釋放資源
			
		B:代碼體現：
			FileInputStream fis = new FileInputStream("fos.txt");
			
			//方式1
			int by = 0;
			while((by=fis.read())!=-1) {
				System.out.print((char)by);
			}
			
			//方式2
			byte[] bys = new byte[1024];
			int len = 0;
			while((len=fis.read(bys))!=-1) {
				System.out.print(new String(bys,0,len));
			}
			
			fis.close();
	(5)案例：2種實現
		A:複製文本文件
		B:複製圖片
		C:複製視頻
	(6)字節緩衝區流
		A:BufferedOutputStream
		B:BufferedInputStream
	(7)案例：4種實現
		A:複製文本文件
		B:複製圖片
		C:複製視頻
		
3:自學字符流
	IO流分類
		字節流：
			InputStream
				FileInputStream
				BufferedInputStream
			OutputStream
				FileOutputStream
				BufferedOutputStream
		
		字符流：
			Reader
				FileReader
				BufferedReader
			Writer
				FileWriter
				BufferedWriter