Day21_IO第三天

1、IO体系总图




2、字符流体系图


记忆路线：输入输出流前面加File和Buffered，这就记住6个了，还剩两个转换流名字比较特殊，需要着重记一下(转换流：字节和字符的组合，所以起名字叫InputStreamReader,OutputStreamWriter)

3、BufferedWriter和BufferedReader特有方法(掌握)

BufferedWriter: newLine():写入一行
BufferedReader: readLine();读取一行，返回的数据中不会包含换行符

4、LineNumberReader(掌握)


特有方法
    setLineNumber(int number)设置行号
    getLineNumber();获取行号
  1. package com.heima.chario;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  6. import java.io.LineNumberReader;
  8. public class Demo5_LineNumberReader {
  10. 	/**
  11. 	 * @param args
  12. 	 * @throws IOException 
  13. 	 */
  14. 	public static void main(String[] args) throws IOException {
  15. 		LineNumberReader lnr = new LineNumberReader(new FileReader("zzz.txt"));
  16. 		
  17. 		String line;
  18. 		lnr.setLineNumber(100);
  19. 		while((line = lnr.readLine()) != null) {
  20. 			System.out.println(lnr.getLineNumber() + ":" + line);
  21. 		}
  22. 		
  23. 		lnr.close();
  24. 	}
  26. }

5、装饰设计模式(掌握)

概述
     对一个已知类，类的原始行为要保留住而且对于某一个方法或者给类增加一些新的内容，这种情况下使用包装设计模式

编写步骤
     
     1、在包装类中定义一个变量temp这个变量的类型是被包装类
     2、定义构造方法，通过构造方法初始化temp
     3、改写之前的方法，或者增加新的方法

  1. import java.io.BufferedReader;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  6. public class LineNumberReader  {
  7. 	private BufferedReader bufferedReader; 							//第一步：增加被包装类的引用
  8. 	private int lineNumber = 0;//计数器,也被称为行号
  9. 	
  10. 	public LineNumberReader(BufferedReader br){					//第二步：通过构造方法给被包装类的引用赋值
  11. 		this.bufferedReader = br;
  12. 	}
  13. 	
  14. 	public String readLine() throws IOException{					//第三部：改写要增强的方法
  15. 		String line = bufferedReader.readLine();
  16. 		lineNumber ++;
  17. 		return line;
  18. 	}
  19. 	
  20. 	public void close() throws IOException{
  21. 		bufferedReader.close();
  22. 	}
  24. 	/**   
  25. 	 *  获取lineNumber  
  26. 	 * @return lineNumber lineNumber   
  27. 	 */
  28. 	public int getLineNumber() {											//第三部：改写要增强的方法
  29. 		return lineNumber;
  30. 	}
  32. 	/**   
  33. 	 *  设置lineNumber  
  34. 	 * @param lineNumber lineNumber   
  35. 	 */
  36. 	public void setLineNumber(int lineNumber) {				//第三部：改写要增强的方法
  37. 		this.lineNumber = lineNumber;
  38. 	}
  39. 	
  40. 	public static void main(String[] args)  throws Exception{
  41. 		LineNumberReader lnr = new LineNumberReader(new BufferedReader(new FileReader("a.txt")));
  42. 		String line = null;
  43. 		while((line=lnr.readLine()) != null){
  44. 			System.out.println(lnr.getLineNumber()+":"+line);
  45. 		}
  46. 		
  47. 		lnr.close();
  48. 	}
  49. }




6、通过指定编码操作文本文件(掌握)

new InputStreamReader(输入字节流对象, "编码") 
new OutputStreamWriter(输出字节流对象, "编码")
  1. package com.heima.chario;
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.FileReader;
  9. import java.io.FileWriter;
  10. import java.io.IOException;
  11. import java.io.InputStreamReader;
  12. import java.io.OutputStreamWriter;
  13. import java.io.UnsupportedEncodingException;
  15. public class Demo7_TransIO {
  17. 	/**
  18. 	 * @param args
  19. 	 * @throws IOException 
  20. 	 */
  21. 	public static void main(String[] args) throws IOException {
  22. 		//demo1();
  23. 		//demo2();
  24. 		BufferedReader br = 								//更高效的读
  25. 				new BufferedReader(new InputStreamReader(new FileInputStream("utf-8.txt"), "utf-8"));
  26. 		BufferedWriter bw = 								//更高效的写
  27. 				new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk"));
  28. 		int c;
  29. 		while((c = br.read()) != -1) {
  30. 			bw.write(c);
  31. 		}
  32. 		
  33. 		br.close();
  34. 		bw.close();
  35. 	}
  37. 	public static void demo2() throws UnsupportedEncodingException,
  38. 			FileNotFoundException, IOException {
  39. 		InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"), "uTf-8");	//指定码表读字符
  40. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");	//指定码表写字符
  41. 		
  42. 		int c;
  43. 		while((c = isr.read()) != -1) {
  44. 			osw.write(c);
  45. 		}
  46. 		
  47. 		isr.close();
  48. 		osw.close();
  49. 	}
  51. 	public static void demo1() throws FileNotFoundException, IOException {
  52. 		//用默认编码表读写,出现乱码
  53. 		FileReader fr = new FileReader("utf-8.txt");				
  54. 		FileWriter fw = new FileWriter("gbk.txt");
  55. 		
  56. 		int c;
  57. 		while((c = fr.read()) != -1) {
  58. 			fw.write(c);
  59. 		}
  60. 		
  61. 		fr.close();
  62. 		fw.close();
  63. 	}
  65. }

InputStreamReader:字节流通向字符流的桥梁
OutputStreamWriter:字符流通向字节流的桥梁

7、高效字符流标准代码(掌握)

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.FileReader;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.io.LineNumberReader;
  9. public class Copy {
  10. 	
  11. 	/**
  12. 	 * 通过缓冲流拷贝文本文件
  13. 	 * @param source
  14. 	 * @param dest
  15. 	 */
  16. 	public static void copy(String source, String dest){
  17. 		BufferedReader br = null;
  18. 		BufferedWriter bw = null;
  19. 		
  20. 		try{
  21. 			br = new BufferedReader(new FileReader(source));
  22. 			bw = new BufferedWriter(new FileWriter(dest));
  23. 			
  24. 			String line;//定义变量用于接收每行读取到的数据
  25. 			while((line=br.readLine()) != null){//将读取到行数据存入line并且判断line是不是等于null，如果等于null说明没有读到数据，文件读到末尾
  26. 				bw.write(line);
  27. 				bw.newLine();
  28. 			}
  29. 		}catch(Exception e){
  30. 			e.printStackTrace();
  31. 		}finally{
  32. 			if(br != null){
  33. 				try {
  34. 					br.close();
  35. 				} catch (IOException e) {
  36. 					e.printStackTrace();
  37. 				}
  38. 			}
  39. 			
  40. 			if(bw != null){
  41. 				try {
  42. 					bw.close();
  43. 				} catch (IOException e) {
  44. 					e.printStackTrace();
  45. 				}
  46. 			}
  47. 		}
  48. 		
  49. 	}
  50. }


8、案例(掌握)

1、将一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
2、获取一个文本上每个字符出现的次数,将结果写在times.txt上
3、当我们下载一个试用版软件,没有购买正版的时候,每执行一次就会提醒我们还有多少次使用机会用学过的IO流知识,模拟试用版软件,试用10次机会,执行一次就提示一次您还有几次机会,如果次数到了提示请购买正版
4、获取指定目录下的所有文件
5、递归求5的阶乘

9、案例代码(掌握)

1、将一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
  1. package com.heima.test;
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.FileNotFoundException;
  6. import java.io.FileReader;
  7. import java.io.FileWriter;
  8. import java.io.IOException;
  9. import java.util.ArrayList;
  11. public class Test1 {
  13. 	/**
  14. 	 * @param args
  15. 	 * 将一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
  16. 	 * 
  17. 	 * 分析:
  18. 	 * 1,创建输入输出流对象
  19. 	 * 2,创建集合对象
  20. 	 * 3,将读到的数据存储在集合中
  21. 	 * 4,倒着遍历集合将数据写到文件上
  22. 	 * 5,关流
  23. 	 * @throws IOException 
  24. 	 * 
  25. 	 * 注意事项:
  26. 	 * 流对象尽量晚开早关
  27. 	 */
  28. 	public static void main(String[] args) throws IOException {
  29. 		//改写后是尽量晚开早关
  30. 		// 1,创建输入输出流对象
  31. 		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
  32. 		
  33. 		//2,创建集合对象
  34. 		ArrayList<String> list = new ArrayList<>();
  35. 		//3,将读到的数据存储在集合中
  36. 		String line;
  37. 		while((line = br.readLine()) != null) {
  38. 			list.add(line);
  39. 		}
  40. 		br.close();											//关流
  41. 		
  42. 		//4,倒着遍历集合将数据写到文件上
  43. 		BufferedWriter bw = new BufferedWriter(new FileWriter("revzzz.txt"));
  44. 		for(int i = list.size() - 1; i >= 0; i--) {
  45. 			bw.write(list.get(i));
  46. 			bw.newLine();
  47. 		}
  48. 		//5,关流
  49. 		
  50. 		bw.close();
  51. 	}
  53. }

2、获取一个文本上每个字符出现的次数,将结果写在times.txt上
  1. package com.heima.test;
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.FileNotFoundException;
  6. import java.io.FileReader;
  7. import java.io.FileWriter;
  8. import java.io.IOException;
  9. import java.util.TreeMap;
  11. public class Test3 {
  13. 	/**
  14. 	 * 获取一个文本上每个字符出现的次数,将结果写在times.txt上
  15. 	 * 
  16. 	 * 分析:
  17. 	 * 1,创建带缓冲的输入流对象
  18. 	 * 2,创建双列集合对象TreeMap
  19. 	 * 3,将读到的字符存储在双列集合中,存储的时候要做判断,如果不包含这个键,就将键和1存储,如果包含这个键,就将该键和值加1存储
  20. 	 * 4,关闭输入流
  21. 	 * 5,创建输出流对象
  22. 	 * 6,遍历集合将集合中的内容写到times.txt中
  23. 	 * 7,关闭输出流
  24. 	 * @throws IOException 
  25. 	 */
  26. 	public static void main(String[] args) throws IOException {
  27. 		//1,创建带缓冲的输入流对象
  28. 		BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
  29. 		//2,创建双列集合对象TreeMap
  30. 		TreeMap<Character, Integer> tm = new TreeMap<>();
  31. 		//3,将读到的字符存储在双列集合中,存储的时候要做判断,如果不包含这个键,就将键和1存储,如果包含这个键,就将该键和值加1存储
  32. 		int ch;
  33. 		while((ch = br.read()) != -1) {
  34. 			char c = (char)ch;					//强制类型转换
  35. 			/*if(!tm.containsKey(c)) {
  36. 				tm.put(c, 1);
  37. 			}else {
  38. 				tm.put(c, tm.get(c) + 1);
  39. 			}*/
  40. 			tm.put(c, !tm.containsKey(c) ? 1 : tm.get(c) + 1);
  41. 		}
  42. 		//4,关闭输入流
  43. 		br.close();
  44. 		//5,创建输出流对象
  45. 		BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
  46. 		//6,遍历集合将集合中的内容写到times.txt中
  47. 		for(Character key : tm.keySet()) {
  48. 			switch (key) {
  49. 			case '\t':
  50. 				bw.write("\\t" + "=" + tm.get(key)); 	
  51. 				break;
  52. 			case '\n':
  53. 				bw.write("\\n" + "=" + tm.get(key)); 
  54. 				break;
  55. 			case '\r':
  56. 				bw.write("\\r" + "=" + tm.get(key)); 
  57. 				break;
  58. 			default:
  59. 				bw.write(key + "=" + tm.get(key)); 			//写出键和值
  60. 				break;
  61. 			}
  62. 			bw.newLine();
  63. 		}
  64. 		//7,关闭输出流
  65. 		bw.close();
  66. 	}
  68. }
3、当我们下载一个试用版软件,没有购买正版的时候,每执行一次就会提醒我们还有多少次使用机会用学过的IO流知识,模拟试用版软件,试用10次机会,执行一次就提示一次您还有几次机会,如果次数到了提示请购买正版
  1. package com.heima.test;
  3. import java.io.BufferedReader;
  4. import java.io.FileReader;
  5. import java.io.FileWriter;
  6. import java.io.IOException;
  8. public class Test4 {
  10. 	/**
  11. 	 *  当我们下载一个试用版软件,没有购买正版的时候,每执行一次就会提醒我们还有多少次使用机会用学过的IO流知识,模拟试用版软件,
  12. 	 *  试用10次机会,执行一次就提示一次您还有几次机会,如果次数到了提示请购买正版
  13. 	 * @throws IOException 
  14. 	 * 分析:
  15. 	 * 1,创建带缓冲的输入流对象,因为要使用readLine方法,可以保证数据的原样性
  16. 	 * 2,将读到的字符串转换为int数
  17. 	 * 3,对int数进行判断,如果大于0,就将其--写回去,如果不大于0,就提示请购买正版
  18. 	 * 4,在if判断中要将--的结果打印,并将结果通过输出流写到文件上
  19. 	 */
  20. 	public static void main(String[] args) throws IOException {
  21. 		//1,创建带缓冲的输入流对象,因为要使用readLine方法,可以保证数据的原样性
  22. 		BufferedReader br = new BufferedReader(new FileReader("config.txt"));
  23. 		//2,将读到的字符串转换为int数
  24. 		String line = br.readLine();
  25. 		int times = Integer.parseInt(line);					//将数字字符串转换为数字
  26. 		//3,对int数进行判断,如果大于0,就将其--写回去,如果不大于0,就提示请购买正版
  27. 		if(times > 0) {
  28. 			//4,在if判断中要将--的结果打印,并将结果通过输出流写到文件上
  29. 			System.out.println("您还有" + times-- + "次机会");
  30. 			FileWriter fw = new FileWriter("config.txt");
  31. 			fw.write(times + "");
  32. 			fw.close();
  33. 		}else {
  34. 			System.out.println("您的试用次数已到,请购买正版");
  35. 		}
  36. 		//关闭流
  37. 		br.close();
  38. 	}
  40. }
4、获取指定目录下的所有文件
  1. import java.io.File;
  3. /**
  4.  * 获取指定目录下的所有文件
  5.  * 
  6.  * @author haoyongliang
  7.  * 
  8.  */
  9. public class Demo4 {
  11. 	public static void main(String[] args) {
  12. 		String path = "C:\\";
  13. 		File f = new File(path);
  14. 		show(f);
  15. 	}
  17. 	public static void show(File file) {
  18. 		// 如果是文件
  19. 		if (file.isFile()) {
  20. 			if (file.getName().endsWith(".java")) {
  21. 				System.out.println(file);
  22. 			}
  23. 			// 如果是文件夹
  24. 		} else {
  25. 			if(!file.getName().equals("Documents and Settings") || !file.getName().equals("System Volume Information")){
  26. 				File[] files = file.listFiles();
  27. 				for (File f : files) {
  28. 					show(f);
  29. 				}
  30. 			}
  31. 		}
  32. 	}
  33. }

5、递归求5的阶乘
  1. package com.heima.chario;
  3. public class Demo8_Digui {
  5. 	/**
  6. 	 * @param args
  7. 	 * 递归:方法自己调用自己
  8. 	 * 5!
  9. 	 * 5 * 4 * 3 * 2 * 1
  10. 	 * 
  11. 	 * 5 * fun(4)(代表4!)
  12. 	 * 		4 * fun(3)(代表3!)
  13. 	 * 				3 * fun(2)(代表2!) 
  14. 	 * 						2 * fun(1)(代表1!)
  15. 	 * 递归的弊端:不能调用次数过多,容易导致栈内存溢出
  16. 	 * 递归的好处:不用知道循环次数
  17. 	 * 
  18. 	 * 构造方法是否可以递归调用?
  19. 	 * 构造方法不能使用递归调用
  20. 	 * 
  21. 	 * 递归调用是否必须有返回值?
  22. 	 * 不一定(可以有,也可以没有)
  23. 	 */
  24. 	public static void main(String[] args) {
  25. 		/*int result = 1;
  26. 		
  27. 		for(int i = 1; i <= 5; i++) {
  28. 			result = result * i;
  29. 		}
  30. 		
  31. 		System.out.println(result);*/
  32. 		System.out.println(fun(6000));
  33. 	}
  34. 	
  35. 	public static int fun(int num) {
  36. 		if(num == 1) {
  37. 			return 1;
  38. 		}else {
  39. 			return num * fun(num - 1);
  40. 		}
  41. 	}
  42. }


10、今天必须掌握的内容，面试题，笔试题。

1、说说字符流体系
2、字符缓冲流结合小数组的两种标准代码
3、使用字符缓冲流的特有方法拷贝文件
4、说说装设设计模式的书写步骤和好处，并且自己能独立完成LineNumberReader类
5、将一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
6、获取一个文本上每个字符出现的次数,将结果写在times.txt上
7、获取指定目录下的所有文件，并且说明为什么要过滤Documents and Settings和System Volume Information这两个文件夹
8、递归求5的阶乘




















posted on 2016-12-23 09:55  虫虫爬啊爬  阅读(236)  评论(0)  编辑  收藏  举报

导航