[关闭]
@w460461339 2016-11-15T23:08:19.000000Z 字数 10379 阅读 1034

Java学习Day10（字符流 以及N多例子）

Java基础

今天学习的是字符流。在学习字符流之前，我们还是把File和字节流再理一遍。

1.Review

File类
其中储存的是文件或者文件夹的抽象路径名。即，无论这个文件存在不存在，都可以写出来。
通过它，可以创建文件/文件夹，获取类型，获取名称，获取文件夹内所有的文件等等操作。总而言之，它是针对文件这个整体进行操作，不涉及文件具体储存内容的修改。

字节流
字节流有两种，输入流和输出流。
输出流：

OutputStream（抽象类)→FileOutputStream(实现子类）或BufferedOutputStream（高速流）

输入流：

InputStream（抽象类）→FileInputStream（实现子类）或者BufferedInputStream（高速流）

构造时，利用File（包装好的文件路径）或者String（字符串表示的文件路径）都行。
字节流能够实现对文件内部数据的操作。注意，此时就没文件夹什么事了，全部都是对文件的。比如往文件内部写入数据，从文件内部读出数据，将文件A的数据复制给文件B等等。所以，字节流是针对文件内部数据的。

2.字符流

字符流=字节流+编码表
因此，最基本的字符流是通过字节流与制定编码表得到的。

2.1 字符转换流

按照前文的定义，字符流=字节流+编码表。字符转换流就是负责这一操作的。同理，这也有字符输入流和字符输出流之分。

2.1.1字符输出转换流

Writer（抽象类）→OutputStreamWriter（具体实现类）
OutputStreamWriter的构造方法需要一个字节输出流OutputStream的对象以及用String表示指定的编码表，比如“GBK”,"UTF-8"等等。

其中，可以通过write方法往文件中写入数据
void write(int c) 等于 void write(char c);
void write(String st);
void write(char[] chas,int start,int off);

2.1.2字符输入转换流

Reader（抽象类）→InputStreamWriter（具体实现类）
InputStreamWriter的构造方法需要一个字节输入流InputStream的对象以及用String表示指定的编码表，比如“GBK”,"UTF-8"等等。

其中，可以通过read方法来读取。read方法有两种形式
int read();//一次读取一个字符
int read(char[] chs);//一次读取一个字符数组

2.1.3代码演示
  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStreamWriter;
  7. public class ZifuStream {
  8.     public static void main(String[] args)throws IOException {
  9.         //指明读取和写入都是按照GBK的编码表来读入和写入
  10.         InputStreamReader isr=new InputStreamReader(
  11.                         new FileInputStream("a.txt"), "GBK");
  12.         OutputStreamWriter osw=new OutputStreamWriter(
  13.                         new FileOutputStream("b.txt"), "GBK");
  14.         //利用一次读取一个字符数组来读取
  15.         int len=0;
  16.         char[] chs=new char[1024];
  17.         while((len=isr.read(chs))!=-1){
  18.             osw.write(chs, 0, len);
  19.         }
  20.         osw.flush();//刷新后数据才进文件
  21.         osw.close();//关闭时自动刷新
  22.         isr.close();
  23.     }
  24. }
2.2 简化字符流

之前那个字符转化流在可以自己指定编码表的同时，名字太长了，用起来不方便。因此诞生了简化的字符流。
简化字符输出流：

Writer（抽象类）→OutputStreamWriter（具体实现类）→FileWriter（具体实现类）

简化字符输入流：

Reader（抽象类）→InputStreamWriter（具体实现类）→FileReader（具体实现类）

这两个类除了构造函数可以直接利用String类型或者File类型来读取文件，并且采用系统默认的编码表以外，和他们的父类没有区别。

  1. import java.io.FileReader;
  2. import java.io.FileWriter;
  3. import java.io.IOException;
  5. public class MyFileWriter_Reader {
  7.     public static void main(String[] args) throws IOException {
  8.         FileReader isr=new FileReader("a.txt");//默认编码表
  9.         FileWriter osw=new FileWriter("b.txt");
  10.         int len=0;
  11.         char[] chs=new char[1024];
  12.         while((len=isr.read(chs))!=-1){
  13.             osw.write(chs, 0, len);
  14.         }
  15.         osw.flush();
  16.         osw.close();
  17.         isr.close();
  18.     }
  19. }
2.3 高效字符流

高效字符输入流：

Reader（抽象类）→BufferedReader（实现类）
其构造方法需要用Reader的具体实现类作为参数

高效字符输出流：

Writer（抽象类）→BufferedWriter（实现类）
其构造方法需要用Writer的具体实现类作为参数

其输入和输出的基本用法和之前的基本流完全一样，下面演示其特有用法

  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;
  7. public class BufferedDemo {
  9.     public static void main(String[] args) throws IOException{
  10.         //Reader与Writer的具体实现类作为构造函数的参数
  11.         BufferedReader br=new BufferedReader(
  12.                             new FileReader("a.txt"));
  13.         BufferedWriter bw=new BufferedWriter(
  14.                             new FileWriter("b.txt"));
  15.         //初始化字符串为null
  16.         String st=null;
  17.         //reanLine按行读入，遇到换行符停止，因此不会读入换行符。
  18.         //在复制时需要自行写入
  19.         //读到末尾时，返回null
  20.         while((st=br.readLine())!=null){
  21.             bw.write(st);//按行写入
  22.             bw.newLine();//人工换行
  23.             bw.flush();//刷新
  24.         }
  25.         bw.close();//关了
  26.         br.close();//关了
  27.     }
  28. }

3.练习

3.1 把ArrayList中的数据存储到文本文件中。

分析：
A：构建ArrayList，存入数据
B：利用字符流输出。构建BufferedWriter高效字符输出流。
C：遍历ArrayList，将每次结果输出到txt文件中。
D：利用BufferedWriter的newLine，换行

  1. import java.io.BufferedWriter;
  2. import java.io.File;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.util.ArrayList;
  7. public class CopyArraytoTxtDemo {
  9.     public static void main(String[] args) throws IOException{
  10.     //添加数据
  11.         ArrayList<String> myarray=new ArrayList<String>();
  12.         myarray.add("hello");
  13.         myarray.add("world");
  14.         myarray.add("java");
  15.     //两种输出方式，FileWriter基本输出流
  16.         //FileWriter fw=new FileWriter(new File("c.txt"));
  17.     //BufferedWriter高效输出流
  18.         BufferedWriter bw=new BufferedWriter(new FileWriter(new File("d.txt")));
  19.     //遍历
  20.         for(String s:myarray){
  21.             bw.write(s);
  22.             bw.newLine();//换行
  23.             bw.flush();//刷新
  24.         }
  25.         bw.close();//关闭
  26.     }
  27. }
3.2把文本文件中的数据以字符串形式按行输入到ArrayList中
  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.util.ArrayList;
  7. public class CopyTxttoArrayDemo {
  8.     /**
  9.      * 分析：
  10.      *    A：利用BufferedReader按行读入数据
  11.      *    B：将数据转换为String
  12.      *    C：存入ArrayList
  13.      *    D：遍历，在控制台显示
  14.      */
  15.     public static void main(String[] args)throws IOException {
  16.         // TODO Auto-generated method stub
  17.         BufferedReader br=new BufferedReader(
  18.                         new FileReader(new File("a.txt")));
  19.         ArrayList<String> myarray=new ArrayList<String>();
  20.         String s=null;
  21.         while((s=br.readLine())!=null){
  22.             myarray.add(s);
  23.         }
  24.         for(String st:myarray){
  25.             System.out.println(st);
  26.         }
  27.     }
  28. }
3.3复制单级文件夹
  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.File;
  4. import java.io.FileReader;
  5. import java.io.FileWriter;
  6. import java.io.IOException;
  8. public class CopyFoldertoFolder {
  10.     /**
  11.      * @param args
  12.      * 分析：
  13.      * 源文件夹：aaa
  14.      * 目标文件夹：bbb
  15.      *      A：单级文件夹，获取该文件夹下所有文件
  16.      *      B：判断目标文件夹是否存在，否，创建
  17.      *      C：将所有文件写入目标文件夹中
  18.      */
  19.     public static void main(String[] args) throws IOException{
  20.         // TODO Auto-generated method stub
  21.         //封装源文件夹下的所有文件
  22.         File myFile=new File("aaa");
  23.         File[] myFileList=myFile.listFiles();
  24.         //封装目标文件夹
  25.         File aimFile=new File("bbb");
  26.         if(!aimFile.exists()){
  27.             aimFile.mkdir();
  28.         }
  29.         //复制文件进另外一个文件
  30.         for(File fl:myFileList){
  31.             copyFile(fl,aimFile);   
  32.         }
  33.     }
  35.     private static void copyFile(File fl, File aimFile) throws IOException{
  36.         // 源文件的表示，直接用fl来构建就好
  37.         BufferedReader br=new BufferedReader(new FileReader(fl));
  38.         //目标文件，必须用File+String的方式构建目标文件夹下的目标文件。否则，就不是复制到目标文件夹下了。
  39.         BufferedWriter bw=new BufferedWriter(
  40.                    new FileWriter(new File(aimFile,fl.getName())));
  41.         String st=null;
  42.         while((st=br.readLine())!=null){
  43.             bw.write(st);
  44.             bw.newLine();
  45.             bw.flush();
  46.         }
  47.         bw.close();
  48.         br.close();
  49.     }
  50. }
3.4复制多级文件夹

以最开始的为例子：
1："aaa"文件夹和"d:\"进入copyFolders
2：判断“aaa”是不是文件夹
3：是文件夹。
|----3.1：首先在d:\ 下创建aaa文件夹
|----3.2：遍历原来的aaa文件夹，得到其中每一个内容 fl。
|----3.3：把 fl 和 d:\aaa 传入copyFolders，开始递归。回到2
4：不是文件夹（假设aaa不是文件夹）
|----4.1：在d：\ 下创建aaa同名空文件。
|----4.2：将源文件“aaa”复制到d：\ 下的aaa空文件中

  1. package exercise;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  10. public class CopyFolderstoFolders {
  12.     /**
  13.      *  需求：将源文件夹下所有内容复制到目标文件夹下
  14.      *  分析：
  15.      *      A：封装源文件夹，以及目标文件夹
  16.      *      B：判断源是否是文件夹
  17.      *          C1：是：封装文件夹下所有内容，遍历，回到B
  18.      *          C2：否：复制文件到另一文件夹中
  19.      */
  20.     public static void main(String[] args) throws IOException{
  21.         // 封装源文件夹与目标文件夹
  22.         File srcFolder=new File("aaa");
  23.         File aimFolder=new File("d:\\");
  24.         copyFolders(srcFolder,aimFolder);
  25.     }
  27.     private static void copyFolders(File srcFolder, File aimFolder) throws IOException{
  28.     //注意，先判断，后封装！！！！
  29.     //先判断源文件是否是文件夹
  30.         if(srcFolder.isDirectory()){
  31.         //是文件夹，在目标位置创造同名文件夹
  32.             File destFile=new File(aimFolder,srcFolder.getName());
  33.             destFile.mkdir();
  34.         //封装其下所有内容
  35.             File[] srcFileList=srcFolder.listFiles();
  36.             for(File fl:srcFileList){
  37.         //遍历，递归
  38.                 copyFolders(fl,destFile);
  39.             }
  40.         }else{
  41.         //不是文件夹
  42.         //先在目标文件夹下创建同名文件
  43.             File destFile=new File(aimFolder,srcFolder.getName());
  44.         //文件对文件的复制
  45.             copy(srcFolder,destFile);
  46.         }
  47.     }
  48.     //复制文件
  49.     private static void copy(File srcFolder, File destFile)throws IOException {
  50.         BufferedInputStream bis=new BufferedInputStream(
  51.                                 new FileInputStream(srcFolder));
  52.         BufferedOutputStream bos=new BufferedOutputStream(
  53.                                 new FileOutputStream(destFile));
  54.         int len=0;
  55.         byte[] bys=new byte[1024];
  56.         while((len=bis.read(bys))!=-1){
  57.             bos.write(bys, 0, len);
  58.         }
  59.         bos.close();
  60.         bis.close();
  61.     }
  62. }
3.5复制单级文件夹下特定文件到新的文件夹，并改名
  1. package exercise;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileOutputStream;
  8. import java.io.FilenameFilter;
  9. import java.io.IOException;
  11. public class CopyandRename {
  13.     /**
  14.      * @param args
  15.      * 需求：
  16.      *      将单级文件夹bbb中的.java文件复制到和bbb同目录下的ccc文件夹中
  17.      *      并改名为a3.jad，b3.jad.
  18.      *分析：
  19.      *      A：获取bbb中所有.java文件
  20.      *      B：将获取到的.java文件复制到ccc下
  21.      *      C：在ccc下对文件进行改名
  22.      *      PS：若是不复制之间改名到CCC下的话，相当于把bbb中文件剪
  23.      *          切到CCC中在改名。
  24.      */
  25.     public static void main(String[] args)throws IOException {
  26.         //封装源文件夹和目标文件夹
  27.         File srcFolder=new File("bbb");
  28.         File destFolder=new File("ccc");
  29.         //判断目标文件夹是否存在
  30.         if(!destFolder.exists()){
  31.             destFolder.mkdir();
  32.         }
  33.         //获取所有以.java结尾的文件
  34.         File[] srcFileList=srcFolder.listFiles(new FilenameFilter()         {
  35.             @Override
  36.             public boolean accept(File dir, String name) {
  37.                 // 判断是否是文件，以及判断是否以.java结尾
  38.                 return new File(dir,name).isFile()
  39.                                 && name.endsWith(".java");
  40.             }
  41.         });
  42.         //复制到ccc中
  43.         for(File fl:srcFileList){
  44.             File destFile=new File(destFolder,fl.getName());
  45.             copyFile(fl,destFile);
  46.         }
  47.         //获取ccc中所有文件
  48.         File[] destFileList=destFolder.listFiles();
  49.         //改名
  50.         for(File fl:destFileList){
  51.             String oldname=fl.getName();
  52.             String newName=oldname.replaceAll(".java", ".jad");
  53.             fl.renameTo(new File(destFolder,newName));
  54.         }
  55.     }
  56.     //复制文件
  57.     private static void copyFile(File fl, File destFile)throws IOException {
  58.         BufferedInputStream bis=new BufferedInputStream(
  59.                                     new FileInputStream(fl));
  60.         BufferedOutputStream bos=new BufferedOutputStream(
  61.                                 new FileOutputStream(destFile));
  62.         int len=0;
  63.         byte[] bys=new byte[1024];
  64.         while((len=bis.read(bys))!=-1){
  65.             bos.write(bys, 0, len);
  66.         }
  67.         bos.close();
  68.         bis.close();
  69.     }
  70. }
3.6输入N个学生姓名和成绩，按照成绩顺序输出到txt文件中
  1. package exercise;
  3. import java.io.BufferedWriter;
  4. import java.io.File;
  5. import java.io.FileWriter;
  6. import java.io.IOException;
  7. import java.util.Comparator;
  8. import java.util.Scanner;
  9. import java.util.TreeSet;
  10. //创建学生类
  11. class Student{
  12.     private String name;
  13.     private int chinese;
  14.     private int math;
  15.     private int english;
  16.     public Student(String name, int chinese, int math, int english) {
  17.         super();
  18.         this.name = name;
  19.         this.chinese = chinese;
  20.         this.math = math;
  21.         this.english = english;
  22.     }
  23.     public String getName() {
  24.         return name;
  25.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  29.     public int getChinese() {
  30.         return chinese;
  31.     }
  32.     public void setChinese(int chinese) {
  33.         this.chinese = chinese;
  34.     }
  35.     public int getMath() {
  36.         return math;
  37.     }
  38.     public void setMath(int math) {
  39.         this.math = math;
  40.     }
  41.     public int getEnglish() {
  42.         return english;
  43.     }
  44.     public void setEnglish(int english) {
  45.         this.english = english;
  46.     }
  47.     public int getSum(){
  48.         return chinese+math+english;
  49.     }
  51. }
  53. public class InsertStuentScoreinOder {
  55.     /**
  56.      * 需求：输入5个学生成绩，按照其总分，语文，数学，外语，姓名的顺序排序
  57.      * 分析：
  58.      *      A：构建学生类，能够获得其总分，语数外姓名等信息
  59.      *      B：利用TreeSet存储，自定义comparator
  60.      *      C：输出到txt文件中
  61.      * @throws IOException 
  62.      */
  63.     public static void main(String[] args) throws IOException {
  64.         //用来存储学生信息，自定义比较器
  65.         TreeSet<Student> st=new TreeSet<Student>(new Comparator<Student>() {
  66.         @Override
  67.         public int compare(Student o1, Student o2) {
  68.             //o2在前表示从大到小
  69.             int r1=o2.getSum()-o1.getSum();
  70.             int r2= r1==0?o2.getChinese()-o1.getChinese():r1;
  71.             int r3= r2==0?o2.getMath()-o1.getMath():r2;
  72.             int r4= r3==0?o2.getEnglish()-o1.getEnglish():r3;
  73.             int r5= r4==0?o2.getName().compareTo(o1.getName()):r4;
  74.                 return r5;
  75.             }
  76.         });
  77.         //读入数据，注意Scanner要在内部定义，不然in.nextLine在循环
  78.         //第二次会因为读入换行符而失效
  79.         for(int i=1;i<=3;i++){
  80.             Scanner in =new Scanner(System.in);
  81.             System.out.println("name");
  82.             String name=in.nextLine();
  83.             System.out.println("chinese");
  84.             int chinese=in.nextInt();
  85.             System.out.println("math");
  86.             int math=in.nextInt();
  87.             System.out.println("english");
  88.             int english=in.nextInt();
  89.             Student s=new Student(name,chinese,math,english);
  90.             st.add(s);
  91.         }
  92.         //封装目标文件
  93.         File score=new File("Student.txt");
  94.         //创建输出流
  95.         BufferedWriter bw=new BufferedWriter(
  96.                 new FileWriter(score));
  97.         for(Student stu:st){
  98.         //构造字符串
  99.             StringBuilder sbu=new StringBuilder();
  100.             sbu.append(stu.getName()).append("  C:").append(stu.getChinese()).append("  M:").append(stu.getMath()).append("  E:").append(stu.getEnglish());
  101.             String line=sbu.toString();
  102.         //输出
  103.             bw.write(line);
  104.             bw.newLine();
  105.             bw.flush();
  106.         }
  107.         //关闭
  108.         bw.close();
  109.     }
  110. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注