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;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.io.LineNumberReader;
  6. public class Demo5_LineNumberReader {
  7. /**
  8. * @param args
  9. * @throws IOException
  10. */
  11. public static void main(String[] args) throws IOException {
  12. LineNumberReader lnr = new LineNumberReader(new FileReader("zzz.txt"));
  13. String line;
  14. lnr.setLineNumber(100);
  15. while((line = lnr.readLine()) != null) {
  16. System.out.println(lnr.getLineNumber() + ":" + line);
  17. }
  18. lnr.close();
  19. }
  20. }

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

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

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

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




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

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

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


8、案例(掌握)

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

5、递归求5的阶乘

9、案例代码(掌握)

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

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

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


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

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
















Day21_IO第三天的更多相关文章

  1. 常用 Gulp 插件汇总 —— 基于 Gulp 的前端集成解决方案(三)

    前两篇文章讨论了 Gulp 的安装部署及基本概念,借助于 Gulp 强大的 插件生态 可以完成很多常见的和不常见的任务.本文主要汇总常用的 Gulp 插件及其基本使用,需要读者对 Gulp 有一个基本 ...

  2. 【原】FMDB源码阅读(三)

    [原]FMDB源码阅读(三) 本文转载请注明出处 —— polobymulberry-博客园 1. 前言 FMDB比较优秀的地方就在于对多线程的处理.所以这一篇主要是研究FMDB的多线程处理的实现.而 ...

  3. Jquery的点击事件,三句代码完成全选事件

    先来看一下Js和Jquery的点击事件 举两个简单的例子 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN&q ...

  4. node.js学习(三)简单的node程序&&模块简单使用&&commonJS规范&&深入理解模块原理

    一.一个简单的node程序 1.新建一个txt文件 2.修改后缀 修改之后会弹出这个,点击"是" 3.运行test.js 源文件 使用node.js运行之后的. 如果该路径下没有该 ...

  5. 简谈百度坐标反转至WGS84的三种思路

    文章版权由作者李晓晖和博客园共有,若转载请于明显处标明出处:http://www.cnblogs.com/naaoveGIS/ 1.背景 基于百度地图进行数据展示是目前项目中常见场景,但是因为百度地图 ...

  6. 一起学 Java(三) 集合框架、数据结构、泛型

    一.Java 集合框架 集合框架是一个用来代表和操纵集合的统一架构.所有的集合框架都包含如下内容: 接口:是代表集合的抽象数据类型.接口允许集合独立操纵其代表的细节.在面向对象的语言,接口通常形成一个 ...

  7. 谈谈一些有趣的CSS题目(三)-- 层叠顺序与堆栈上下文知多少

    开本系列,讨论一些有趣的 CSS 题目,抛开实用性而言,一些题目为了拓宽一下解决问题的思路,此外,涉及一些容易忽视的 CSS 细节. 解题不考虑兼容性,题目天马行空,想到什么说什么,如果解题中有你感觉 ...

  8. 如何一步一步用DDD设计一个电商网站(三)—— 初涉核心域

    一.前言 结合我们本次系列的第一篇博文中提到的上下文映射图(传送门:如何一步一步用DDD设计一个电商网站(一)—— 先理解核心概念),得知我们这个电商网站的核心域就是销售子域.因为电子商务是以信息网络 ...

  9. 测试一下StringBuffer和StringBuilder及字面常量拼接三种字符串的效率

    之前一篇里写过字符串常用类的三种方式<java中的字符串相关知识整理>,只不过这个只是分析并不知道他们之间会有多大的区别,或者所谓的StringBuffer能提升多少拼接效率呢?为此写个简 ...

随机推荐

  1. qml中打开本地html

    main.cpp QString tmploc = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation); QDi ...

  2. cacti结合nagios

    使用系统ubuntu12.0.45 监控软件,cacti 使用的是源码安装系统自带的版本过低需要添加插件 nagios采用的系统自带版本 安装nagios apt-get install nagios ...

  3. daydayup1 codeforces141c

    题意:给定n个数字,代表每个人前面有几个人比他高,让你构造一个height数组,满足条件 思路:直接贪心就好,假设到第i个人,设他的高度为i-a[i]+1,前面比他高的人每个人的高度加1

  4. 【 2013 Multi-University Training Contest 4 】

    HDU 4632 Palindrome subsequence dp[x][y]表示区间[x,y]构成回文串的方案数. 若str[x]==str[y],dp[x][y]=dp[x+1][y]+dp[x ...

  5. js实现图片预览

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding= ...

  6. openssl

    openssl genrsa -des3 -out server.key 1024openssl req -new server.key -out servr.csr seserver-fnamese ...

  7. C++小项目:directx11图形程序(二):systemclass

    先上代码: systemclass.h #pragma once #include"graphicsclass.h" const bool FULLSCREEN = true; c ...

  8. 微信公众号网页开发-jssdk config配置参数生成(Java版)

    一.配置参数 参考官方文档:http://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421141115&token=&la ...

  9. Hollister Outlet Store

    (link to hollisterco site), It's a major try. After a photographer's viewpoint, Which roughly splend ...

  10. flex页面刷新实现

    页面刷新:navigateToURL(new URLRequest("javascript:location.reload();"),"_self"); 关闭浏 ...