JAVA 字符流

 

为什么会出现字符流

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

  • 字符流 = 字节流 + 编码表

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

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

 

复制代码
 1 import java.io.FileInputStream;
 2 import java.io.IOException;
 3 import java.util.Arrays;
 4 
 5 /*
 6 需求：字节流读文本文件数据
 7 
 8     一个汉字的存储：
 9         如果是GBK编码，占用2个字节
10         如果是UTF-8编码，占用3个字节
11 
12 */
13 
14 public class FileInputStreamDemo3 {
15     public static void main(String[] args) throws IOException{
16 //        FileInputStream fis=new FileInputStream("..\\hello java\\a.txt");
17 //        
18 //        int by;
19 //        while((by=fis.read())!=-1) {
20 //            System.out.print((char)by);
21 //        }
22 //        
23 //        fis.close();
24         
25 //        String s="abc";//[97, 98, 99]
26         
27         String s="中国";//[-42, -48, -71, -6] 默认GBK编码
28 //        byte[] bys = s.getBytes();
29         
30 //        byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
31         byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]
32         System.out.println(Arrays.toString(bys));
33         
34         
35     }
36 }
复制代码

 

编码表

 

基础知识：

    • 计算机中存储的信息都是用二进制数表示的；我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果
    • 按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。这里强调一下：按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象。

字符编码：就是一套自然语言的字符与二进制数之间的对应规则（A，65）


字符集：

    • 是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
    • 计算机要准确的存储和识别个只能怪字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。

常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

 

ASCII字符集：

    • ASCII（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编码。它使用一至4个字节为每个字符编码

编码规则：
128个US-ASCII字符，只需一个字节编码
拉丁文等文字，需要二个字节编码
大部分常用字（含中文），使用三个字节编码
其他极少使用的Unicode辅助字符，使用四字节编码

 

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

字符串中的编码解码

编码：

    • byte[] getBytes()：使用平台的默认字符集将该String编码为以一系列字节，将结果存储到新的字节数组中
    • byte[] getBytes(String charsetName)：使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中

解码：

    • String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
    • String(byte[] bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String

 

复制代码
 1 import java.io.UnsupportedEncodingException;
 2 import java.util.Arrays;
 3 
 4 /*
 5 编码：
 6 
 7 - byte[] getBytes()：使用平台的默认字符集将该String编码为以一系列字节，将结果存储到新的字节数组中
 8 - byte[] getBytes(String charsetName)：使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
 9 
10 解码：
11 
12 - String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
13 - String(byte[] bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String
14 
15 */
16 public class StringDemo {
17     public static void main(String[] args) throws UnsupportedEncodingException {
18         //定义一个字符串
19         String s="中国";
20         //编码：
21         //byte[] getBytes()：使用平台的默认字符集将该String编码为以一系列字节，将结果存储到新的字节数组中
22         byte[] bys = s.getBytes();//[-42, -48, -71, -6]
23         
24         //byte[] getBytes(String charsetName)：使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
25 //        byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
26 //        byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]
27         System.out.println(Arrays.toString(bys));
28         
29         //解码：
30         //String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
31 //        String ss=new String(bys);//中国
32         //String(byte[] bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String
33 //        String ss=new String(bys,"UTF-8");//?й?
34         String ss=new String(bys,"GBK");//中国
35         System.out.println(ss);
36     }
37 }
复制代码

 

字符流中的编码解码

 

字符流抽象基类：

    • Reader：字符输入流的抽象类
    • Writer：字符输出流的抽象类

字符流中和编码解码的两个类：

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

它读取字节，并使用指定的编码将其解码为字符
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接收平台的默认字符集

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

是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接收平台的默认字符集

复制代码
 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;
 6 
 7 /*
 8 - InputStreamReader：是从字节流到字符流的桥梁
 9     它读取字节，并使用指定的编码将其解码为字符
10     它使用的字符集可以由名称指定，也可以被明确指定，或者可以接收平台的默认字符集
11 
12 - OutputStreamWriter：是从字符流到字节流的桥梁
13     是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
14     它使用的字符集可以由名称指定，也可以被明确指定，或者可以接收平台的默认字符集
15 */
16 public class ConversionStreamDemo {
17     public static void main(String[] args) throws IOException{
18         //OutputStreamWriter(OutputStream out)创建一个使用默认字符编码的OutputStreamWriter
19         //OutputStreamWriter(OutputStream out,String charsetName)创建一个使用命名字符集的OutputStreamWriter
20         
21 //        FileOutputStream fos=new FileOutputStream("..\\hello java\\osw.txt");
22 //        OutputStreamWriter osw=new OutputStreamWriter(fos);
23         //两步合并
24 //        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt"));
25 //        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt"),"GBK");//中国
26         OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt"),"UTF-8");//涓浗
27         osw.write("中国");
28         osw.close();
29         
30         //InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
31         //InputStreamReader(InputStream in,String charsetName)创建一个使用命名字符集的InputStreamReader
32         
33 //        InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"));//涓浗
34 //        InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"),"GBK");//涓浗
35         InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"),"UTF-8");//中国
36         //一次读取一个字符数据
37         int ch;
38         while((ch=isr.read())!=-1) {
39             System.out.print((char)ch);
40         }
41         
42         isr.close();
43         
44     }
45 }
复制代码

 

字符流写数据的5种方式

 

 

 

 

复制代码
 1 import java.io.FileOutputStream;
 2 import java.io.IOException;
 3 import java.io.OutputStreamWriter;
 4 
 5 /*
 6 构造方法：
 7     OutputStreamWriter(OutputStream out)创建一个使用默认字符编码的OutputStreamWriter
 8     
 9     字符流写数据的5种方式**
10 
11     void write(int c)   写一个字符
12     void write(char[] cbuf)写入一个字符数组
13     void write(char[] cbuf,int off,int len)写入字符数组的一部分
14     void write(String str)写一个字符串
15     void write(String str,int off,int len)写一个字符串的一部分
16 */
17 
18 public class OutputStreamWriterDemo {
19     public static void main(String[] args) throws IOException {
20         //        OutputStreamWriter(OutputStream out)创建一个使用默认字符编码的OutputStreamWriter
21         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt"));
22         /*
23         //void write(int c)   写一个字符
24         osw.write(97);//不刷新数据进不来，因为真正底层写数据是字节流，而字符流相对于字节流是有缓冲的
25         //void flush()刷新流
26         osw.flush();
27         osw.write(98);
28         osw.flush();
29         osw.write(99);*/
30 
31         //void write(char[] cbuf)写入一个字符数组
32         char[] chs = { 'a', 'b', 'c', 'd', 'e' };
33         //osw.write(chs);//abcde
34 
35         //void write(char[] cbuf,int off,int len)写入字符数组的一部分
36         //osw.write(chs,0,chs.length);//abcde
37         //osw.write(chs,1,3);//bcd
38 
39         //void write(String str)写一个字符串
40         //osw.write("abcde");//abcde
41 
42         //void write(String str,int off,int len)写一个字符串的一部分
43         //osw.write("abcde",0,"abcde".length());//abcde
44         osw.write("abcde", 1, 3);//bcd
45 
46         osw.close();//关闭流，先刷新
47         //osw.write(100);//java.io.IOException: Stream closed
48 
49     }
50 }
复制代码

 

字符流读数据的2种方式

 

 

 

 

复制代码
 1 import java.io.FileInputStream;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 
 5 /*
 6 构造方法：
 7     InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
 8     
 9 字符流读数据的2种方式**
10     int read()  一次读一个字符数据
11     int read(char[] cbuf)一次读一个字符数组数据
12 
13 */
14 public class InputStreamReaderDemo {
15     public static void main(String[] args) throws IOException{
16         //InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
17 //        InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"));
18         InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\ConversionStreamDemo.java"));
19         
20         
21         //int read()  一次读一个字符数据
22 //        int ch;
23 //        while((ch=isr.read())!=-1) {
24 //            System.out.print((char)ch);
25 //        }
26         /*运行结果：
27         hello
28         world
29         java*/
30         
31         //int read(char[] cbuf)一次读一个字符数组数据
32         char[] chs=new char[1024];
33         int len;
34         while((len=isr.read(chs))!=-1) {
35             System.out.print(new String(chs,0,len));
36         }
37         /*运行结果：
38         hello
39         world
40         java*/
41         
42         //释放资源
43         isr.close();
44         
45     }
46 }
复制代码

 

案例：复制Java文件

需求：把模块目录下的“ConversionSteamDemo.java”复制到模块目录下的“Copy.java”

思路：

  1. 根据数据源创建字符输入流对象
  2. 根据目的地创建字符输出流对象
  3. 读写数据，复制文件
  4. 释放资源

 

复制代码
 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;
 6 
 7 /*
 8 案例：复制Java文件
 9 需求：把模块目录下的“ConversionSteamDemo.java”复制到模块目录下的“Copy.java”
10 
11 思路：
12 
13  1. 根据数据源创建字输入流对象
14  2. 根据目的地创建字符输出流对象
15  3. 读写数据，复制文件
16  4. 释放资源
17 */
18 
19 public class CopyJavaDemo {
20     public static void main(String[] args) throws IOException {
21         //1. 根据数据源创建字输入流对象
22         InputStreamReader isr = new InputStreamReader(new FileInputStream("..\\hello java\\ConversionStreamDemo.java"));
23         //2. 根据目的地创建字符输出流对象
24         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("..\\hello java\\Copy.java"));
25         //3. 读写数据，复制文件
26         //一次读写一个字符数据
27         //int ch;
28         //while((ch=isr.read())!=-1) {
29         //    osw.write(ch);
30         //}
31 
32         //一次读写一个字符数组数据
33         char[] chs = new char[1024];
34         int len;
35         while ((len = isr.read(chs)) != -1) {
36             osw.write(chs, 0, len);
37         }
38 
39         //释放资源
40         isr.close();
41         osw.close();
42 
43     }
44 }
复制代码

 

复制Java文件（改进版）

 

转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类

  • FileReader：用于读取字符文件的便捷类

FileReader(String fileName)

  • FileWriter：用于写入字符文件的便捷类

FileWriter(String fileName)

 

数据源和目的地的分析

数据源：…\hello java\ConversionStreamDemo.java—读数据—Reader—InputStreamReader—FileReader

目的地：…\hello java\Copy.java–写数据–Writer–OutputStreamWriter—FileWriter

 

复制代码
 1 import java.io.FileReader;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 
 5 /*
 6 案例：复制Java文件（改进版）
 7 
 8 需求：把模块目录下的“ConversionSteamDemo.java”复制到模块目录下的“Copy.java”
 9 
10 分析：
11 
12  1. 转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类
13  2. FileReader：用于读取字符文件的便捷类
14     FileReader(String fileName)
15  3. FileWriter：用于写入字符文件的便捷类
16     FileWriter(String fileName)
17  4. 数据源和目的地的分析
18     数据源：---读数据---Reader---InputStreamReader---FileReader
19     目的地：..\\hello java\\Copy.java--写数据--Writer--OutputStreamWriter---FileWriter
20 
21 思路：
22 
23 1. 根据数据源创建字输入流对象
24 2. 根据目的地创建字符输出流对象
25 3. 读写数据，复制文件
26 4. 释放资源
27 
28 */
29 public class CopyJavaDemo2 {
30     public static void main(String[] args) throws IOException {
31         //1. 根据数据源创建字输入流对象
32         FileReader fr = new FileReader("..\\hello java\\ConversionStreamDemo.java");
33 
34         //2. 根据目的地创建字符输出流对象
35         FileWriter fw = new FileWriter("..\\hello java\\Copy.java");
36 
37         //3. 读写数据，复制文件
38         //一次读写一个字符数据
39         //int ch;
40         //while((ch=fr.read())!=-1) {
41         //    fw.write(ch);
42         //}
43 
44         //一次读写一个字符数组数据
45         char[] chs = new char[1024];
46         int len;
47         while ((len = fr.read(chs)) != -1) {
48             fw.write(chs, 0, len);
49         }
50 
51         //4. 释放资源
52         fr.close();
53         fw.close();
54 
55     }
56 }
复制代码

 

字符缓冲流

字符缓冲流：

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

构造方法：

    • BufferedWriter(Writer out)
    • BufferedReader(Reader in)

 

复制代码
 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 
 7 /*
 8 字符缓冲流：
 9 
10 - BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接收默认大小。默认值足够大，可用于大多数用途
11 - BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途
12 
13 构造方法：
14 
15 - BufferedWriter(Writer out)
16 - BufferedReader(Reader in)
17 */
18 
19 public class BufferedStreamDemo2 {
20     public static void main(String[] args) throws IOException {
21         //BufferedWriter(Writer out)
22         //        FileWriter fw=new FileWriter("..\\hello java\\bw.txt");
23         //        BufferedWriter bw=new BufferedWriter(fw);
24         /*
25         //可合并为一句
26         BufferedWriter bw=new BufferedWriter(new FileWriter("..\\hello java\\bw.txt"));
27         
28         bw.write("hello\r\n");
29         bw.write("world\r\n");
30         
31         bw.close();*/
32 
33         //BufferedReader(Reader in)
34         BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\bw.txt"));
35         /*
36         //一次读一个字符数据
37         int ch;
38         while((ch=br.read())!=-1) {
39             System.out.print((char)ch);
40         }*/
41 
42         //一次读一个字符数组数据
43         char[] chs = new char[1024];
44         int len;
45         while ((len = br.read(chs)) != -1) {
46             System.out.print(new String(chs, 0, len));
47         }
48 
49         br.close();
50 
51     }
52 }
复制代码

 

复制Java文件（字符缓冲流改进版）

 

复制代码
 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 
 7 /*
 8 案例：复制Java文件（字符缓冲流改进版）
 9 
10 需求：把模块目录下的“ConversionStreamDemo.java”复制到模块目录下的“Copy.java”
11 
12 思路：
13     1. 根据数据源创建字符缓冲输入流对象
14     2. 根据目的地创建字符缓冲输出流对象
15     3. 读写数据，复制文件
16     4. 释放资源
17 */
18 
19 public class CopyJavaDemo3 {
20     public static void main(String[] args) throws IOException {
21         //1. 根据数据源创建字符缓冲输入流对象
22         BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\ConversionStreamDemo.java"));
23 
24         //2. 根据目的地创建字符缓冲输出流对象
25         BufferedWriter bw = new BufferedWriter(new FileWriter("..\\hello java\\Copy.java"));
26 
27         //3. 读写数据，复制文件
28         /*
29         //一次读写一个字符数据
30         int ch;
31         while((ch=br.read())!=-1) {
32             bw.write(ch);
33         }*/
34 
35         //一次读写一个字符数组数据
36         char[] chs = new char[1024];
37         int len;
38         while ((len = br.read(chs)) != -1) {
39             bw.write(chs, 0, len);
40         }
41 
42         //4. 释放资源
43         br.close();
44         bw.close();
45 
46     }
47 }
复制代码

 

字符缓冲流的特有功能

  • BufferedWrite：

void newLine()：写行分隔符，行分隔符字符串有系统属性定义

  • BufferedReader：

public String readLine()：读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到大，则为null

 

复制代码
 1 /*
 2 字符缓冲流的特有功能
 3 
 4 BufferedWrite：
 5     void newLine()：写一行行分隔符，行分隔符字符串有系统属性定义
 6 
 7 BufferedReader：
 8     public String readLine()：读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到大，则为null
 9 
10 */
11 
12 import java.io.BufferedReader;
13 import java.io.BufferedWriter;
14 import java.io.FileReader;
15 import java.io.FileWriter;
16 import java.io.IOException;
17 
18 public class BufferedStreamDemo3 {
19     public static void main(String[] args) throws IOException {
20         /*//创建字符缓冲输出流
21         BufferedWriter bw=new BufferedWriter(new FileWriter("..\\hello java\\bw.txt"));
22         
23         //写数据
24         for(int i=0;i<10;i++) {
25             bw.write("hello"+i);
26         //            bw.write("\r\n");//只适用于Windows
27             bw.newLine();
28             bw.flush();
29         } 
30             hello0
31             hello1
32             hello2
33             hello3
34             hello4
35             hello5
36             hello6
37             hello7
38             hello8
39             hello9
40         
41         //释放资源
42         bw.close();
43         */
44 
45         //创建字符缓冲输入流
46         BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\bw.txt"));
47 
48         //public String readLine()：读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到大，则为null
49         /*//第一次读取数据
50         String line = br.readLine();
51         System.out.println(line);//hello0
52         //第二次读取数据
53         line = br.readLine();
54         System.out.println(line);//hello1
55         //再多读两次
56         line = br.readLine();
57         System.out.println(line);//null
58         line = br.readLine();
59         System.out.println(line);//null
60         */
61 
62         String line;
63         while ((line = br.readLine()) != null) {
64             System.out.println(line);//readline只读内容，不包含换行符，要加ln
65         }
66 
67         //释放资源
68         br.close();
69 
70     }
71 }
复制代码

 

复制Java文件（字符缓冲流特有功能改进版）

 

复制代码
 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 
 7 /*
 8 案例：复制Java文件（字符缓冲流特有功能改进版）
 9 
10 需求：把模块目录下的“ConversionSteamDemo.java”复制到模块目录下的“Copy.java”
11 
12 思路：
13 
14  1. 根据数据源创建字符缓冲输入流对象
15  2. 根据目的地创建字符缓冲输出流对象
16  3. 读写数据，复制文件
17          使用字符缓冲流特有功能实现
18  4. 释放资源
19 */
20 public class CopyJavaDemo4 {
21     public static void main(String[] args) throws IOException {
22         //1. 根据数据源创建字符缓冲输入流对象
23         BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\ConversionStreamDemo.java"));
24 
25         //2. 根据目的地创建字符缓冲输出流对象
26         BufferedWriter bw = new BufferedWriter(new FileWriter("..\\hello java\\Copy.java"));
27 
28         //3. 读写数据，复制文件(使用字符缓冲流特有功能实现)
29         String line;
30         while ((line = br.readLine()) != null) {
31             bw.write(line);
32             bw.newLine();//要加换行
33             bw.flush();
34         }
35 
36         //4. 释放资源
37         br.close();
38         bw.close();
39 
40     }
41 }
复制代码

 

IO流小结

 

 

 

 

 

 

复制文件的异常处理

 

try…catch…finally的做法：

1 try{
2     可能出现异常的代码;
3     }catch(异常类名 变量名){
4         异常的处理代码;
5     }finally{
6         执行所有清除操作;
7     }

 

JDK7改进方案：

1 try(定义流对象){
2     可能出现异常的代码;
3 }catch(异常类名 变量名){
4     异常的处理代码;
5 }
6 
7 自动释放资源

 

JDK9的改进方案：

 

复制代码
1 定义输入流对象;
2 定义输出流对象;
3 try(输入流对象;输出流对象){
4     可能出现异常的代码;
5 }catch(异常类名 变量名){
6     异常的处理代码;
7 }
8 
9 自动释放资源
复制代码

 

复制代码
 1 import java.io.FileReader;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 
 5 /*
 6 复制文件加入异常处理
 7 */
 8 public class CopyFileDemo {
 9     public static void main(String[] args) {
10 
11     }
12 
13     //JDK9的改进方案
14     private static void method4() throws IOException {
15         FileReader fr = new FileReader("fr.txt");
16         FileWriter fw = new FileWriter("fw.txt");
17         try (fr; fw) {
18 
19             char[] chs = new char[1024];
20             int len;
21             while ((len = fr.read()) != -1) {
22                 fw.write(chs, 0, len);
23             }
24         } catch (IOException e) {
25             e.printStackTrace();
26         }
27 
28     }
29 
30     //JDK7的改进方案
31     private static void method3() {
32         try (FileReader fr = new FileReader("fr.txt"); FileWriter fw = new FileWriter("fw.txt");) {
33 
34             char[] chs = new char[1024];
35             int len;
36             while ((len = fr.read()) != -1) {
37                 fw.write(chs, 0, len);
38             }
39         } catch (IOException e) {
40             e.printStackTrace();
41         }
42 
43     }
44 
45     //try...catch...finally
46     private static void method2() {
47         FileReader fr = null;//放外面定义，并给初始化
48         FileWriter fw = null;
49         try {
50             fr = new FileReader("fr.txt");
51             fw = new FileWriter("fw.txt");
52 
53             char[] chs = new char[1024];
54             int len;
55             while ((len = fr.read()) != -1) {
56                 fw.write(chs, 0, len);
57             }
58 
59         } catch (IOException e) {
60             e.printStackTrace();
61         } finally {//close出现问题,先判断不为空，再用try...catch处理
62             if (fw != null) {
63 
64                 try {
65                     fw.close();
66                 } catch (IOException e) {
67                     // TODO Auto-generated catch block
68                     e.printStackTrace();
69                 }
70             }
71             //同理
72             if (fr != null) {
73                 try {
74                     fr.close();
75                 } catch (IOException e) {
76                     // TODO Auto-generated catch block
77                     e.printStackTrace();
78                 }
79             }
80 
81         }
82     }
83 
84     //抛出异常
85     private static void method1() throws IOException {
86         FileReader fr = new FileReader("fr.txt");
87         FileWriter fw = new FileWriter("fw.txt");
88 
89         char[] chs = new char[1024];
90         int len;
91         while ((len = fr.read()) != -1) {
92             fw.write(chs, 0, len);
93         }
94 
95         fr.close();
96         fw.close();
97     }
98 
99 }
复制代码

 

posted @   忱康  阅读(66)  评论(0)  编辑  收藏  举报
相关博文：
· JAVA 字节流
· JAVA 特殊操作流 对象序列化 Properties
· JavaIO流之字符流与字符缓冲流
· IO流(二)之字符流、缓冲流、转换流、打印流，数据流，序列化流，File和IO工具包
· java-IO流之字符流
阅读排行：
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
点击右上角即可分享
微信分享提示