java学习21-字符流，字节流，转换流的理解

1:字符流
 (1)字节流操作中文数据不是特别的方便，所以就出现了转换流。
    转换流的作用就是把字节流转换字符流来使用。
 (2)转换流其实是一个字符流
  字符流 = 字节流 + 编码表

 (3)编码表
  A:就是由字符和对应的数值组成的一张表
  B:常见的编码表
   ASCII
   ISO-8859-1
   GB2312
   GBK
   GB18030
   UTF-8
  C:字符串中的编码问题
   编码
    String -- byte[]
   解码
    byte[] -- String
 (4)IO流中的编码问题
  A:OutputStreamWriter
   OutputStreamWriter(OutputStream os):默认编码，GBK
   OutputStreamWriter(OutputStream os,String charsetName):指定编码。
  B:InputStreamReader
   InputStreamReader(InputStream is):默认编码，GBK
   InputStreamReader(InputStream is,String charsetName):指定编码
  C:编码问题其实很简单
   编码只要一致即可
 (5)字符流
  Reader
   |--InputStreamReader
    |--FileReader
   |--BufferedReader
  Writer
   |--OutputStreamWriter
    |--FileWriter
   |--BufferedWriter
 (6)复制文本文件(5种方式)
    package cn.itcast_01;

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

/*
 * 复制文本文件
 *
 * 分析：
 *   复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
 *   通过该原理，我们知道我们应该采用字符流更方便一些。
 *   而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。
 * 数据源：
 *   c:\\a.txt -- FileReader -- BufferdReader
 * 目的地：
 *   d:\\b.txt -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
  String srcString = "c:\\a.txt";
  String destString = "d:\\b.txt";
  // method1(srcString, destString);
  // method2(srcString, destString);
  // method3(srcString, destString);
  // method4(srcString, destString);
  method5(srcString, destString);
 }

 // 字符缓冲流一次读写一个字符串
 private static void method5(String srcString, String destString)
   throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(srcString));
  BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

  String line = null;
  while ((line = br.readLine()) != null) {
   bw.write(line);
   bw.newLine();
   bw.flush();
  }

  bw.close();
  br.close();
 }

 // 字符缓冲流一次读写一个字符数组
 private static void method4(String srcString, String destString)
   throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(srcString));
  BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

  char[] chs = new char[1024];
  int len = 0;
  while ((len = br.read(chs)) != -1) {
   bw.write(chs, 0, len);
  }

  bw.close();
  br.close();
 }

 // 字符缓冲流一次读写一个字符
 private static void method3(String srcString, String destString)
   throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(srcString));
  BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

  int ch = 0;
  while ((ch = br.read()) != -1) {
   bw.write(ch);
  }

  bw.close();
  br.close();
 }

 // 基本字符流一次读写一个字符数组
 private static void method2(String srcString, String destString)
   throws IOException {
  FileReader fr = new FileReader(srcString);
  FileWriter fw = new FileWriter(destString);

  char[] chs = new char[1024];
  int len = 0;
  while ((len = fr.read(chs)) != -1) {
   fw.write(chs, 0, len);
  }

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

 // 基本字符流一次读写一个字符
 private static void method1(String srcString, String destString)
   throws IOException {
  FileReader fr = new FileReader(srcString);
  FileWriter fw = new FileWriter(destString);

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

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

2:IO流小结(掌握)
 IO流
  |--字节流
   |--字节输入流
    InputStream
     int read():一次读取一个字节
     int read(byte[] bys):一次读取一个字节数组
    
     |--FileInputStream
     |--BufferedInputStream
   |--字节输出流
    OutputStream
     void write(int by):一次写一个字节
     void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
     
     |--FileOutputStream
     |--BufferedOutputStream
  |--字符流
   |--字符输入流
    Reader
     int read():一次读取一个字符
     int read(char[] chs):一次读取一个字符数组
     
     |--InputStreamReader
      |--FileReader
     |--BufferedReader
      String readLine():一次读取一个字符串
   |--字符输出流
    Writer
     void write(int ch):一次写一个字符
     void write(char[] chs,int index,int len):一次写一个字符数组的一部分
     
     |--OutputStreamWriter
      |--FileWriter
     |--BufferedWriter
      void newLine():写一个换行符
      
      void write(String line):一次写一个字符串

3:案例
 A:复制文本文件 5种方式
 B:复制图片(二进制流数据) 4种方式(掌握)
 分析：
 *   复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
 *   通过该原理，我们知道我们应该采用字节流。
 *   而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。
 *
 * 数据源：
 *   c:\\a.jpg -- FileInputStream -- BufferedInputStream
 * 目的地：
 *   d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
 C:把集合中的数据存储到文本文件
 分析：
 *   通过题目的意思我们可以知道如下的一些内容，
 *    ArrayList集合里存储的是字符串。
 *    遍历ArrayList集合，把数据获取到。
 *    然后存储到文本文件中。
 *    文本文件说明使用字符流。
 *
 * 数据源：
 *   ArrayList<String> -- 遍历得到每一个字符串数据
 * 目的地：
 *   a.txt -- FileWriter -- BufferedWriter
 D:把文本文件中的数据读取到集合并遍历集合
 分析：
 *   通过题目的意思我们可以知道如下的一些内容，
 *    数据源是一个文本文件。
 *    目的地是一个集合。
 *    而且元素是字符串。
 *
 * 数据源：
 *   b.txt -- FileReader -- BufferedReader
 * 目的地：
 *   ArrayList<String>
 E:复制单级文件夹
 
 * 数据源：e:\\demo
 * 目的地：e:\\test
 *
 * 分析：
 *   A:封装目录
 *   B:获取该目录下的所有文本的File数组
 *   C:遍历该File数组，得到每一个File对象
 *   D:把该File进行复制
 F:复制单级文件夹中指定的文件并修改名称
 
  回顾一下批量修改名称
  指定的文件是：.java文件。
 * 指定的后缀名是：.jad
 * 指定的目录是：jad
 *
 * 数据源：e:\\java\\A.java
 * 目的地：e:\\jad\\A.jad
 *
 * 分析：
 *   A:封装目录
 *   B:获取该目录下的java文件的File数组
 *   C:遍历该File数组，得到每一个File对象
 *   D:把该File进行复制
 *   E:在目的地目录下改名
 G:复制多级文件夹
 数据源：E:\JavaSE\day21\code\demos
 * 目的地：E:\\
 *
 * 分析：
 *   A:封装数据源File
 *   B:封装目的地File
 *   C:判断该File是文件夹还是文件
 *    a:是文件夹
 *     就在目的地目录下创建该文件夹
 *     获取该File对象下的所有文件或者文件夹File对象
 *     遍历得到每一个File对象
 *     回到C
 *    b:是文件
 *     就复制(字节流)
 H:键盘录入学生信息按照总分从高到低存储到文本文件
 分析：
 *   A:创建学生类
 *   B:创建集合对象
 *    TreeSet<Student>
 *   C:键盘录入学生信息存储到集合
 *   D:遍历集合，把数据写到文本文件
 I:把某个文件中的字符串排序后输出到另一个文本文件中
 分析：
 *   A:把s.txt这个文件给做出来
 *   B:读取该文件的内容，存储到一个字符串中
 *   C:把字符串转换为字符数组
 *   D:对字符数组进行排序
 *   E:把排序后的字符数组转换为字符串
 *   F:把字符串再次写入ss.txt中
 */
 J:用Reader模拟BufferedReader的特有功能
 readLine():一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符
 K:模拟LineNumberReader的特有功能
 BufferedReader
 *   |--LineNumberReader
 *    public int getLineNumber()获得当前行号。
 *    public void setLineNumber(int lineNumber)
 */

a.

/*
 * 打印流
 * 字节流打印流    PrintStream
 * 字符打印流    PrintWriter
 * 
 * 打印流的特点：
 *         A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
 *         B:可以操作任意类型的数据。
 *         C:如果启动了自动刷新，能够自动刷新。
 *         D:该流是可以直接操作文本文件的。
 *             哪些流对象是可以直接操作文本文件的呢?
 *             FileInputStream
 *             FileOutputStream
 *             FileReader
 *             FileWriter
 *             PrintStream
 *             PrintWriter
 *             看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
 * 
 *             流：
 *                 基本流：就是能够直接读写文件的
 *                 高级流：在基本流基础上提供了一些其他的功能
 */

/*
 * 需求：DataStreamDemo.java复制到Copy.java中
 * 数据源：
 *         DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
 * 目的地：
 *         Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
 */

/*
 * 1:可以操作任意类型的数据。
 *         print()
 *         println()
 * 2:启动自动刷新
 *         PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
 *         还是应该调用println()的方法才可以
 *         这个时候不仅仅自动刷新了，还实现了数据的换行。
 * 
 *         println()
 *        其实等价于于：
 *        bw.write();
 *        bw.newLine();        
 *        bw.flush();
 */