Java笔记(21)：IO流(03)

1、String类中的编码和解码问题

 1 package cn.itcast_01;
 2 
 3 import java.io.UnsupportedEncodingException;
 4 import java.util.Arrays;
 5 
 6 /*
 7  * String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
 8  * byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
 9  * 
10  * 编码:把看得懂的变成看不懂的
11  * String -- byte[]
12  * 
13  * 解码:把看不懂的变成看得懂的
14  * byte[] -- String
15  * 
16  * 举例：谍战片(发电报，接电报)
17  * 
18  * 码表：小本子
19  *         字符    数值
20  * 
21  * 要发送一段文字：
22  *         今天晚上在老地方见
23  * 
24  *         发送端：今 -- 数值 -- 二进制 -- 发出去
25  *         接收端：接收 -- 二进制 -- 十进制 -- 数值 -- 字符 -- 今
26  * 
27  *         今天晚上在老地方见
28  * 
29  * 编码问题简单，只要编码解码的格式是一致的。
30  */
31 public class StringDemo {
32     public static void main(String[] args) throws UnsupportedEncodingException {
33         String s = "你好";
34 
35         // String -- byte[]
36         byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
37         // byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
38         // byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
39         System.out.println(Arrays.toString(bys));
40 
41         // byte[] -- String
42         String ss = new String(bys); // 你好
43         // String ss = new String(bys, "GBK"); // 你好
44         // String ss = new String(bys, "UTF-8"); // ???
45         System.out.println(ss);
46     }
47 }

2、转换流OutputStreamWriter的使用

 1 package cn.itcast_02;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.OutputStreamWriter;
 6 
 7 /*
 8  * OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
 9  * OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
10  * 把字节流转换为字符流。
11  * 字符流 = 字节流 +编码表。
12  */
13 public class OutputStreamWriterDemo {
14     public static void main(String[] args) throws IOException {
15         // 创建对象
16         // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
17         // "osw.txt")); // 默认GBK
18         // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
19         // "osw.txt"), "GBK"); // 指定GBK
20         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
21                 "osw.txt"), "UTF-8"); // 指定UTF-8
22         // 写数据
23         osw.write("中国");
24 
25         // 释放资源
26         osw.close();
27     }
28 }

3、转换流InputStreamReader的使用

 1 package cn.itcast_02;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 
 7 /*
 8  * InputStreamReader(InputStream is):用默认的编码读取数据
 9  * InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
10  */
11 public class InputStreamReaderDemo {
12     public static void main(String[] args) throws IOException {
13         // 创建对象
14         // InputStreamReader isr = new InputStreamReader(new FileInputStream(
15         // "osw.txt"));
16 
17         // InputStreamReader isr = new InputStreamReader(new FileInputStream(
18         // "osw.txt"), "GBK");
19 
20         InputStreamReader isr = new InputStreamReader(new FileInputStream(
21                 "osw.txt"), "UTF-8");
22 
23         // 读取数据
24         // 一次读取一个字符
25         int ch = 0;
26         while ((ch = isr.read()) != -1) {
27             System.out.print((char) ch);
28         }
29 
30         // 释放资源
31         isr.close();
32     }
33 }

4、字符流的5种写数据的方式

 1 package cn.itcast_03;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.OutputStreamWriter;
 6 
 7 /*
 8  * OutputStreamWriter的方法：
 9  * public void write(int c):写一个字符
10  * public void write(char[] cbuf):写一个字符数组
11  * public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
12  * public void write(String str):写一个字符串
13  * public void write(String str,int off,int len):写一个字符串的一部分
14  * 
15  * 面试题：close()和flush()的区别?
16  * A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
17  * B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。
18  */
19 public class OutputStreamWriterDemo {
20     public static void main(String[] args) throws IOException {
21         // 创建对象
22         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
23                 "osw2.txt"));
24 
25         // 写数据
26         // public void write(int c):写一个字符
27         // osw.write('a');
28         // osw.write(97);
29         // 为什么数据没有进去呢?
30         // 原因是：字符 = 2字节
31         // 文件中数据存储的基本单位是字节。
32         // void flush()
33 
34         // public void write(char[] cbuf):写一个字符数组
35         // char[] chs = {'a','b','c','d','e'};
36         // osw.write(chs);
37 
38         // public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
39         // osw.write(chs,1,3);
40 
41         // public void write(String str):写一个字符串
42         // osw.write("我爱烨儿");
43 
44         // public void write(String str,int off,int len):写一个字符串的一部分
45         osw.write("我爱烨儿", 2, 2);
46 
47         // 刷新缓冲区
48         osw.flush();
49         // osw.write("我爱烨儿", 2, 3);
50 
51         // 释放资源
52         osw.close();
53         // java.io.IOException: Stream closed
54         // osw.write("我爱烨儿", 2, 3);
55     }
56 }

6、字符流的2种读数据的方式

 1 package cn.itcast_03;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 
 7 /*
 8  * InputStreamReader的方法：
 9  * int read():一次读取一个字符
10  * int read(char[] chs):一次读取一个字符数组
11  */
12 public class InputStreamReaderDemo {
13     public static void main(String[] args) throws IOException {
14         // 创建对象
15         InputStreamReader isr = new InputStreamReader(new FileInputStream(
16                 "StringDemo.java"));
17 
18         // 一次读取一个字符
19         // int ch = 0;
20         // while ((ch = isr.read()) != -1) {
21         // System.out.print((char) ch);
22         // }
23 
24         // 一次读取一个字符数组
25         char[] chs = new char[1024];
26         int len = 0;
27         while ((len = isr.read(chs)) != -1) {
28             System.out.print(new String(chs, 0, len));
29         }
30 
31         // 释放资源
32         isr.close();
33     }
34 }

练习：字符流复制文本文件案例1

 1 package cn.itcast_04;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 
 9 /*
10  * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
11  * 
12  * 数据源：
13  *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
14  * 目的地：
15  *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter
16  */
17 public class CopyFileDemo {
18     public static void main(String[] args) throws IOException {
19         // 封装数据源
20         InputStreamReader isr = new InputStreamReader(new FileInputStream(
21                 "a.txt"));
22         // 封装目的地
23         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
24                 "b.txt"));
25 
26         // 读写数据
27         // 方式1
28         // int ch = 0;
29         // while ((ch = isr.read()) != -1) {
30         // osw.write(ch);
31         // }
32 
33         // 方式2
34         char[] chs = new char[1024];
35         int len = 0;
36         while ((len = isr.read(chs)) != -1) {
37             osw.write(chs, 0, len);
38             // osw.flush();
39         }
40 
41         // 释放资源
42         osw.close();
43         isr.close();
44     }
45 }

练习：字符流复制文本文件案例2

 1 package cn.itcast_04;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。
 9  * 而转换流的名称有点长，所以，Java就提供了其子类供我们使用。
10  * OutputStreamWriter = FileOutputStream + 编码表(GBK)
11  * FileWriter = FileOutputStream + 编码表(GBK)
12  * 
13  * InputStreamReader = FileInputStream + 编码表(GBK)
14  * FileReader = FileInputStream + 编码表(GBK)
15  * 
16  /*
17  * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
18  * 
19  * 数据源：
20  *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader
21  * 目的地：
22  *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter
23  */
24 public class CopyFileDemo2 {
25     public static void main(String[] args) throws IOException {
26         // 封装数据源
27         FileReader fr = new FileReader("a.txt");
28         // 封装目的地
29         FileWriter fw = new FileWriter("b.txt");
30 
31         // 一次一个字符
32         // int ch = 0;
33         // while ((ch = fr.read()) != -1) {
34         // fw.write(ch);
35         // }
36 
37         // 一次一个字符数组
38         char[] chs = new char[1024];
39         int len = 0;
40         while ((len = fr.read(chs)) != -1) {
41             fw.write(chs, 0, len);
42             fw.flush();
43         }
44 
45         // 释放资源
46         fw.close();
47         fr.close();
48     }
49 }

练习：字符流复制文本文件案例3

 1 package cn.itcast_04;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 需求：把c:\\a.txt内容复制到d:\\b.txt中
 9  * 
10  * 数据源：
11  *         c:\\a.txt -- FileReader
12  * 目的地:
13  *         d:\\b.txt -- FileWriter
14  */
15 public class CopyFileDemo3 {
16     public static void main(String[] args) throws IOException {
17         // 封装数据源
18         FileReader fr = new FileReader("c:\\a.txt");
19         // 封装目的地
20         FileWriter fw = new FileWriter("d:\\b.txt");
21 
22         // 读写数据
23         // int ch = 0;
24         int ch;
25         while ((ch = fr.read()) != -1) {
26             fw.write(ch);
27         }
28         
29         //释放资源
30         fw.close();
31         fr.close();
32     }
33 }

7、字符缓冲输出流BufferedWriter的使用

 1 package cn.itcast_05;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 字符流为了高效读写，也提供了对应的字符缓冲流。
 9  * BufferedWriter:字符缓冲输出流
10  * BufferedReader:字符缓冲输入流
11  * 
12  * BufferedWriter:字符缓冲输出流
13  * 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 
14  * 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 
15  */
16 public class BufferedWriterDemo {
17     public static void main(String[] args) throws IOException {
18         // BufferedWriter(Writer out)
19         // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
20         // new FileOutputStream("bw.txt")));
21 
22         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
23 
24         bw.write("hello");
25         bw.write("world");
26         bw.write("java");
27         bw.flush();
28 
29         bw.close();
30     }
31 }

8、字符缓冲输入流BufferedReader的使用

 1 package cn.itcast_05;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 
 7 /*
 8  * BufferedReader
 9  * 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 
10  * 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 
11  * 
12  * BufferedReader(Reader in)
13  */
14 public class BufferedReaderDemo {
15     public static void main(String[] args) throws IOException {
16         // 创建字符缓冲输入流对象
17         BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
18 
19         // 方式1
20         // int ch = 0;
21         // while ((ch = br.read()) != -1) {
22         // System.out.print((char) ch);
23         // }
24 
25         // 方式2
26         char[] chs = new char[1024];
27         int len = 0;
28         while ((len = br.read(chs)) != -1) {
29             System.out.print(new String(chs, 0, len));
30         }
31 
32         // 释放资源
33         br.close();
34     }
35 }

练习：字符缓冲流复制文本文件案例1

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 
 9 /*
10  * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
11  * 
12  * 数据源：
13  *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
14  * 目的地：
15  *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
16  */
17 public class CopyFileDemo {
18     public static void main(String[] args) throws IOException {
19         // 封装数据源
20         BufferedReader br = new BufferedReader(new FileReader("a.txt"));
21         // 封装目的地
22         BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
23 
24         // 两种方式其中的一种一次读写一个字符数组
25         char[] chs = new char[1024];
26         int len = 0;
27         while ((len = br.read(chs)) != -1) {
28             bw.write(chs, 0, len);
29             bw.flush();
30         }
31 
32         // 释放资源字符缓冲流的特殊功能
33         bw.close();
34         br.close();
35     }
36 }

9、字符缓冲流的特殊功能

 1 package cn.itcast_05;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 
 9 /*
10  * 字符缓冲流的特殊方法：
11  * BufferedWriter:
12  *         public void newLine():根据系统来决定换行符
13  * BufferedReader:
14  *         public String readLine()：一次读取一行数据
15  *         包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
16  */
17 public class BufferedDemo {
18     public static void main(String[] args) throws IOException {
19         // write();
20         read();
21     }
22 
23     private static void read() throws IOException {
24         // 创建字符缓冲输入流对象
25         BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
26 
27         // public String readLine()：一次读取一行数据
28         // String line = br.readLine();
29         // System.out.println(line);
30         // line = br.readLine();
31         // System.out.println(line);
32 
33         // 最终版代码
34         String line = null;
35         while ((line = br.readLine()) != null) {
36             System.out.println(line);
37         }
38         
39         //释放资源
40         br.close();
41     }
42 
43     private static void write() throws IOException {
44         // 创建字符缓冲输出流对象
45         BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
46         for (int x = 0; x < 10; x++) {
47             bw.write("hello" + x);
48             // bw.write("\r\n");
49             bw.newLine();
50             bw.flush();
51         }
52         bw.close();
53     }
54 
55 }

练习：字符缓冲流复制文本文件案例2

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 
 9 /*
10  * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
11  * 
12  * 数据源：
13  *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
14  * 目的地：
15  *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
16  */
17 public class CopyFileDemo2 {
18     public static void main(String[] args) throws IOException {
19         // 封装数据源
20         BufferedReader br = new BufferedReader(new FileReader("a.txt"));
21         // 封装目的地
22         BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
23 
24         // 读写数据
25         String line = null;
26         while ((line = br.readLine()) != null) {
27             bw.write(line);
28             bw.newLine();
29             bw.flush();
30         }
31 
32         // 释放资源
33         bw.close();
34         br.close();
35     }
36 }

IO流图解：

练习：复制文本文件的5种方式案例

  1 package cn.itcast_01;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.BufferedWriter;
  5 import java.io.FileReader;
  6 import java.io.FileWriter;
  7 import java.io.IOException;
  8 
  9 /*
 10  * 复制文本文件
 11  * 
 12  * 分析：
 13  *         复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
 14  *         通过该原理，我们知道我们应该采用字符流更方便一些。
 15  *         而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。
 16  * 数据源：
 17  *         c:\\a.txt -- FileReader -- BufferdReader
 18  * 目的地：
 19  *         d:\\b.txt -- FileWriter -- BufferedWriter
 20  */
 21 public class CopyFileDemo {
 22     public static void main(String[] args) throws IOException {
 23         String srcString = "c:\\a.txt";
 24         String destString = "d:\\b.txt";
 25         // method1(srcString, destString);
 26         // method2(srcString, destString);
 27         // method3(srcString, destString);
 28         // method4(srcString, destString);
 29         method5(srcString, destString);
 30     }
 31 
 32     // 字符缓冲流一次读写一个字符串
 33     private static void method5(String srcString, String destString)
 34             throws IOException {
 35         BufferedReader br = new BufferedReader(new FileReader(srcString));
 36         BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
 37 
 38         String line = null;
 39         while ((line = br.readLine()) != null) {
 40             bw.write(line);
 41             bw.newLine();
 42             bw.flush();
 43         }
 44 
 45         bw.close();
 46         br.close();
 47     }
 48 
 49     // 字符缓冲流一次读写一个字符数组
 50     private static void method4(String srcString, String destString)
 51             throws IOException {
 52         BufferedReader br = new BufferedReader(new FileReader(srcString));
 53         BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
 54 
 55         char[] chs = new char[1024];
 56         int len = 0;
 57         while ((len = br.read(chs)) != -1) {
 58             bw.write(chs, 0, len);
 59         }
 60 
 61         bw.close();
 62         br.close();
 63     }
 64 
 65     // 字符缓冲流一次读写一个字符
 66     private static void method3(String srcString, String destString)
 67             throws IOException {
 68         BufferedReader br = new BufferedReader(new FileReader(srcString));
 69         BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
 70 
 71         int ch = 0;
 72         while ((ch = br.read()) != -1) {
 73             bw.write(ch);
 74         }
 75 
 76         bw.close();
 77         br.close();
 78     }
 79 
 80     // 基本字符流一次读写一个字符数组
 81     private static void method2(String srcString, String destString)
 82             throws IOException {
 83         FileReader fr = new FileReader(srcString);
 84         FileWriter fw = new FileWriter(destString);
 85 
 86         char[] chs = new char[1024];
 87         int len = 0;
 88         while ((len = fr.read(chs)) != -1) {
 89             fw.write(chs, 0, len);
 90         }
 91 
 92         fw.close();
 93         fr.close();
 94     }
 95 
 96     // 基本字符流一次读写一个字符
 97     private static void method1(String srcString, String destString)
 98             throws IOException {
 99         FileReader fr = new FileReader(srcString);
100         FileWriter fw = new FileWriter(destString);
101 
102         int ch = 0;
103         while ((ch = fr.read()) != -1) {
104             fw.write(ch);
105         }
106 
107         fw.close();
108         fr.close();
109     }
110 }

练习：复制图片的4种方式案例

 1 package cn.itcast_01;
 2 
 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;
 9 
10 /*
11  * 复制图片
12  * 
13  * 分析：
14  *         复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
15  *         通过该原理，我们知道我们应该采用字节流。
16  *         而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。
17  * 
18  * 数据源：
19  *         c:\\a.jpg -- FileInputStream -- BufferedInputStream
20  * 目的地：
21  *         d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
22  */
23 public class CopyImageDemo {
24     public static void main(String[] args) throws IOException {
25         // 使用字符串作为路径
26         // String srcString = "c:\\a.jpg";
27         // String destString = "d:\\b.jpg";
28         // 使用File对象做为参数
29         File srcFile = new File("c:\\a.jpg");
30         File destFile = new File("d:\\b.jpg");
31 
32         // method1(srcFile, destFile);
33         // method2(srcFile, destFile);
34         // method3(srcFile, destFile);
35         method4(srcFile, destFile);
36     }
37 
38     // 字节缓冲流一次读写一个字节数组
39     private static void method4(File srcFile, File destFile) throws IOException {
40         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
41                 srcFile));
42         BufferedOutputStream bos = new BufferedOutputStream(
43                 new FileOutputStream(destFile));
44 
45         byte[] bys = new byte[1024];
46         int len = 0;
47         while ((len = bis.read(bys)) != -1) {
48             bos.write(bys, 0, len);
49         }
50 
51         bos.close();
52         bis.close();
53     }
54 
55     // 字节缓冲流一次读写一个字节
56     private static void method3(File srcFile, File destFile) throws IOException {
57         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
58                 srcFile));
59         BufferedOutputStream bos = new BufferedOutputStream(
60                 new FileOutputStream(destFile));
61 
62         int by = 0;
63         while ((by = bis.read()) != -1) {
64             bos.write(by);
65         }
66 
67         bos.close();
68         bis.close();
69     }
70 
71     // 基本字节流一次读写一个字节数组
72     private static void method2(File srcFile, File destFile) throws IOException {
73         FileInputStream fis = new FileInputStream(srcFile);
74         FileOutputStream fos = new FileOutputStream(destFile);
75 
76         byte[] bys = new byte[1024];
77         int len = 0;
78         while ((len = fis.read(bys)) != -1) {
79             fos.write(bys, 0, len);
80         }
81 
82         fos.close();
83         fis.close();
84     }
85 
86     // 基本字节流一次读写一个字节
87     private static void method1(File srcFile, File destFile) throws IOException {
88         FileInputStream fis = new FileInputStream(srcFile);
89         FileOutputStream fos = new FileOutputStream(destFile);
90 
91         int by = 0;
92         while ((by = fis.read()) != -1) {
93             fos.write(by);
94         }
95 
96         fos.close();
97         fis.close();
98     }
99 }

练习：把集合中的数据存储到文本文件案例

 1 package cn.itcast_02;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 import java.util.ArrayList;
 7 
 8 /*
 9  * 需求：把ArrayList集合中的字符串数据存储到文本文件
10  * 
11  * 分析：
12  *         通过题目的意思我们可以知道如下的一些内容，
13  *             ArrayList集合里存储的是字符串。
14  *             遍历ArrayList集合，把数据获取到。
15  *             然后存储到文本文件中。
16  *             文本文件说明使用字符流。
17  * 
18  * 数据源：
19  *         ArrayList<String> -- 遍历得到每一个字符串数据
20  * 目的地：
21  *         a.txt -- FileWriter -- BufferedWriter
22  */
23 public class ArrayListToFileDemo {
24     public static void main(String[] args) throws IOException {
25         // 封装数据与(创建集合对象)
26         ArrayList<String> array = new ArrayList<String>();
27         array.add("hello");
28         array.add("world");
29         array.add("java");
30 
31         // 封装目的地
32         BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
33 
34         // 遍历集合
35         for (String s : array) {
36             // 写数据
37             bw.write(s);
38             bw.newLine();
39             bw.flush();
40         }
41 
42         // 释放资源
43         bw.close();
44     }
45 }

练习：把文本文件中的数据存储到集合中案例

 1 package cn.itcast_02;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 import java.util.ArrayList;
 7 
 8 /*
 9  * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
10  * 
11  * 分析：
12  *         通过题目的意思我们可以知道如下的一些内容，
13  *             数据源是一个文本文件。
14  *             目的地是一个集合。
15  *             而且元素是字符串。
16  * 
17  * 数据源：
18  *         b.txt -- FileReader -- BufferedReader
19  * 目的地：
20  *         ArrayList<String>
21  */
22 public class FileToArrayListDemo {
23     public static void main(String[] args) throws IOException {
24         // 封装数据源
25         BufferedReader br = new BufferedReader(new FileReader("b.txt"));
26         // 封装目的地(创建集合对象)
27         ArrayList<String> array = new ArrayList<String>();
28 
29         // 读取数据存储到集合中
30         String line = null;
31         while ((line = br.readLine()) != null) {
32             array.add(line);
33         }
34 
35         // 释放资源
36         br.close();
37 
38         // 遍历集合
39         for (String s : array) {
40             System.out.println(s);
41         }
42     }
43 }

练习：随机获取文本文件中的姓名案例

 1 package cn.itcast_02;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 import java.util.ArrayList;
 7 import java.util.Random;
 8 
 9 /*
10  * 需求：我有一个文本文件中存储了几个名称，请大家写一个程序实现随机获取一个人的名字。
11  * 
12  * 分析：
13  *         A:把文本文件中的数据存储到集合中
14  *         B:随机产生一个索引
15  *         C:根据该索引获取一个值
16  */
17 public class GetName {
18     public static void main(String[] args) throws IOException {
19         // 把文本文件中的数据存储到集合中
20         BufferedReader br = new BufferedReader(new FileReader("b.txt"));
21         ArrayList<String> array = new ArrayList<String>();
22         String line = null;
23         while ((line = br.readLine()) != null) {
24             array.add(line);
25         }
26         br.close();
27 
28         // 随机产生一个索引
29         Random r = new Random();
30         int index = r.nextInt(array.size());
31 
32         // 根据该索引获取一个值
33         String name = array.get(index);
34         System.out.println("该幸运者是：" + name);
35     }
36 }

练习：复制单级文件夹案例

 1 package cn.itcast_03;
 2 
 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;
 9 
10 /*
11  * 需求：复制单极文件夹
12  * 
13  * 数据源：e:\\demo
14  * 目的地：e:\\test
15  * 
16  * 分析：
17  *         A:封装目录
18  *         B:获取该目录下的所有文本的File数组
19  *         C:遍历该File数组，得到每一个File对象
20  *         D:把该File进行复制
21  */
22 public class CopyFolderDemo {
23     public static void main(String[] args) throws IOException {
24         // 封装目录
25         File srcFolder = new File("e:\\demo");
26         // 封装目的地
27         File destFolder = new File("e:\\test");
28         // 如果目的地文件夹不存在，就创建
29         if (!destFolder.exists()) {
30             destFolder.mkdir();
31         }
32 
33         // 获取该目录下的所有文本的File数组
34         File[] fileArray = srcFolder.listFiles();
35 
36         // 遍历该File数组，得到每一个File对象
37         for (File file : fileArray) {
38             // System.out.println(file);
39             // 数据源：e:\\demo\\e.mp3
40             // 目的地：e:\\test\\e.mp3
41             String name = file.getName(); // e.mp3
42             File newFile = new File(destFolder, name); // e:\\test\\e.mp3
43 
44             copyFile(file, newFile);
45         }
46     }
47 
48     private static void copyFile(File file, File newFile) throws IOException {
49         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
50                 file));
51         BufferedOutputStream bos = new BufferedOutputStream(
52                 new FileOutputStream(newFile));
53 
54         byte[] bys = new byte[1024];
55         int len = 0;
56         while ((len = bis.read(bys)) != -1) {
57             bos.write(bys, 0, len);
58         }
59 
60         bos.close();
61         bis.close();
62     }
63 }

练习：复制指定目录下指定后缀名的文件并修改名称案例

 1 package cn.itcast_04;
 2 
 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;
10 
11 /*
12  * 需求：复制指定目录下的指定文件，并修改后缀名。
13  * 指定的文件是：.java文件。
14  * 指定的后缀名是：.jad
15  * 指定的目录是：jad
16  * 
17  * 数据源：e:\\java\\A.java
18  * 目的地：e:\\jad\\A.jad
19  * 
20  * 分析：
21  *         A:封装目录
22  *         B:获取该目录下的java文件的File数组
23  *         C:遍历该File数组，得到每一个File对象
24  *         D:把该File进行复制
25  *         E:在目的地目录下改名
26  */
27 public class CopyFolderDemo {
28     public static void main(String[] args) throws IOException {
29         // 封装目录
30         File srcFolder = new File("e:\\java");
31         // 封装目的地
32         File destFolder = new File("e:\\jad");
33         // 如果目的地目录不存在，就创建
34         if (!destFolder.exists()) {
35             destFolder.mkdir();
36         }
37 
38         // 获取该目录下的java文件的File数组
39         File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
40             @Override
41             public boolean accept(File dir, String name) {
42                 return new File(dir, name).isFile() && name.endsWith(".java");
43             }
44         });
45 
46         // 遍历该File数组，得到每一个File对象
47         for (File file : fileArray) {
48             // System.out.println(file);
49             // 数据源：e:\java\DataTypeDemo.java
50             // 目的地：e:\\jad\DataTypeDemo.java
51             String name = file.getName();
52             File newFile = new File(destFolder, name);
53             copyFile(file, newFile);
54         }
55 
56         // 在目的地目录下改名
57         File[] destFileArray = destFolder.listFiles();
58         for (File destFile : destFileArray) {
59             // System.out.println(destFile);
60             // e:\jad\DataTypeDemo.java
61             // e:\\jad\\DataTypeDemo.jad
62             String name =destFile.getName(); //DataTypeDemo.java
63             String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
64             
65             File newFile = new File(destFolder,newName);
66             destFile.renameTo(newFile);
67         }
68     }
69 
70     private static void copyFile(File file, File newFile) throws IOException {
71         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
72                 file));
73         BufferedOutputStream bos = new BufferedOutputStream(
74                 new FileOutputStream(newFile));
75 
76         byte[] bys = new byte[1024];
77         int len = 0;
78         while ((len = bis.read(bys)) != -1) {
79             bos.write(bys, 0, len);
80         }
81 
82         bos.close();
83         bis.close();
84     }
85 }

练习：复制多级文件夹案例

 1 package cn.itcast_05;
 2 
 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;
 9 
10 /*
11  * 需求：复制多极文件夹
12  * 
13  * 数据源：E:\JavaSE\day21\code\demos
14  * 目的地：E:\\
15  * 
16  * 分析：
17  *         A:封装数据源File
18  *         B:封装目的地File
19  *         C:判断该File是文件夹还是文件
20  *             a:是文件夹
21  *                 就在目的地目录下创建该文件夹
22  *                 获取该File对象下的所有文件或者文件夹File对象
23  *                 遍历得到每一个File对象
24  *                 回到C
25  *             b:是文件
26  *                 就复制(字节流)
27  */
28 public class CopyFoldersDemo {
29     public static void main(String[] args) throws IOException {
30         // 封装数据源File
31         File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
32         // 封装目的地File
33         File destFile = new File("E:\\");
34 
35         // 复制文件夹的功能
36         copyFolder(srcFile, destFile);
37     }
38 
39     private static void copyFolder(File srcFile, File destFile)
40             throws IOException {
41         // 判断该File是文件夹还是文件
42         if (srcFile.isDirectory()) {
43             // 文件夹
44             File newFolder = new File(destFile, srcFile.getName());
45             newFolder.mkdir();
46 
47             // 获取该File对象下的所有文件或者文件夹File对象
48             File[] fileArray = srcFile.listFiles();
49             for (File file : fileArray) {
50                 copyFolder(file, newFolder);
51             }
52         } else {
53             // 文件
54             File newFile = new File(destFile, srcFile.getName());
55             copyFile(srcFile, newFile);
56         }
57     }
58 
59     private static void copyFile(File srcFile, File newFile) throws IOException {
60         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
61                 srcFile));
62         BufferedOutputStream bos = new BufferedOutputStream(
63                 new FileOutputStream(newFile));
64 
65         byte[] bys = new byte[1024];
66         int len = 0;
67         while ((len = bis.read(bys)) != -1) {
68             bos.write(bys, 0, len);
69         }
70 
71         bos.close();
72         bis.close();
73     }
74 }

--回眸不舍离去，此情为你在心上停栖... ...

posted @ 2017-06-12 23:07 花醉红尘阅读(213) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

花醉红尘

婆罗樱花终相见相伴人世共翩跹

Java笔记(21)：IO流(03)

公告

花醉红尘

婆罗樱花终相见 相伴人世共翩跹

Java笔记(21)：IO流(03)

公告

婆罗樱花终相见相伴人世共翩跹