• 字符流学习14.3

    目录

    1.字符流

    1.1为什么会出现字符流【理解】

    1.2编码表【理解】

    1.3字符串中的编码解码问题【应用】

    1.4字符流中的编码解码问题【应用】

    1.5字符流写数据的5种方式【应用】

    1.6字符流读数据的2种方式【应用】

    1.7字符流复制Java文件【应用】

    1.8字符流复制Java文件改进版【应用】

    1.9字符缓冲流【应用】

    1.10字符缓冲流复制Java文件【应用】

    1.11字符缓冲流特有功能【应用】

    1.12字符缓冲流特有功能复制Java文件【***应用】

    1.13IO流小结【理解】

    2练习案例

    2.1集合到文件【应用】

    2.2文件到集合【应用】

    2.3点名器【应用】

    2.4集合到文件改进版【应用】

    2.5文件到集合改进版【应用】

    3.IO流案例

    3.1集合到文件数据排序改进版【应用】

    3.2复制单级文件夹【应用】

    3.3复制多级文件夹【应用】

    3.4复制文件的异常处理【应用】

    1.字符流

    1.1为什么会出现字符流【理解】

    • 字符流的介绍

      由于字节流操作中文不是特别的方便，所以Java就提供字符流

      字符流 = 字节流 + 编码表

    • 中文的字节存储方式

      用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

      汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

    1.2编码表【理解】

    基础知识:
    计算机中储存的信息都是用二进制数表示的;我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果
    按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。这里强调一下:按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象
    字符编码:就是一套自然语言的字符与二进制数之间的对应规则(A65)
     

    • 什么是字符集

      是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

      计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

    • 常见的字符集

      • ASCII字符集：

        ASCIl(American Standard Code for Information Interchange，美国信息交换标准代码)
        ：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)

        基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

      • GBXXX字符集：

             GB2312:简体中文码表。一个小于127的字符的意义与原来相同，但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名等都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符

           GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

           GB18030:最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等

    • Unicode字符集：

    为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF32。最为常用的UTF-8编码

    UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用 中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码

         编码规则：

    128个US-ASCII字符，只需一个字节编码

    拉丁文等字符，需要二个字节编码

    大部分常用字（含中文），使用三个字节编码

    其他极少使用的Unicode辅助字符，使用四字节编码

    小结:采用何种规则编码，就要采用对应规则解码，否则就会出现乱码
     

    1.3字符串中的编码解码问题【应用】

    • 相关方法

      方法名说明
      byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节
      byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节
      String(byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串
      String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串

    • 代码演示

      public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";
​
        //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
        //byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));
​
        //String ss = new String(bys);
        //String ss = new String(bys,"UTF-8");
        String ss = new String(bys,"GBK");//会乱码，以为默认UTF-8
        System.out.println(ss);
    }
}

    1.4字符流中的编码解码问题【应用】

    • 字符流中和编码解码问题相关的两个类

      • InputStreamReader：是从字节流到字符流的桥梁

        它读取字节，并使用指定的编码将其解码为字符

        它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

      • OutputStreamWriter：是从字符流到字节流的桥梁

        是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节

        它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

    • 构造方法

      方法名说明
      InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象
      InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
      OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象
      OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象

    • 代码演示

      public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter osw = new OutputStreamWriter(new                                             FileOutputStream("myCharStream\\osw.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new                                              FileOutputStream("myCharStream\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();
​
        //InputStreamReader isr = new InputStreamReader(new                                              FileInputStream("myCharStream\\osw.txt"));//默认UTF-8
        InputStreamReader isr = new InputStreamReader(new                                                 FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1) {
            System.out.print((char)ch);
        }
        isr.close();
    }
}

    1.5字符流写数据的5种方式【应用】

    • 方法介绍

      方法名说明
      void write(int c)写一个字符
      void write(char[] cbuf)写入一个字符数组
      void write(char[] cbuf, int off, int len)写入字符数组的一部分
      void write(String str)写一个字符串
      void write(String str, int off, int len)写一个字符串的一部分

    • 刷新和关闭的方法

      方法名说明
      flush()刷新流，之后还可以继续写数据
      close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

    • 代码演示

      public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
​
        //void write(int c)：写一个字符
//        osw.write(97);
//        osw.write(98);
//        osw.write(99);
​
        //void writ(char[] cbuf)：写入一个字符数组
        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        osw.write(chs);
​
        //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
//        osw.write(chs, 0, chs.length);
//        osw.write(chs, 1, 3);
​
        //void write(String str)：写一个字符串
//        osw.write("abcde");
​
        //void write(String str, int off, int len)：写一个字符串的一部分
//        osw.write("abcde", 0, "abcde".length());
        osw.write("abcde", 1, 3);
​
        //释放资源
        osw.close();
    }
}

    1.6字符流读数据的2种方式【应用】

    • 方法介绍

      方法名说明
      int read()一次读一个字符数据
      int read(char[] cbuf)一次读一个字符数组数据

    • 代码演示

      public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
   
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
​
        //int read()：一次读一个字符数据
//        int ch;
//        while ((ch=isr.read())!=-1) {
//            System.out.print((char)ch);
//        }
​
        //int read(char[] cbuf)：一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }
​
        //释放资源
        isr.close();
    }
}

    1.7字符流复制Java文件【应用】

    • 案例需求

      把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”

    • 实现步骤

      • 根据数据源创建字符输入流对象

      • 根据目的地创建字符输出流对象

      • 读写数据，复制文件

      • 释放资源

    • 代码实现

      public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\Copy.java"));
​
        //读写数据，复制文件
        //一次读写一个字符数据
//        int ch;
//        while ((ch=isr.read())!=-1) {
//            osw.write(ch);
//        }
​
        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=isr.read(chs))!=-1) {
            osw.write(chs,0,len);
        }
​
        //释放资源
        osw.close();
        isr.close();
    }
}

    1.8字符流复制Java文件改进版【应用】

    • 案例需求

      使用便捷流对象，把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”

    • 分析:
      转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类FileReader:用于读取字符文件的便捷类
      FileReader(String fileName)
      3FileWriter:用于写入字符文件的便捷类
      FileWriter(String fileName)
      数据源和目的地的分析
      数据源: myCharStream\lConversionStreamDemojava ---读数据---Reader ---InputStreamReader --- FileReader目的地: myCharStreamll Copy.java ---写数据---Writer --- OutputStreamWriter --- FileWriter
       

    • 实现步骤

      • 根据数据源创建字符输入流对象

      • 根据目的地创建字符输出流对象

      • 读写数据，复制文件

      • 释放资源

    • 代码实现

      public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
        //根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("myCharStream\\Copy.java");
​
        //读写数据，复制文件
//        int ch;
//        while ((ch=fr.read())!=-1) {
//            fw.write(ch);
//        }
​
        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }
​
        //释放资源
        fw.close();
        fr.close();
    }
}

    1.9字符缓冲流【应用】

    • 字符缓冲流介绍

      • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

      • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

    • 构造方法

      方法名说明
      BufferedWriter(Writer out)创建字符缓冲输出流对象
      BufferedReader(Reader in)创建字符缓冲输入流对象

    • 代码演示

      public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
        BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));
        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();
​
        //BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));
​
        //一次读取一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1) {
//            System.out.print((char)ch);
//        }
​
        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            System.out.print(new String(chs,0,len));
        }
​
        br.close();
    }
}

    1.10字符缓冲流复制Java文件【应用】

    • 案例需求

      把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java

    • 实现步骤

      • 根据数据源创建字符缓冲输入流对象

      • 根据目的地创建字符缓冲输出流对象

      • 读写数据，复制文件，使用字符缓冲流特有功能实现

      • 释放资源

    • 代码实现

      public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
​
        //读写数据，复制文件
        //一次读写一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1) {
//            bw.write(ch);
//        }
​
        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }
​
        //释放资源
        bw.close();
        br.close();
    }
}

    1.11字符缓冲流特有功能【应用】

    • 方法介绍

      BufferedWriter：

      方法名说明
      void newLine()写一行行分隔符，行分隔符字符串由系统属性定义

      BufferedReader:

      方法名说明
      String readLine()读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

    • 代码演示

      public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
​
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));
​
        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();//刷新数据
        }
​
        //释放资源
        bw.close();
​
        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));
​
        String line;
        while ((line=br.readLine())!=null) {
            System.out.println(line);
        }
​
        br.close();
    }
}

    1.12字符缓冲流特有功能复制Java文件【***应用】

    • 案例需求

      使用特有功能把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java

    • 实现步骤

      • 根据数据源创建字符缓冲输入流对象

      • 根据目的地创建字符缓冲输出流对象

      • 读写数据，复制文件，使用字符缓冲流特有功能实现

      • 释放资源

    • 代码实现

      public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));

        //读写数据，复制文件
        //使用字符缓冲流特有功能实现
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();
    }
}

    1.13IO流小结【理解】

    • 字节流

    •  

    • 字符流

    2练习案例

    2.1集合到文件【应用】

    • 案例需求

      把文本文件中的数据读取到集合中，并遍历集合。要求：文件中每一行数据是一个集合元素

    • 实现步骤

      • 创建字符缓冲输入流对象

      • 创建ArrayList集合对象

      • 调用字符缓冲输入流对象的方法读数据

      • 把读取到的字符串数据存储到集合中

      • 释放资源

      • 遍历集合

    • 代码实现

    1. package com.B.IOStream_14.CharDemo03;
    2.  
    3. import java.io.BufferedWriter;
    4. import java.io.FileWriter;
    5. import java.io.IOException;
    6. import java.util.ArrayList;
    7. //集合到文件
    8. public class ArrayListToTxt01 {
    9.     public static void main(String[] args) throws IOException {
    10.                 //创建ArrayList集合
    11.                 ArrayList array = new ArrayList();
    12.  
    13.                 //往集合中存储字符串元素
    14.                 array.add("hello");
    15.                 array.add("world");
    16.                 array.add("java");
    17.  
    18.                 //创建字符缓冲输出流对象
    19.                 BufferedWriter bw = new BufferedWriter(new FileWriter("Temp\\array.txt"));
    20.  
    21.                 //遍历集合，得到每一个字符串数据
    22.                 for(String s : array) {
    23.                     //调用字符缓冲输出流对象的方法写数据
    24.                     bw.write(s);
    25.                     bw.newLine();
    26.                     bw.flush();
    27.                 }
    28.  
    29.                 //释放资源
    30.                 bw.close();
    31.             }
    32.         }
    33.  
    34.  
    35.  
     

    2.2文件到集合【应用】
     

    •  
      案例需求
       
      把ArrayList集合中的字符串数据写入到文本文件。要求：每一个字符串元素作为文件中的一行数据
       
    •  
      实现步骤
       
  
      •  
        创建ArrayList集合
         
      •  
        往集合中存储字符串元素
         
      •  
        创建字符缓冲输出流对象
         
      •  
        遍历集合，得到每一个字符串数据
         
      •  
        调用字符缓冲输出流对象的方法写数据
         
      •  
        释放资源
         
    •  
      代码实现
       
      1. package com.B.IOStream_14.CharDemo03;
      2.  
      3. import java.io.BufferedReader;
      4. import java.io.FileReader;
      5. import java.io.IOException;
      6. import java.util.ArrayList;
      7. //文件到集合
      8. public class TxtToArrayList01 {
      9.     public static void main(String[] args) throws IOException {
      10.         //创建字符缓冲输入流对象
      11.         BufferedReader br = new BufferedReader(new FileReader("Temp\\array.txt"));
      12.  
      13.         //创建ArrayList集合对象
      14.         ArrayList array = new ArrayList();
      15.  
      16.         //调用字符缓冲输入流对象的方法读数据
      17.         String line;
      18.         while ((line=br.readLine())!=null) {
      19.             //把读取到的字符串数据存储到集合中
      20.             array.add(line);
      21.         }
      22.         //释放资源
      23.         br.close();
      24.         //遍历集合
      25.         for(String s : array) {
      26.             System.out.println(s);
      27.         }
      28.  
      29.     }
      30. }
       
       
       
    

    2.3点名器【应用】
     

    •  
      案例需求
       
      我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随点名器
       
    •  
      实现步骤
       
  
      •  
        创建字符缓冲输入流对象
         
      •  
        创建ArrayList集合对象
         
      •  
        调用字符缓冲输入流对象的方法读数据
         
      •  
        把读取到的字符串数据存储到集合中
         
      •  
        释放资源
         
      •  
        使用Random产生一个随机数，随机数的范围在：[0,集合的长度)
         
      •  
        把第6步产生的随机数作为索引到ArrayList集合中获取值
         
      •  
        把第7步得到的数据输出在控制台
         
    •  
      代码实现
       
      public class CallNameDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\names.txt"));

        //创建ArrayList集合对象
        ArrayList array = new ArrayList();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line=br.readLine())!=null) {
            //把读取到的字符串数据存储到集合中
            array.add(line);
        }

        //释放资源
        br.close();

        //使用Random产生一个随机数，随机数的范围在：[0,集合的长度)
        Random r = new Random();
        int index = r.nextInt(array.size());

        //把第6步产生的随机数作为索引到ArrayList集合中获取值
        String name = array.get(index);

        //把第7步得到的数据输出在控制台
        System.out.println("幸运者是：" + name);
    }
}
       
    

     

    2.4集合到文件改进版【应用】
     

    •  
      案例需求
       
      把ArrayList集合中的学生数据写入到文本文件。要求：每一个学生对象的数据作为文件中的一行数据 ​ 格式：学号,姓名,年龄,居住地 举例：itheima001,林青霞,30,西安
       
    •  
      实现步骤
       
  
      •  
        定义学生类
         
      •  
        创建ArrayList集合
         
      •  
        创建学生对象
         
      •  
        把学生对象添加到集合中
         
      •  
        创建字符缓冲输出流对象
         
      •  
        遍历集合，得到每一个学生对象
         
      •  
        把学生对象的数据拼接成指定格式的字符串
         
      •  
        调用字符缓冲输出流对象的方法写数据
         
      •  
        释放资源
         
    •  
      代码实现
       
  
      •  
        学生类
         
        public class Student {
    private String sid;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}
         
      •  
        测试类
         
        public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList array = new ArrayList();

        //创建学生对象
        Student s1 = new Student("itheima001", "林青霞", 30, "西安");
        Student s2 = new Student("itheima002", "张曼玉", 35, "武汉");
        Student s3 = new Student("itheima003", "王祖贤", 33, "郑州");

        //把学生对象添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\students.txt"));

        //遍历集合，得到每一个学生对象
        for (Student s : array) {
            //把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());

            //调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}
         
       
    

    2.5文件到集合改进版【应用】
     

    •  
      案例需求
       
      把文本文件中的数据读取到集合中，并遍历集合。要求：文件中每一行数据是一个学生对象的成员变量值 举例：itheima001,林青霞,30,西安
       
    •  
      实现步骤
       
  
      •  
        定义学生类
         
      •  
        创建字符缓冲输入流对象
         
      •  
        创建ArrayList集合对象
         
      •  
        调用字符缓冲输入流对象的方法读数据
         
      •  
        把读取到的字符串数据用split()进行分割，得到一个字符串数组
         
      •  
        创建学生对象
         
      •  
        把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
         
      •  
        把学生对象添加到集合
         
      •  
        释放资源
         
      •  
        遍历集合
         
    •  
      代码实现
       
  
      •  
        学生类
         
        同上
         
      •  
        测试类
         
        public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\students.txt"));

        //创建ArrayList集合对象
        ArrayList array = new ArrayList();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
            //把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] strArray = line.split(",");

            //创建学生对象
            Student s = new Student();
            //把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            //itheima001,林青霞,30,西安
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));
            s.setAddress(strArray[3]);

            //把学生对象添加到集合
            array.add(s);
        }

        //释放资源
        br.close();

        //遍历集合
        for (Student s : array) {
            System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
        }
    }
}
         
       
    

    3.IO流案例
     

    3.1集合到文件数据排序改进版【应用】
     

    3.1.1案例需求
     

    •  
      键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件
       
    •  
      格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100
       
    

    3.1.2分析步骤
     

    1.  
      定义学生类
       
    2.  
      创建TreeSet集合，通过比较器排序进行排序
       
    3.  
      键盘录入学生数据
       
    4.  
      创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
       
    5.  
      把学生对象添加到TreeSet集合
       
    6.  
      创建字符缓冲输出流对象
       
    7.  
      遍历集合，得到每一个学生对象
       
    8.  
      把学生对象的数据拼接成指定格式的字符串
       
    9.  
      调用字符缓冲输出流对象的方法写数据
       
    10.  
      释放资源
       
    

    3.1.3代码实现
     

    •  
      学生类
       
      public class Student {
    // 姓名
    private String name;
    // 语文成绩
    private int chinese;
    // 数学成绩
    private int math;
    // 英语成绩
    private int english;

    public Student() {
        super();
    }

    public Student(String name, int chinese, int math, int english) {
        super();
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    public int getSum() {
        return this.chinese + this.math + this.english;
    }
}
       
    •  
      测试类
       
      public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合，通过比较器排序进行排序
        TreeSet ts = new TreeSet(new Comparator() {
            @Override
            public int compare(Student s1, Student s2) {
                //成绩总分从高到低
                int num = s2.getSum() - s1.getSum();
                //次要条件
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
                return num4;
            }
        });

        //键盘录入学生数据
        for (int i = 0; i < 5; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第" + (i + 1) + "个学生信息：");
            System.out.println("姓名：");
            String name = sc.nextLine();
            System.out.println("语文成绩：");
            int chinese = sc.nextInt();
            System.out.println("数学成绩：");
            int math = sc.nextInt();
            System.out.println("英语成绩：");
            int english = sc.nextInt();

            //创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);

            //把学生对象添加到TreeSet集合
            ts.add(s);
        }

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\ts.txt"));

        //遍历集合，得到每一个学生对象
        for (Student s : ts) {
            //把学生对象的数据拼接成指定格式的字符串
            //格式：姓名,语文成绩,数学成绩,英语成绩
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());

//            调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}
       
    

    1. 不知火,96,93,98,287
    2. 彼岸花,95,96,95,286
    3. 大天狗 ,98,86,98,282
    4. 紧那罗,96,87,86,269
    5. 妖狐,98,60,99,257
     

     

    3.2复制单级文件夹【应用】
     

    3.2.1案例需求
     

    •  
      把“E:\itcast”这个文件夹复制到模块目录下
       
    

    3.2.2分析步骤
     

    1.  
      创建数据源目录File对象，路径是E:\itcast
       
    2.  
      获取数据源目录File对象的名称
       
    3.  
      创建目的地目录File对象，路径由(模块名+第2步获取的名称)组成
       
    4.  
      判断第3步创建的File是否存在，如果不存在，就创建
       
    5.  
      获取数据源目录下所有文件的File数组
       
    6.  
      遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
       
    7.  
      获取数据源文件File对象的名称
       
    8.  
      创建目的地文件File对象，路径由(目的地目录+第7步获取的名称)组成
       
    9.  
      复制文件
       
      由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件
       
      采用参数为File的构造方法
       
    

    3.2.3代码实现
     

    public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源目录File对象，路径是E:\\itcast
        File srcFolder = new File("E:\\itcast");

        //获取数据源目录File对象的名称(itcast)
        String srcFolderName = srcFolder.getName();

        //创建目的地目录File对象，路径名是模块名+itcast组成(myCharStream\\itcast)
        File destFolder = new File("myCharStream",srcFolderName);

        //判断目的地目录对应的File是否存在，如果不存在，就创建
        if(!destFolder.exists()) {
            destFolder.mkdir();
        }

        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();

        //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for(File srcFile : listFiles) {
            //数据源文件：E:\\itcast\\mn.jpg
            //获取数据源文件File对象的名称(mn.jpg)
            String srcFileName = srcFile.getName();
            //创建目的地文件File对象，路径名是目的地目录+mn.jpg组成(myCharStream\\itcast\\mn.jpg)
            File destFile = new File(destFolder,srcFileName);
            //复制文件
            copyFile(srcFile,destFile);
        }
    }

    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
}
     

     

     

    3.3复制多级文件夹【应用】
     

    3.3.1案例需求
     

    •  
      把“E:\itcast”这个文件夹复制到 F盘目录下
       
    

    3.3.2分析步骤
     

    1.  
      创建数据源File对象，路径是E:\itcast
       
    2.  
      创建目的地File对象，路径是F:\
       
    3.  
      写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
       
    4.  
      判断数据源File是否是文件
       
      是文件：直接复制，用字节流
       
      不是文件：
       
      在目的地下创建该目录
       
      遍历获取该目录下的所有文件的File数组，得到每一个File对象
       
      回到3继续(递归)
       
    

    3.3.3代码实现
     

    public class CopyFoldersDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源File对象，路径是E:\\itcast
        File srcFile = new File("E:\\itcast");
        //创建目的地File对象，路径是F:\\
        File destFile = new File("F:\\");

        //写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
        copyFolder(srcFile,destFile);
    }

    //复制文件夹
    private static void copyFolder(File srcFile, File destFile) throws IOException {
        //判断数据源File是否是目录
        if(srcFile.isDirectory()) {
            //在目的地下创建和数据源File名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName); //F:\\itcast
            if(!newFolder.exists()) {
                newFolder.mkdir();
            }

            //获取数据源File下所有文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();

            //遍历该File数组，得到每一个File对象
            for(File file : fileArray) {
                //把该File作为数据源File对象，递归调用复制文件夹的方法
                copyFolder(file,newFolder);
            }
        } else {
            //说明是文件，直接复制，用字节流
            File newFile = new File(destFile,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }

    //字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}
     

    3.4复制文件的异常处理【应用】
     

    1.4.1基本做法
     

    public class CopyFileDemo {
    public static void main(String[] args) {

    }

    //try...catch...finally
    private static void method2() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("fr.txt");
            fw = new FileWriter("fw.txt");

            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw!=null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fr!=null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //抛出处理
    private static void method1() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");

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

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

    3.4.2JDK7版本改进
     

    public class CopyFileDemo {
    public static void main(String[] args) {

    }

    //JDK7的改进方案
    private static void method3() {
        try(FileReader fr = new FileReader("fr.txt");
            FileWriter fw = new FileWriter("fw.txt");){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
     

    3.4.3JDK9版本改进
     

    public class CopyFileDemo {
    public static void main(String[] args) {

    }

    //JDK9的改进方案
    private static void method4() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        try(fr;fw){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
     

    ##
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
Spring 源码阅读（二）IoC 容器初始化以及 BeanFactory 创建和 BeanDefinition 加载过程                            
    
Re-Ranking                            
    
HTML5+CSS3小实例：纯CSS实现彩虹倒映水面的唯美背景                            
    
Java 类型通配符下限以及案例说明(八)                            
    
2022中兴捧月算法挑战赛（RAW图像去噪）——初赛到决赛总结与反思                            
    
Python深度学习实践代码实现                            
    
vue.js毕业设计，基于vue.js前后端分离订座预约小程序系统 开题报告                            
    
【Graph Net学习】GNN/GCN代码实战                            
    
基于JavaFX的扫雷游戏实现（五）——设置和自定义控件                            
    
PAM从入门到精通（十三）                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/clover_oreo/article/details/125991103
                
    •