1 遞歸求階乘
public static int jieCheng(int n){
if(n == 1){
return 1;
}else{
return n*jieCheng(n-1);
}
}
public static void main(String[] args){
System.out.println(jieCheng(5));
}
2 斐波那契數列
有一對兔子，從出生後第3個月起每個月都生一對兔子，小兔子倡導第三個月後每個月又生一對兔子，假設兔子都不死，問第二十個月兔子的對數是多少？
1,1,2,3,5,8,13,21...
分析：可以看出從第三項開始，每一項是前兩項之和。
public static int fib(int n){
if(n == 1 || n ==2){
return 1;
}else{
return fib(n-1)+fib(n-2);
}
}
3 遞歸輸出指定目錄下文件絕對路徑
需求：把E：\JavaEE目錄下所有的java結尾的文件的絕對路徑給輸出在控制檯。
//創建目錄
File srcFolder = new File("E:\\javaEE");
//遞歸功能實現
getAllJavaFilePaths(srcFolder);
pirvate static void getAllJavaFilePaths(File srcFolder){
//獲取該目錄下所有的文件或者文件夾的File數組
File[] fileArray = srcFolder.listFiles();
//遍歷File數組，得到每一個File對象
for(File file : fileArray){
//判斷該File對象是否是文件夾
if(file.isDirectiory()){
getAllJavaFilePaths(file);
}else{
//繼續判斷是否以.java結尾
if(file.getName().endsWith(".java")){
//就輸出該文件的絕對路徑
System.out.println(file.getAbsolutePath());
}
}
}
}
//跟360掃描一個道理。。。。。。。感覺木馬、
4 遞歸刪除帶內容的目錄
//封裝目錄
File srcFolder = new File("demo");
//遞歸實現
deleteolder(srcFolder);
private static void deleteFolder(File srcFolder){
//獲取該目錄下的所有文件或者文件夾的File數組
File[] fileArray = srcFolder.listFiles();
//遍歷該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());
}
5 IO流
(1)IO流概述
IO流用來處理設備之間的數據傳輸問題
上傳文件和下載文件
如果操作的數據是文本數據，就用字符流，把要操作的文件用windows自帶的記事本打開，如果打開後數據是可以讀懂的，就可以使用字符流，如果不能讀懂，就用字節流。
如果什麼都不知道，就用字節流。
IO流的分類：
流向：
輸入流 讀取數據
輸出流 寫出數據
數據類型：
字節流
字節輸入流 讀取數據 InputStream
字節輸出流 寫出數據 OutputStream
字符流
字符輸入流 讀取數據 Reder
字符輸出流 寫入數據 Writer
注意：一般我們在探討IO流的時候，如果沒有明確按照哪種分類來說，默認情況下是按照數據類型來分的。
--------------------------------------------------
(2) 寫入一句話
需求：往文件中寫一句話。
通過分析，我們知道要使用OutputStream
所以，要找一個具體的子類。
文件是File，字節輸出流是OutputStream，連起來就是FileOutputStream
注意：每種基類的子類都是以父類名作爲後綴名。
XxxOutputStream
XxxInputStream
XxxReader
XxxWriter
查看FileOutputStream的構造方法：
FileOutputStream(File file)
FileOutputStream(String name)
字節輸出流操作步驟：
A:創建字節輸出流對象
B:寫數據 (write()方法)
C:釋放資源
--------------------------------------------------
//創建字節輸出流對象
//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.close();
//爲什麼一定要close()呢？
A:讓流對象編程垃圾，這樣就可以被垃圾回收器回收了。
B:通知系統去釋放跟該文件相關的資源
----------------------------------------------------
6 字節流 寫出數據
(1)字節流中 write()的三個方法
public void write(int b):寫一個字節
public void write(byte[] b):寫一個字節數組
public void write(byte[] b,int off,int len):寫一個字節數組的一部分
FileOutputStream fos = new FileOutputStream("fos.txt");
//調用write()方法
fos.write(97)://97 --底層二進制編碼--通過記事本打卡--找到97對應的字符值--a
//public void write(byte[] b)
byte[] bys ={97,98,99,100,101};
fos.write(bys); //abcde
//public void write(byte[] b,int off,int len)
fos.write(bys,1,3) // bcd
(2)寫出數據 數據換行和追加寫入
A:如何實現換行？
寫入換行符號即可
fos.write("\n".getBytes);
剛纔我們看到了有些文本文件打開是可以的，通過windows自帶的那個不行，爲什麼呢？
因爲不同的系統針對不同的換行符號識別是不一樣的。
windows：\r\n
linux:\n
Max:\r
而一些常見的高級記事本，是可以識別任意換行符號的。
B:如何實現追加寫入？
通過構造方法
FileOutputSream(File file,boolean append)
FileOutputStream fos = new FileOutputStream("fos.txt"，true);
(3)寫出數據 字節流加入異常處理
/*
* 加入異常處理的字節輸出流操作
*/
//分開做異常處理
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();
}
}
}
}
}
7 字節流 讀取數據
(1) 讀取數據
字節流輸入操作步驟
A:創建字節輸入流對象
B:調用read()方法讀取數據，並把數據顯示在控制檯
C:釋放數據
讀取數據的方式：
A:int read():一次讀取一個字節
B:int read(byte[] b):一次讀取一個字節數組
如果一次讀取一個字節的話，需要用循環改進，通過測試發現，如果讀取的數據是-1，則說明已經讀完了。
FileInputStream fis = new FileInputStream("fis.txt");
//用循環改進
int by = fis.read();
while(by != -1){
System.out.println((char)by);
by=.fis.read();
}
//最終版代碼
int by = 0;
//讀取，賦值判斷
while((by = fis.read())!=-1){
System.out.println((char)by);
}
(2)複製文本文件
數據源：從哪裏來
a.txt -- 讀取數據 -- FileInputStream
目的地：到哪裏去
b.txt -- 寫數據 --FileOutputStream
------------------------------------------------------
這一次複製中文沒有出現任何問題，爲什麼呢?
上一次我們出現問題的原因在於我們每次獲取到一個字節數據，就把該字節數據轉換爲了字符數據，然後輸出到控制檯。
而這一次呢?確實通過IO流讀取數據，寫到文本文件，你讀取一個字節，我就寫入一個字節，你沒有做任何的轉換。
它會自己做轉換。
讀取必須要有文件，輸入可以沒有
--------------------------------------------------------
//封裝數據源
FileInputStream fis = new FileInputStream("fis.txt");
//封裝目的地
FileOutputStream fos = new FileOutputStream("fos4.txt");
int by = 0;
while((by=fis.read())!=-1){
fos.write(by);
}
//釋放資源(先關誰都行)
fos.close();
fis.close();
(3)中文存儲在計算機中
計算機是如何識別什麼時候該把兩個字節轉換爲一箇中文呢?
在計算機中中文的存儲分兩個字節：
第一個字節肯定是負數。
第二個字節常見的是負數，可能有正數。但是沒影響。
// 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));
(4) 字節流 複製圖片
//封裝數據源
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();
(5) 字節流 複製視頻
//封裝數據源
FileInputStream fis = new FileInputStream("e:\\視屏.mp4");
//封裝目的地
FileOutputStream fos = new FileOutputStream("mn.mp4");
//複製數據
int by = 0;
while((by=fis.read())!=-1){
fos.write(by);
}
//釋放資源(先關誰都行)
fos.close();
fis.close();
//注意：一次一個字節，效率太低了。。。
(6) 字節流一次一個字節數組
FileInputStream fis = new FileInputStream("fis.txt");
byte[] bys = new byte[115];
int len = 0;
while((len = fis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
//System.out.println(new String(bys));//千萬要帶上len的使用
}
//最終版代碼
//數組的長度一般是1024或者1024的整數倍
byte[] bys = new byte[1024];
int len = 0;
while((len = fis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
}
(7) 兩種方式的圖解
(8) 複製文本 字節數組
//封裝數據源
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();
(9) 複製視頻 字節數組
//封裝數據源
FileInputStream fis = new FileInputStream("e:\\視屏.mp4");
FileOutputStream fos = new FileOutputStream("mn.mp4");
//複製數據
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
//釋放資源
fos.close();
fis.close();
8 字節緩衝區流
通過定義數組的方式確實比以前一次讀取一個字節的方式快很多，所以，看來有一個緩衝區還是非常好的。
既然是這樣的話，那麼，java開始在設計的時候，它也考慮到了這個問題，就專門提供了帶緩衝區的字節類。
這種類被稱爲：緩衝區類(高效類)
字節緩衝輸出流：BufferedOutputStream
字節緩衝輸入流：BufferedInputStream
構造方法可以指定緩衝區的大小，但是我們一般用不上，因爲默認緩衝區大小就足夠了。
爲什麼不傳遞一個具體的文件或者文件路徑，而是傳遞一個OutputStream的對象呢？
原因很簡單，字節緩衝區流僅僅提供緩衝區，爲高效而設計的，但是呢，真正的讀寫操作還是得靠基本的流兌現實現。
--------------------------------------
//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,IO".getBytes());
//釋放資源
bos.close();
---------------------------------------
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
//讀取數據
//int by = 0;
//while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
// 釋放資源
bis.close();
注意：雖然有兩種方式可以讀取，但是，注意，這兩種方式針對同一個對象在一個代碼中只能使用一個。
9 四種複製方式的比較
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：把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();
}
}