JAVA語言基礎-面向對象（IO：IO字符流、遞歸）

21.01_IO流(字符流FileReader)

• 1.字符流是什麼
  • 字符流是能夠直接讀寫字符的IO流
  • 字符流讀取字符, 就要先讀取到字節數據, 而後轉爲字符. 若是要寫出字符, 須要把字符轉爲字節再寫出.
• 2.FileReader
  • FileReader類的read()方法能夠按照字符大小讀取

• FileReader fr = new FileReader("aaa.txt");              //建立輸入流對象,關聯aaa.txt
  int ch;
  while((ch = fr.read()) != -1) {                         //將讀到的字符賦值給ch
      System.out.println((char)ch);                       //將讀到的字符強轉後打印
  }
  
  fr.close();                                             //關流

    

package com.heima.chario;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo1_FileReader {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		FileReader fr = new FileReader("xxx.txt");
		int c;
		
		while((c = fr.read()) != -1) {					//經過項目默認的碼錶一次讀取一個字符
			System.out.print((char)c);
		}
		
		fr.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
		FileReader fr = new FileReader("xxx.txt");
		int x = fr.read();
		System.out.println(x);
		char c = (char)x;
		System.out.println(c);
		fr.close();
	}

}

21.02_IO流(字符流FileWriter)

• FileWriter類的write()方法能夠自動把字符轉爲字節寫出

  FileWriter fw = new FileWriter("aaa.txt");
  fw.write("aaa");
  fw.close();

    

package com.heima.chario;

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

public class Demo2_FileWriter {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("yyy.txt");
		fw.write("你們好,基礎班快接近尾聲了,你們要努力,要堅持!!!");
		fw.write(97);
		fw.close();
	}

}

21.03_IO流(字符流的拷貝)

FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

int ch;
while((ch = fr.read()) != -1) {
    fw.write(ch);
}

fr.close();
fw.close();

   

package com.heima.chario;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3_Copy {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		//demo2();	
		//demo3();
		BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("yyy.txt"));
		
		int c;
		while((c = br.read()) != -1) {
			bw.write(c);
		}
		
		br.close();
		bw.close();
	}

	public static void demo3() throws FileNotFoundException, IOException {
		FileReader fr = new FileReader("xxx.txt");
		FileWriter fw = new FileWriter("yyy.txt");
		
		char[] arr = new char[1024];
		int len;
		while((len = fr.read(arr)) != -1) {			//將文件上的數據讀取到字符數組中
			fw.write(arr,0,len);					//將字符數組中的數據寫到文件上
		}
		
		fr.close();
		fw.close();
	}

	public static void demo2() throws FileNotFoundException, IOException {
		//字符流不能拷貝純文本的文件
		FileReader fr = new FileReader("雙元.jpg");
		FileWriter fw = new FileWriter("copy.jpg");
		
		int c;
		while((c = fr.read()) != -1) {
			fw.write(c);
		}
		
		fr.close();
		fw.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
		FileReader fr = new FileReader("xxx.txt");
		FileWriter fw = new FileWriter("zzz.txt");
		
		int c;
		while((c = fr.read()) != -1) {
			fw.write(c);
		}
		
		fr.close();
		fw.close();				//Writer類中有一個2k的小緩衝區,若是不關流,就會將內容寫到緩衝區裏,關流會將緩衝區內容刷新,再關閉
	}

}

21.04_IO流(什麼狀況下使用字符流)

• 字符流也能夠拷貝文本文件, 但不推薦使用. 由於讀取時會把字節轉爲字符, 寫出時還要把字符轉回字節.
• 程序須要讀取一段文本, 或者須要寫出一段文本的時候能夠使用字符流
• 讀取的時候是按照字符的大小讀取的,不會出現半個中文
• 寫出的時候能夠直接將字符串寫出,不用轉換爲字節數組

21.05_IO流(字符流是否能夠拷貝非純文本的文件)

• 不能夠拷貝非純文本的文件
• 由於在讀的時候會將字節轉換爲字符,在轉換過程當中,可能找不到對應的字符,就會用?代替,寫出的時候會將字符轉換成字節寫出去
• 若是是?,直接寫出,這樣寫出以後的文件就亂了,看不了了

21.06_IO流(自定義字符數組的拷貝)

• FileReader fr = new FileReader("aaa.txt");          //建立字符輸入流,關聯aaa.txt
  FileWriter fw = new FileWriter("bbb.txt");          //建立字符輸出流,關聯bbb.txt
  
  int len;
  char[] arr = new char[1024*8];                      //建立字符數組
  while((len = fr.read(arr)) != -1) {                 //將數據讀到字符數組中
      fw.write(arr, 0, len);                          //從字符數組將數據寫到文件上
  }
  
  fr.close();                                         //關流釋放資源
  fw.close();

21.07_IO流(帶緩衝的字符流)

• BufferedReader的read()方法讀取字符時會一次讀取若干字符到緩衝區, 而後逐個返回給程序, 下降讀取文件的次數, 提升效率
• BufferedWriter的write()方法寫出字符時會先寫到緩衝區, 緩衝區寫滿時纔會寫到文件, 下降寫文件的次數, 提升效率

• BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));  //建立字符輸入流對象,關聯aaa.txt
  BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));  //建立字符輸出流對象,關聯bbb.txt
  
  int ch;             
  while((ch = br.read()) != -1) {     //read一次,會先將緩衝區讀滿,從緩衝去中一個一個的返給臨時變量ch
      bw.write(ch);                   //write一次,是將數據裝到字符數組,裝滿後再一塊兒寫出去
  }
  
  br.close();                         //關流
  bw.close();

21.08_IO流(readLine()和newLine()方法)

• BufferedReader的readLine()方法能夠讀取一行字符(不包含換行符號)
• BufferedWriter的newLine()能夠輸出一個跨平臺的換行符號"\r\n"

• BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
  BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
  String line;
  while((line = br.readLine()) != null) {
      bw.write(line);
      //bw.write("\r\n");                 //只支持windows系統
      bw.newLine();                       //跨平臺的
  }
  
  br.close();
  bw.close();

    

package com.heima.chario;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo4_Buffered {

	/**
	 * @param args
	 * 帶緩衝區的流中的特殊方法
	 * readLine()
	 * newLine();
	 * 
	 * newLine()與\r\n的區別
	 * newLine()是跨平臺的方法
	 * \r\n只支持的是windows系統
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("aaa.txt"));
		
		String line;
		while((line = br.readLine()) != null) {
			bw.write(line);
			//bw.newLine();							//寫出回車換行符
			//bw.write("\r\n");
		}
		
		br.close();
		bw.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
		String line;
		
		while((line = br.readLine()) != null) {
			System.out.println(line);
		}
		
		br.close();
	}

}

21.09_IO流(將文本反轉)

• 將一個文本文檔上的文本反轉,第一行和倒數第一行交換,第二行和倒數第二行交換

    

package com.heima.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Test1 {

	/**
	 * @param args
	 * 將一個文本文檔上的文本反轉,第一行和倒數第一行交換,第二行和倒數第二行交換
	 * 
	 * 分析:
	 * 1,建立輸入輸出流對象
	 * 2,建立集合對象
	 * 3,將讀到的數據存儲在集合中
	 * 4,倒着遍歷集合將數據寫到文件上
	 * 5,關流
	 * @throws IOException 
	 * 
	 * 注意事項:
	 * 流對象儘可能晚開早關
	 */
	public static void main(String[] args) throws IOException {
		//改寫後是儘可能晚開早關
		// 1,建立輸入輸出流對象
		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
		
		//2,建立集合對象
		ArrayList<String> list = new ArrayList<>();
		//3,將讀到的數據存儲在集合中
		String line;
		while((line = br.readLine()) != null) {
			list.add(line);
		}
		br.close();											//關流
		
		//4,倒着遍歷集合將數據寫到文件上
		BufferedWriter bw = new BufferedWriter(new FileWriter("revzzz.txt"));
		for(int i = list.size() - 1; i >= 0; i--) {
			bw.write(list.get(i));
			bw.newLine();
		}
		//5,關流
		
		bw.close();
	}

}

21.10_IO流(LineNumberReader)

• LineNumberReader是BufferedReader的子類, 具備相同的功能, 而且能夠統計行號
  • 調用getLineNumber()方法能夠獲取當前行號
  • 調用setLineNumber()方法能夠設置當前行號

• LineNumberReader lnr = new LineNumberReader(new FileReader("aaa.txt"));
  String line;
  lnr.setLineNumber(100);                                 //設置行號
  while((line = lnr.readLine()) != null) {
      System.out.println(lnr.getLineNumber() + ":" + line);//獲取行號
  }
  
  lnr.close();

    

package com.heima.chario;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class Demo5_LineNumberReader {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		LineNumberReader lnr = new LineNumberReader(new FileReader("zzz.txt"));
		
		String line;
		lnr.setLineNumber(100);
		while((line = lnr.readLine()) != null) {
			System.out.println(lnr.getLineNumber() + ":" + line);
		}
		
		lnr.close();
	}

}

21.11_IO流(裝飾設計模式)

• interface Coder {
      public void code();
  }
  
  class Student implements Coder {
  
      @Override
      public void code() {
          System.out.println("javase");
          System.out.println("javaweb");
      }
  
  }
  
  class HeiMaStudent implements Coder {
      private Student s;                      //獲取到被包裝的類的引用
      public HeiMaStudent(Student s) {        //經過構造函數建立對象的時候,傳入被包裝的對象
          this.s = s;
      }
      @Override
      public void code() {                    //對其原有功能進行升級
          s.code();
          System.out.println("數據庫");
          System.out.println("ssh");
          System.out.println("安卓");
          System.out.println(".....");
      }
  
  }

    

package com.heima.chario;

public class Demo6_Wrap {

	/**
	 * @param args
	 * 裝飾設計模式的好處是:
	 * 耦合性不強,被裝飾的類的變化與裝飾類的變化無關
	 */
	public static void main(String[] args) {
		HeiMaStudent hms = new HeiMaStudent(new Student());
		hms.code();
	}

}

interface Coder {
	public void code();
}

class Student implements Coder {

	@Override
	public void code() {
		System.out.println("javase");
		System.out.println("javaweb");
	}
	
}

class HeiMaStudent implements Coder {
	//1,獲取被裝飾類的引用
	private Student s;						//獲取學生引用
	
	//2,在構造方法中傳入被裝飾類的對象
	public HeiMaStudent(Student s) {
		this.s = s;
	}

	//3,對原有的功能進行升級
	@Override
	public void code() {
		s.code();
		System.out.println("ssh");
		System.out.println("數據庫");
		System.out.println("大數據");
		System.out.println("...");
	}
}

21.12_IO流(使用指定的碼錶讀寫字符)

• FileReader是使用默認碼錶讀取文件, 若是須要使用指定碼錶讀取, 那麼能夠使用InputStreamReader(字節流,編碼表)
• FileWriter是使用默認碼錶寫出文件, 若是須要使用指定碼錶寫出, 那麼能夠使用OutputStreamWriter(字節流,編碼表)

• BufferedReader br =                                     //高效的用指定的編碼表讀
          new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt"), "UTF-8"));
  BufferedWriter bw =                                     //高效的用指定的編碼表寫
          new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt"), "GBK"));
  int ch;
  while((ch = br.read()) != -1) {
      bw.write(ch);
  }
  
  br.close();
  bw.close();

    

package com.heima.chario;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Demo7_TransIO {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		//demo2();
		BufferedReader br = 								//更高效的讀
				new BufferedReader(new InputStreamReader(new FileInputStream("utf-8.txt"), "utf-8"));
		BufferedWriter bw = 								//更高效的寫
				new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk"));
		int c;
		while((c = br.read()) != -1) {
			bw.write(c);
		}
		
		br.close();
		bw.close();
	}

	public static void demo2() throws UnsupportedEncodingException,
			FileNotFoundException, IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"), "uTf-8");	//指定碼錶讀字符
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");	//指定碼錶寫字符
		
		int c;
		while((c = isr.read()) != -1) {
			osw.write(c);
		}
		
		isr.close();
		osw.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
		//用默認編碼表讀寫,出現亂碼
		FileReader fr = new FileReader("utf-8.txt");				
		FileWriter fw = new FileWriter("gbk.txt");
		
		int c;
		while((c = fr.read()) != -1) {
			fw.write(c);
		}
		
		fr.close();
		fw.close();
	}

}

21.13_IO流(轉換流圖解)

• 畫圖分析轉換流

21.14_IO流(獲取文本上字符出現的次數)

• 獲取一個文本上每一個字符出現的次數,將結果寫在times.txt上

package com.heima.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;

public class Test2 {

	/**
	 * @param args
	 * 獲取一個文本上每一個字符出現的次數,將結果寫在times.txt上
	 * 
	 * 1,建立帶緩衝區的輸入流對象
	 * 2,建立雙列集合對象,目的是把字符看成鍵,把字符出現的次數看成值
	 * 3,經過讀取不斷向集合中存儲,存儲的時候要判斷,若是不包含這個鍵就將鍵和值爲1存儲,若是包含就將鍵和值加1存儲
	 * 4,關閉輸入流
	 * 5,建立輸出流對象
	 * 6,將結果寫出
	 * 7,關閉輸出流
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//1,建立帶緩衝區的輸入流對象
		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
		//2,建立雙列集合對象,目的是把字符看成鍵,把字符出現的次數看成值
		HashMap<Character, Integer> hm = new HashMap<>();
		//3,經過讀取不斷向集合中存儲,存儲的時候要判斷,若是不包含這個鍵就將鍵和值爲1存儲,若是包含就將鍵和值加1存儲
		int c;
		while((c = br.read()) != -1) {
			char ch = (char)c;
			/*if(!hm.containsKey(ch)) {
				hm.put(ch, 1);
			}else {
				hm.put(ch, hm.get(ch) +  1);
			}*/
			
			hm.put(ch, !hm.containsKey(ch)? 1 : hm.get(ch) + 1);
		}
		//4,關閉輸入流
		br.close();
		//5,建立輸出流對象
		BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
		//6,將結果寫出
		
		for (Character key : hm.keySet()) {
			bw.write(key + "=" + hm.get(key));
		}
		
		bw.close();
	}

}

package com.heima.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.TreeMap;

public class Test3 {

	/**
	 * 獲取一個文本上每一個字符出現的次數,將結果寫在times.txt上
	 * 
	 * 分析:
	 * 1,建立帶緩衝的輸入流對象
	 * 2,建立雙列集合對象TreeMap
	 * 3,將讀到的字符存儲在雙列集合中,存儲的時候要作判斷,若是不包含這個鍵,就將鍵和1存儲,若是包含這個鍵,就將該鍵和值加1存儲
	 * 4,關閉輸入流
	 * 5,建立輸出流對象
	 * 6,遍歷集合將集合中的內容寫到times.txt中
	 * 7,關閉輸出流
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//1,建立帶緩衝的輸入流對象
		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
		//2,建立雙列集合對象TreeMap
		TreeMap<Character, Integer> tm = new TreeMap<>();
		//3,將讀到的字符存儲在雙列集合中,存儲的時候要作判斷,若是不包含這個鍵,就將鍵和1存儲,若是包含這個鍵,就將該鍵和值加1存儲
		int ch;
		while((ch = br.read()) != -1) {
			char c = (char)ch;					//強制類型轉換
			/*if(!tm.containsKey(c)) {
				tm.put(c, 1);
			}else {
				tm.put(c, tm.get(c) + 1);
			}*/
			tm.put(c, !tm.containsKey(c) ? 1 : tm.get(c) + 1);
		}
		//4,關閉輸入流
		br.close();
		//5,建立輸出流對象
		BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
		//6,遍歷集合將集合中的內容寫到times.txt中
		for(Character key : tm.keySet()) {
			switch (key) {
			case '\t':
				bw.write("\\t" + "=" + tm.get(key)); 	
				break;
			case '\n':
				bw.write("\\n" + "=" + tm.get(key)); 
				break;
			case '\r':
				bw.write("\\r" + "=" + tm.get(key)); 
				break;
			default:
				bw.write(key + "=" + tm.get(key)); 			//寫出鍵和值
				break;
			}
			bw.newLine();
		}
		//7,關閉輸出流
		bw.close();
	}

}

21.15_IO流(試用版軟件)

• 當咱們下載一個試用版軟件,沒有購買正版的時候,每執行一次就會提醒咱們還有多少次使用機會用學過的IO流知識,模擬試用版軟件,試用10次機會,執行一次就提示一次您還有幾回機會,若是次數到了提示請購買正版

    

package com.heima.test;

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

public class Test4 {

	/**
	 *  當咱們下載一個試用版軟件,沒有購買正版的時候,每執行一次就會提醒咱們還有多少次使用機會用學過的IO流知識,模擬試用版軟件,
	 *  試用10次機會,執行一次就提示一次您還有幾回機會,若是次數到了提示請購買正版
	 * @throws IOException 
	 * 分析:
	 * 1,建立帶緩衝的輸入流對象,由於要使用readLine方法,能夠保證數據的原樣性
	 * 2,將讀到的字符串轉換爲int數
	 * 3,對int數進行判斷,若是大於0,就將其--寫回去,若是不大於0,就提示請購買正版
	 * 4,在if判斷中要將--的結果打印,並將結果經過輸出流寫到文件上
	 */
	public static void main(String[] args) throws IOException {
		//1,建立帶緩衝的輸入流對象,由於要使用readLine方法,能夠保證數據的原樣性
		BufferedReader br = new BufferedReader(new FileReader("config.txt"));
		//2,將讀到的字符串轉換爲int數
		String line = br.readLine();
		int times = Integer.parseInt(line);					//將數字字符串轉換爲數字
		//3,對int數進行判斷,若是大於0,就將其--寫回去,若是不大於0,就提示請購買正版
		if(times > 0) {
			//4,在if判斷中要將--的結果打印,並將結果經過輸出流寫到文件上
			System.out.println("您還有" + times-- + "次機會");
			FileWriter fw = new FileWriter("config.txt");
			fw.write(times + "");
			fw.close();
		}else {
			System.out.println("您的試用次數已到,請購買正版");
		}
		//關閉流
		br.close();
	}

}

21.16_File類(遞歸)

• 5的階乘    

package com.heima.chario;

public class Demo8_Digui {

	/**
	 * @param args
	 * 遞歸:方法本身調用本身
	 * 5!
	 * 5 * 4 * 3 * 2 * 1
	 * 
	 * 5 * fun(4)(表明4!)
	 * 		4 * fun(3)(表明3!)
	 * 				3 * fun(2)(表明2!) 
	 * 						2 * fun(1)(表明1!)
	 * 遞歸的弊端:不能調用次數過多,容易致使棧內存溢出
	 * 遞歸的好處:不用知道循環次數
	 * 
	 * 構造方法是否能夠遞歸調用?
	 * 構造方法不能使用遞歸調用
	 * 
	 * 遞歸調用是否必須有返回值?
	 * 不必定(能夠有,也能夠沒有)
	 */
	public static void main(String[] args) {
		/*int result = 1;
		
		for(int i = 1; i <= 5; i++) {
			result = result * i;
		}
		
		System.out.println(result);*/
		System.out.println(fun(6000));
	}
	
	public static int fun(int num) {
		if(num == 1) {
			return 1;
		}else {
			return num * fun(num - 1);
		}
	}
}

21.17_File類(練習)

• 需求:從鍵盤輸入接收一個文件夾路徑,打印出該文件夾下全部的.java文件名

    

package com.heima.test;

import java.io.File;
import java.io.FileReader;
import java.util.Scanner;

public class Test5 {

	/**
	 * 需求:從鍵盤輸入接收一個文件夾路徑,打印出該文件夾下全部的.java文件名
	 * 
	 * 分析:
	 * 從鍵盤接收一個文件夾路徑
	 * 1,若是錄入的是不存在,給與提示
	 * 2,若是錄入的是文件路徑,給與提示
	 * 3,若是是文件夾路徑,直接返回
	 * 
	 * 打印出該文件夾下全部的.java文件名
	 * 1,獲取到該文件夾路徑下的全部的文件和文件夾,存儲在File數組中
	 * 2,遍歷數組,對每個文件或文件夾作判斷
	 * 3,若是是文件,而且後綴是.java的,就打印
	 * 4,若是是文件夾,就遞歸調用
	 */
	public static void main(String[] args) {
		File dir = getDir();
		printJavaFile(dir);
	}

	/*
	 * 獲取鍵盤錄入的文件夾路徑
	 * 1,返回值類型File
	 * 2,不須要有參數
	 */
	public static File getDir() {
		Scanner sc = new Scanner(System.in);				//建立鍵盤錄入對象
		System.out.println("請輸入一個文件夾路徑");
		while(true) {
			String line = sc.nextLine();					//將鍵盤錄入的文件夾路徑存儲
			File dir = new File(line);						//封裝成File對象
			if(!dir.exists()) {
				System.out.println("您錄入的文件夾路徑不存在,請從新錄入");
			}else if(dir.isFile()) {
				System.out.println("您錄入的是文件路徑,請從新錄入文件夾路徑");
			}else {
				return dir;
			}
		}
	}
	/*
	 * 獲取文件夾路徑下的所.java文件
	 * 1,返回值類型 void
	 * 2,參數列表File dir
	 */
	public static void printJavaFile(File dir) {
		//1,獲取到該文件夾路徑下的全部的文件和文件夾,存儲在File數組中
		File[] subFiles = dir.listFiles();
		//2,遍歷數組,對每個文件或文件夾作判斷
		for (File subFile : subFiles) {
			//3,若是是文件,而且後綴是.java的,就打印
			if(subFile.isFile() && subFile.getName().endsWith(".java")) {
				System.out.println(subFile);
			//4,若是是文件夾,就遞歸調用
			}else if (subFile.isDirectory()){
				printJavaFile(subFile);
			}
		}
	}
}

21.18_IO流(總結)

• 1.會用BufferedReader讀取GBK碼錶和UTF-8碼錶的字符
• 2.會用BufferedWriter寫出字符到GBK碼錶和UTF-8碼錶的文件中
• 3.會使用BufferedReader從鍵盤讀取一行