java基础学习_IO流03_字符流、IO流小结、案例_day21总结

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

 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  * BufferedWriter类的构造方法
17  *         public BufferedWriter(Writer out)
18  */
19 public class BufferedWriterDemo {
20     public static void main(String[] args) throws IOException {
21         // 创建字符缓冲区输出流对象
22         // public BufferedWriter(Writer out)
23         // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bw.txt")));
24         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
25 
26         bw.write("hello");
27         bw.write("world");
28         bw.write("java");
29         bw.flush();
30 
31         bw.close();
32     }
33 }

 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类的构造方法
13  *         public BufferedReader(Reader in)
14  */
15 public class BufferedReaderDemo {
16     public static void main(String[] args) throws IOException {
17         // 创建字符缓冲区输入流对象
18         // public BufferedReader(Reader in)
19         // BufferedReader bw = new BufferedReader(new InputStreamReader(new FileInputStream("bw.txt")));
20         BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
21 
22         // 方式1
23 //        int ch = 0;
24 //        while ((ch = br.read()) != -1) {
25 //            System.out.print((char) ch);
26 //        }
27 
28         // 方式2
29         char[] chs = new char[1024];
30         int len = 0;
31         while ((len = br.read(chs)) != -1) {
32             System.out.print(new String(chs, 0, len));
33         }
34 
35         // 释放资源
36         br.close();
37     }
38 }

 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); // hello1
30         // line = br.readLine();
31         // System.out.println(line); // hello2
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 < 100; x++) {
47             bw.write("hello" + x); // bw.write("\r\n"); // 在windows系统下的换行
48             bw.newLine(); // 根据系统属性来决定换行符
49             bw.flush(); // 习惯性写法
50         }
51         bw.close();
52     }
53 
54 }

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

 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         
29         // 使用File对象作为参数(装逼/专业写法)
30         File srcFile = new File("c:\\a.jpg");
31         File destFile = new File("d:\\b.jpg");
32         // 是文件和目录(文件夹)路径名的抽象表示形式。仅仅是一个路径的表示，不代表具体的事物一定是存在的。
33         
34         // method1(srcFile, destFile);
35         // method2(srcFile, destFile);
36         // method3(srcFile, destFile);
37         method4(srcFile, destFile);
38     }
39 
40     // 字节缓冲区流：一次读写一个字节数组
41     private static void method4(File srcFile, File destFile) throws IOException {
42         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
43         BufferedOutputStream bos = new BufferedOutputStream(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(srcFile));
58         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
59 
60         int by = 0;
61         while ((by = bis.read()) != -1) {
62             bos.write(by);
63         }
64 
65         bos.close();
66         bis.close();
67     }
68 
69     // 基本字节流：一次读写一个字节数组
70     private static void method2(File srcFile, File destFile) throws IOException {
71         FileInputStream fis = new FileInputStream(srcFile);
72         FileOutputStream fos = new FileOutputStream(destFile);
73 
74         byte[] bys = new byte[1024];
75         int len = 0;
76         while ((len = fis.read(bys)) != -1) {
77             fos.write(bys, 0, len);
78         }
79 
80         fos.close();
81         fis.close();
82     }
83 
84     // 基本字节流：一次读写一个字节
85     private static void method1(File srcFile, File destFile) throws IOException {
86         FileInputStream fis = new FileInputStream(srcFile);
87         FileOutputStream fos = new FileOutputStream(destFile);
88 
89         int by = 0;
90         while ((by = fis.read()) != -1) {
91             fos.write(by);
92         }
93 
94         fos.close();
95         fis.close();
96     }
97 }

 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  *             
14  *             只有写出数据，没有读取数据。
15  * 
16  *             ArrayList集合里存储的是字符串。
17  *             遍历ArrayList集合，把数据获取到。
18  *             然后存储到文本文件中。
19  * 
20  *             文本文件说明使用字符流。
21  * 
22  * 数据源：
23  *         ArrayList<String> --> 遍历得到每一个字符串数据
24  * 目的地：
25  *         a.txt --> FileWriter --> BufferedWriter
26  */
27 public class ArrayListToFileDemo {
28     public static void main(String[] args) throws IOException {
29         // 封装数据源(创建集合对象)
30         ArrayList<String> array = new ArrayList<String>();
31         array.add("hello");
32         array.add("world");
33         array.add("java");
34 
35         // 封装目的地
36         BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
37 
38         // 遍历集合(增强for)
39         for (String s : array) {
40             // 写数据
41             bw.write(s);
42             bw.newLine();
43             bw.flush();
44         }
45 
46         // 释放资源
47         bw.close();
48     }
49 }

 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  *             而且元素是字符串。
19  * 
20  * 数据源：
21  *         b.txt --> FileReader --> BufferedReader
22  * 目的地：
23  *         ArrayList<String>
24  */
25 public class FileToArrayListDemo {
26     public static void main(String[] args) throws IOException {
27         // 封装数据源
28         BufferedReader br = new BufferedReader(new FileReader("b.txt"));
29         // 封装目的地(创建集合对象)
30         ArrayList<String> array = new ArrayList<String>();
31 
32         // 读取数据存储到集合中
33         String line = null;
34         while ((line = br.readLine()) != null) {
35             array.add(line);
36         }
37 
38         // 释放资源
39         br.close();
40 
41         // 遍历集合(增强for)
42         for (String s : array) {
43             System.out.println(s);
44         }
45         
46     }
47 }

 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("name.txt"));
21         ArrayList<String> array = new ArrayList<String>();
22         
23         String line = null;
24         while ((line = br.readLine()) != null) {
25             array.add(line);
26         }
27         br.close();
28 
29         // 随机产生一个索引，并设定索引的范围
30         Random r = new Random();
31         int index = r.nextInt(array.size()); // [0, array.size())
32 
33         // 根据该索引获取一个值
34         String name = array.get(index);
35         System.out.println("该幸运者是：" + name);
36     }
37 }

 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  *         用字节流
14  * 
15  * 数据源：e:\\demo
16  * 目的地：e:\\test
17  * 
18  * 分析：
19  *         A:封装数据源File对象+封装目的地File对象
20  *         B:获取数据源目录下的所有文件的File数组
21  *         C:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
22  *         D:把该File进行复制
23  */
24 public class CopyFolderDemo {
25     public static void main(String[] args) throws IOException {
26         // 封装数据源File对象
27         File srcFolder = new File("e:\\demo");
28         // 封装目的地File对象
29         File destFolder = new File("e:\\test");
30         // 如果目的地文件夹不存在，就创建
31         if (!destFolder.exists()) {
32             destFolder.mkdir();
33         }
34 
35         // 获取数据源目录下的所有文件的File数组
36         // 遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
37         // 把该File进行复制
38         File[] fileArray = srcFolder.listFiles();
39         for (File srcFile : fileArray) {
40             // System.out.println(file); // e:\demo\e.mp3
41             // 数据源：e:\\demo\\e.mp3    注意：数据源是变化的
42             // 目的地：e:\\test\\e.mp3    注意：目的地也是变化的(使用拼接)
43             String name = srcFile.getName(); // e.mp3
44             File destFile = new File(destFolder, name); // e:\\test\\e.mp3
45 
46             copyFile(srcFile, destFile);
47         }
48     }
49 
50     private static void copyFile(File srcFile, File destFile) throws IOException {
51         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
52         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
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  * 需求：复制指定单级文件夹中的指定文件，并修改文件后缀名(里面只有文件，且文件各种各样，但是本例题为了增加一点难度，使该单级文件夹中增加一个文件夹名为hello.java的文件夹)
13  *         
14  *         指定的文件是：.java文件
15  *         指定的后缀名是：.jad
16  *         指定的目录是：jad
17  * 
18  * 数据源：e:\\java\\A.java
19  * 目的地：e:\\jad\\A.jad
20  * 
21  * 分析：
22  *         A:封装数据源File对象+封装目的地File对象
23  *         B:获取数据源目录下的所有.java文件的File数组(加入了判断条件)
24  *         C:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
25  *         D:把符合条件的File进行复制
26  *         E:获取目的地目录下的所有文件的File数组
27  *         F:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
28  *         E:把该File重命名为新名字
29  */
30 public class CopyFolderDemo {
31     public static void main(String[] args) throws IOException {
32         // 封装数据源File对象
33         File srcFolder = new File("e:\\java");
34         // 封装目的地File对象
35         File destFolder = new File("e:\\jad");
36         // 如果目的地目录不存在，就创建
37         if (!destFolder.exists()) {
38             destFolder.mkdir();
39         }
40 
41         // 获取数据源目录下的所有.java文件的File数组(加入了判断条件)
42         File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
43             @Override
44             public boolean accept(File dir, String name) {
45                 return new File(dir, name).isFile() && name.endsWith(".java");
46             }
47         });
48 
49         // 遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
50         // 把符合条件的File进行复制
51         for (File srcFile : fileArray) {
52             // System.out.println(file); // e:\java\DataTypeDemo.java
53             // 数据源：e:\\java\\DataTypeDemo.java     注意：数据源是变化的
54             // 目的地：e:\\jad\\DataTypeDemo.java     注意：目的地也是变化的(使用拼接)
55             String name = srcFile.getName(); // DataTypeDemo.java
56             File destFile = new File(destFolder, name); // e:\\jad\\DataTypeDemo.java
57 
58             copyFile(srcFile, destFile);
59         }
60 
61         // 获取目的地目录下的所有文件的File数组
62         // 遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
63         // 把该File重命名为新名字
64         File[] destFileArray = destFolder.listFiles();
65         for (File destFile : destFileArray) {
66             // System.out.println(destFile); // e:\jad\DataTypeDemo.java
67             // 数据源：e:\\jad\\DataTypeDemo.java
68             // 目的地：e:\\jad\\DataTypeDemo.jad
69             String oldName = destFile.getName(); // DataTypeDemo.java
70             String newName = oldName.replace(".java", ".jad"); // DataTypeDemo.jad
71             File newFile = new File(destFolder, newName); // e:\\jad\\DataTypeDemo.jad
72             
73             destFile.renameTo(newFile);
74         }
75     }
76 
77     private static void copyFile(File srcFile, File destFile) throws IOException {
78         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
79         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
80 
81         byte[] bys = new byte[1024];
82         int len = 0;
83         while ((len = bis.read(bys)) != -1) {
84             bos.write(bys, 0, len);
85         }
86 
87         bos.close();
88         bis.close();
89     }
90 }

 1 package cn.itcast_09;
 2 
 3 import java.io.File;
 4 
 5 /*
 6  * 需求：把E:\评书\三国演义下面的视频名称修改为
 7  *         00?_介绍.avi
 8  * 
 9  * 思路：
10  *         A:把 E:\\评书\\三国演义 封装成一个File对象
11  *         B:获取该目录下所有的文件的File数组
12  *         C:遍历该File数组，得到每一个File对象，该对象名打印输出为：E:\\评书\\三国演义\\三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi
13  *         D:获取符合要求的各个名称
14  *         E:拼接一个新的名称，再new一个新对象，新对象名打印输出为： E:\\评书\\三国演义\\001_桃园三结义.avi
15  *         F:然后重命名即可。
16  */
17 public class FileDemo {
18     public static void main(String[] args) {
19         // 把 E:\\评书\\三国演义 封装成一个File对象
20         File srcFolder = new File("E:\\评书\\三国演义");
21 
22         // 获取该目录下所有的文件的File数组
23         File[] fileArray = srcFolder.listFiles();
24 
25         // 遍历该File数组，得到每一个File对象
26         for (File file : fileArray) {
27             // System.out.println(file); 
28             
29             // 改前：E:\评书\三国演义\三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi
30             // 改后：E:\评书\三国演义\001_桃园三结义.avi
31             
32             String name = file.getName(); // 三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi
33 
34             int index = name.indexOf("_"); // 找到第一个_
35             String numberString = name.substring(index + 1, index + 4); // 001    包左不包右 
36             // System.out.println(numberString); // 001
37             
38             int endIndex = name.lastIndexOf('_'); // 找到最后一个_
39             String nameString = name.substring(endIndex); // 桃园三结义.avi
40             // System.out.println(nameString); // 桃园三结义.avi
41             
42             // 拼接一个新的名称
43             String newName = numberString.concat(nameString); // 001_桃园三结义.avi
44             // System.out.println(newName); // 001_桃园三结义.avi
45 
46             // 把 E:\\评书\\三国演义\\001_桃园三结义.avi 封装成一个File对象
47             File newFile = new File(srcFolder, newName); // E:\\评书\\三国演义\\001_桃园三结义.avi
48             // System.out.println(newFile);
49             
50             // 重命名即可
51             file.renameTo(newFile);
52         }
53     }
54 }

 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对象+封装目的地File对象
18  *         B:判断该数据源File对象是文件夹还是文件
19  *             a:是文件夹
20  *                 就在目的地目录下创建该文件夹(创建前先拼接一个新的文件夹路径名的抽象表示)
21  *                 获取该数据源File对象下的所有文件或者文件夹的File数组
22  *                 遍历该File数组，得到每一个File对象
23  *                 回到B(递归)
24  *             b:是文件(文件各种各样，用字节流复制)
25  *                 就在目的地目录下复制该文件(复制前先拼接一个新的文件路径名的抽象表示)
26  */
27 public class CopyFoldersDemo {
28     public static void main(String[] args) throws IOException {
29         // 封装数据源File对象
30         File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
31         // 封装目的地File对象
32         File destFile = new File("E:\\");
33 
34         // 复制文件夹的功能
35         copyFolder(srcFile, destFile);
36     }
37 
38     private static void copyFolder(File srcFile, File destFile) throws IOException {
39         // 判断该数据源File对象是文件夹还是文件
40         if (srcFile.isDirectory()) {
41             // 是文件夹
42             // 就在目的地目录下创建该文件夹(创建前先拼接一个新的文件夹路径名的抽象表示)
43             File newFolder = new File(destFile, srcFile.getName());
44             newFolder.mkdir(); // 因为文件夹不会帮你自动创建，需要你手动创建
45 
46             // 获取该数据源File对象下的所有文件或者文件夹的File数组
47             // 遍历该File数组，得到每一个File对象
48             File[] fileArray = srcFile.listFiles();
49             for (File file : fileArray) {
50                 copyFolder(file, newFolder);
51             }
52         } else {
53             // 是文件(文件各种各样，用字节流复制)
54             // 就在目的地目录下复制该文件(复制前先拼接一个新的文件路径名的抽象表示)
55             File newFile = new File(destFile, srcFile.getName());
56             copyFile(srcFile, newFile);
57         }
58     }
59 
60     // 复制文件的功能
61     private static void copyFile(File srcFile, File newFile) throws IOException {
62         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
63         BufferedOutputStream bos = new BufferedOutputStream(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 }

 1 package cn.itcast_06;
 2 
 3 public class Student {
 4     // 姓名
 5     private String name;
 6     // 语文成绩
 7     private int chinese;
 8     // 数学成绩
 9     private int math;
10     // 英语成绩
11     private int english;
12 
13     public Student() {
14         super();
15     }
16 
17     public Student(String name, int chinese, int math, int english) {
18         super();
19         this.name = name;
20         this.chinese = chinese;
21         this.math = math;
22         this.english = english;
23     }
24 
25     public String getName() {
26         return name;
27     }
28 
29     public void setName(String name) {
30         this.name = name;
31     }
32 
33     public int getChinese() {
34         return chinese;
35     }
36 
37     public void setChinese(int chinese) {
38         this.chinese = chinese;
39     }
40 
41     public int getMath() {
42         return math;
43     }
44 
45     public void setMath(int math) {
46         this.math = math;
47     }
48 
49     public int getEnglish() {
50         return english;
51     }
52 
53     public void setEnglish(int english) {
54         this.english = english;
55     }
56 
57     public int getSum() {
58         return this.chinese + this.math + this.english;
59     }
60 }

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 import java.util.Comparator;
 7 import java.util.Scanner;
 8 import java.util.TreeSet;
 9 
10 /*
11  * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低存入文本文件。
12  * 
13  * 分析：
14  *         A:创建学生类
15  *         B:创建集合对象(比较器排序:匿名内部类实现)
16  *             TreeSet<Student>
17  *         C:键盘录入学生信息并存储到集合
18  *         D:遍历集合，把数据写到文本文件
19  */
20 public class StudentDemo {
21     public static void main(String[] args) throws IOException {
22         // 创建集合对象(比较器排序:匿名内部类实现)
23         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
24             @Override
25             public int compare(Student s1, Student s2) {
26                 int num = s2.getSum() - s1.getSum(); // 主要条件
27                 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num; // 次要条件
28                 int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2; // 次要条件
29                 int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3; // 次要条件
30                 int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4; // 次要条件
31                 return num5; 
32             }
33         });
34 
35         // 键盘录入学生信息并存储到集合
36         Scanner sc = null;
37         for (int x = 1; x <= 5; x++) {
38             sc = new Scanner(System.in);
39             System.out.println("请录入第" + x + "个的学习信息");
40             System.out.println("姓名：");
41             String name = sc.nextLine();
42             System.out.println("语文成绩：");
43             int chinese = sc.nextInt();
44             System.out.println("数学成绩：");
45             int math = sc.nextInt();
46             System.out.println("英语成绩：");
47             int english = sc.nextInt();
48 
49             // 创建学生对象
50             Student s = new Student();
51             s.setName(name);
52             s.setChinese(chinese);
53             s.setMath(math);
54             s.setEnglish(english);
55 
56             // 把学生对象添加到集合
57             ts.add(s);
58         }
59         sc.close();
60 
61         // 遍历集合，把数据写到文本文件
62         BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
63         bw.write("学生信息如下：");
64         bw.newLine();
65         bw.flush();
66         bw.write("姓名,语文成绩,数学成绩,英语成绩");
67         bw.newLine();
68         bw.flush();
69         for (Student s : ts) {
70             StringBuilder sb = new StringBuilder();
71             sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish());
72             bw.write(sb.toString());
73             bw.newLine();
74             bw.flush();
75         }
76         // 释放资源
77         bw.close();
78         System.out.println("学习信息存储完毕");
79     }
80 }

 1 package cn.itcast_09;
 2 
 3 public class Student {
 4     // 姓名
 5     private String name;
 6     // 语文成绩
 7     private int chinese;
 8     // 数学成绩
 9     private int math;
10     // 英语成绩
11     private int english;
12     
13     public Student() {
14         super();
15     }
16 
17     public Student(String name, int chinese, int math, int english) {
18         super();
19         this.name = name;
20         this.chinese = chinese;
21         this.math = math;
22         this.english = english;
23     }
24 
25     public String getName() {
26         return name;
27     }
28 
29     public void setName(String name) {
30         this.name = name;
31     }
32 
33     public int getChinese() {
34         return chinese;
35     }
36 
37     public void setChinese(int chinese) {
38         this.chinese = chinese;
39     }
40 
41     public int getMath() {
42         return math;
43     }
44 
45     public void setMath(int math) {
46         this.math = math;
47     }
48 
49     public int getEnglish() {
50         return english;
51     }
52 
53     public void setEnglish(int english) {
54         this.english = english;
55     }
56 
57     public int getSum() {
58         return this.chinese + this.math + this.english;
59     }
60 }

 1 package cn.itcast_09;
 2 
 3 import java.util.Comparator;
 4 import java.util.Scanner;
 5 import java.util.TreeSet;
 6 
 7 /*
 8  * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低输出到控制台。
 9  * 
10  * 分析：
11  *         A:定义学生类
12  *         B:创建一个TreeSet集合(比较器排序:匿名内部类实现)
13  *             TreeSet<Student>
14  *         C:总分从高到底如何实现呢?        
15  *         D:键盘录入5个学生信息
16  *         E:遍历TreeSet集合
17  */
18 public class TreeSetDemo {
19     public static void main(String[] args) {
20         // 创建一个TreeSet集合(比较器排序:匿名内部类实现)
21         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
22             @Override
23             public int compare(Student s1, Student s2) {
24                 // 总分从高到低
25                 int num = s2.getSum() - s1.getSum();
26                 // 总分相同的不一定语文相同
27                 int num2 = (num == 0 ? s1.getChinese() - s2.getChinese() : num);
28                 // 总分和语文相同的不一定数序相同
29                 int num3 = (num2 == 0 ? s1.getMath() - s2.getMath() : num2);
30                 // 总分、语文和数学相同的不一定英语相同
31                 int num4 = (num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3);
32                 // 总分、语文、数学和英语相同的姓名还不一定相同
33                 int num5 = (num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4);
34                 return num5;
35             }
36         });
37 
38         System.out.println("学生信息录入开始");
39         // 键盘录入5个学生信息
40         Scanner sc = null;
41         for (int x = 1; x <= 5; x++) {
42             sc = new Scanner(System.in);
43             
44             System.out.println("请输入第" + x + "个学生的姓名:");
45             String name = sc.nextLine();
46             
47             System.out.println("请输入第" + x + "个学生的语文成绩:");
48             String chineseString = sc.nextLine();
49             
50             System.out.println("请输入第" + x + "个学生的数学成绩:");
51             String mathString = sc.nextLine();
52             
53             System.out.println("请输入第" + x + "个学生的英语成绩:");
54             String englishString = sc.nextLine();
55 
56             // 把录入的数据封装到学生对象中
57             Student s = new Student();
58             s.setName(name);
59             s.setChinese(Integer.parseInt(chineseString)); // 把字符串类型转换为int类型
60             s.setMath(Integer.parseInt(mathString));        // 把字符串类型转换为int类型
61             s.setEnglish(Integer.parseInt(englishString)); // 把字符串类型转换为int类型
62 
63             // 把学生对象添加到集合
64             ts.add(s);
65         }
66         sc.close();
67         
68         System.out.println("学生信息录入完毕");
69 
70         System.out.println("学习信息从高到低排序如下：");
71         System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩");
72         // 遍历TreeSet集合
73         for (Student s : ts) {
74             System.out.println(s.getName() + "\t" + s.getChinese() + "\t" + s.getMath() + "\t" + s.getEnglish());
75         }
76     }
77 }

 1 package cn.itcast_07;
 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 import java.util.Arrays;
 9 
10 /*
11  * 已知在s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”
12  * 请编写程序读取s.txt文件的数据内容，把读取到的数据排序后写入到ss.txt中。
13  * 
14  * 分析：
15  *         A:封装数据源File对象
16  *         B:读取该File对象的内容，存储到一个字符串中
17  *         C:把字符串转换为字符数组
18  *         D:对字符数组进行排序(使用数组工具类的排序方法)
19  *         E:把排序后的字符数组转换为字符串(通过字符串的构造方法实现)
20  *         F:封装目的地File对象
21  *         G:通过该File对象把字符串写入到ss.txt中
22  */
23 public class StringDemo {
24     public static void main(String[] args) throws IOException {
25         // 封装数据源File对象
26         // 读取该File对象的内容，存储到一个字符串中
27         BufferedReader br = new BufferedReader(new FileReader("s.txt"));
28         String line = br.readLine();
29         br.close();
30 
31         // 把字符串转换为字符数组
32         char[] chs = line.toCharArray();
33 
34         // 对字符数组进行排序(使用数组工具类的排序方法实现)
35         Arrays.sort(chs);
36 
37         // 把排序后的字符数组转换为字符串(通过字符串的构造方法实现)
38         String s = new String(chs);
39 
40         // 封装目的地File对象
41         // 通过该File对象把字符串写入到ss.txt中
42         BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
43         bw.write(s);
44         bw.newLine();
45         bw.flush();
46 
47         bw.close();
48     }
49 }

 1 package cn.itcast_08;
 2 
 3 import java.io.IOException;
 4 import java.io.Reader;
 5 
 6 /*
 7  * 用Reader来模拟BufferedReader的readLine()功能
 8  * 
 9  * readLine() 一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符。
10  * 
11  *
12  * 思考：写一个方法，返回值是一个字符串。
13  * 
14  * 我要返回一个字符串，我该怎么办呢? 
15  * 因为我们现在有一个Reader对象，所以我们必须去看看r对象能够读取什么东西呢? 
16  * r对象有两个读取方法：一次读取一个字符或者一次读取一个字符数组。
17  * 
18  * 那么，我们要返回一个字符串，用哪个方法比较好呢? 
19  * 我们很容易想到用字符数组比较好，但是问题来了，就是这个字符数组的长度是多长呢?
20  * 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。
21  * 
22  * 但是呢，用这种方式的时候，我们在读取下一个字符的时候，上一个字符就丢失了。
23  * 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。
24  * 
25  * 这个用谁比较合适呢?
26  * 数组、集合、字符串缓冲区三个可供选择。
27  * 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder。
28  * 
29  */
30 public class MyBufferedReader {
31     private Reader r;
32 
33     public MyBufferedReader(Reader r) {
34         this.r = r;
35     }
36     
37     public String readLine() throws IOException {
38         StringBuilder sb = new StringBuilder();
39         
40         // 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1。
41         int ch = 0;
42         while ((ch = r.read()) != -1) { 
43             if (ch == '\r') {
44                 continue;
45             }
46 
47             if (ch == '\n') {
48                 return sb.toString(); 
49             } else {
50                 sb.append((char)ch); 
51             }
52         }
53 
54         // 如果原始数据最后一行没有回车换行符(\r\n)，读取到的最好一行数据会丢失，所以判断读取到的最后一行的sb的长度，长度大于0说明有数据。
55         if (sb.length() > 0) {
56             return sb.toString();
57         }
58 
59         return null;
60     }
61 
62     /*
63      * 先写一个关闭流的方法
64      */
65     public void close() throws IOException {
66         this.r.close();
67     }
68 }

 1 package cn.itcast_08;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 /*
 7  * 注意：测试MyBufferedReader的时候，你就把它当作BufferedReader一样来使用就好。
 8  */
 9 public class MyBufferedReaderDemo {
10     public static void main(String[] args) throws IOException {
11         MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt"));
12 
13         String line = null;
14         while ((line = mbr.readLine()) != null) {
15             System.out.println(line);
16         }
17 
18         mbr.close();
19     }
20 }

 1 package cn.itcast_09;
 2 
 3 import java.io.IOException;
 4 import java.io.Reader;
 5 
 6 public class MyLineNumberReader {
 7     private Reader r;
 8     private int lineNumber = 0;
 9 
10     public MyLineNumberReader(Reader r) {
11         this.r = r;
12     }
13 
14     public int getLineNumber() {
15         return lineNumber;
16     }
17 
18     public void setLineNumber(int lineNumber) {
19         this.lineNumber = lineNumber;
20     }
21 
22     public String readLine() throws IOException {
23         lineNumber++; // 每调用一次readLine()方法后就让行号自加1
24 
25         StringBuilder sb = new StringBuilder();
26 
27         int ch = 0;
28         while ((ch = r.read()) != -1) {
29             if (ch == '\r') {
30                 continue;
31             }
32 
33             if (ch == '\n') {
34                 return sb.toString();
35             } else {
36                 sb.append((char) ch);
37             }
38         }
39 
40         if (sb.length() > 0) {
41             return sb.toString();
42         }
43 
44         return null;
45     }
46 
47     public void close() throws IOException {
48         this.r.close();
49     }
50 }

 1 package cn.itcast_09;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 public class MyLineNumberReaderTest {
 7     public static void main(String[] args) throws IOException {
 8         MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader("my.txt"));
 9         
10         mlnr.setLineNumber(10);
11 
12         String line = null;
13         while ((line = mlnr.readLine()) != null) {
14             System.out.println(mlnr.getLineNumber() + ":" + line);
15         }
16 
17         mlnr.close();
18 
19     }
20 }

 1 package cn.itcast_08;
 2 
 3 import java.io.IOException;
 4 import java.io.Reader;
 5 
 6 /*
 7  * 用Reader来模拟BufferedReader的readLine()功能
 8  * 
 9  * readLine() 一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符。
10  * 
11  *
12  * 思考：写一个方法，返回值是一个字符串。
13  * 
14  * 我要返回一个字符串，我该怎么办呢? 
15  * 因为我们现在有一个Reader对象，所以我们必须去看看r对象能够读取什么东西呢? 
16  * r对象有两个读取方法：一次读取一个字符或者一次读取一个字符数组。
17  * 
18  * 那么，我们要返回一个字符串，用哪个方法比较好呢? 
19  * 我们很容易想到用字符数组比较好，但是问题来了，就是这个字符数组的长度是多长呢?
20  * 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。
21  * 
22  * 但是呢，用这种方式的时候，我们在读取下一个字符的时候，上一个字符就丢失了。
23  * 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。
24  * 
25  * 这个用谁比较合适呢?
26  * 数组、集合、字符串缓冲区三个可供选择。
27  * 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder。
28  * 
29  */
30 public class MyBufferedReader {
31     private Reader r;
32 
33     public MyBufferedReader(Reader r) {
34         this.r = r;
35     }
36     
37     public String readLine() throws IOException {
38         StringBuilder sb = new StringBuilder();
39         
40         // 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1。
41         int ch = 0;
42         while ((ch = r.read()) != -1) { 
43             if (ch == '\r') {
44                 continue;
45             }
46 
47             if (ch == '\n') {
48                 return sb.toString(); 
49             } else {
50                 sb.append((char)ch); 
51             }
52         }
53 
54         // 如果原始数据最后一行没有回车换行符(\r\n)，读取到的最好一行数据会丢失，所以判断读取到的最后一行的sb的长度，长度大于0说明有数据。
55         if (sb.length() > 0) {
56             return sb.toString();
57         }
58 
59         return null;
60     }
61 
62     /*
63      * 先写一个关闭流的方法
64      */
65     public void close() throws IOException {
66         this.r.close();
67     }
68 }

 1 package cn.itcast_09;
 2 
 3 import java.io.IOException;
 4 import java.io.Reader;
 5 
 6 import cn.itcast_08.MyBufferedReader;
 7 
 8 public class MyLineNumberReader2 extends MyBufferedReader {
 9     private Reader r;
10 
11     private int lineNumber = 0;
12 
13     public MyLineNumberReader2(Reader r) {
14         super(r);
15     }
16 
17     public int getLineNumber() {
18         return lineNumber;
19     }
20 
21     public void setLineNumber(int lineNumber) {
22         this.lineNumber = lineNumber;
23     }
24     
25     // 重写父类MyBufferedReader的readLine()方法
26     @Override
27     public String readLine() throws IOException {
28         lineNumber++;
29         return super.readLine();
30     }
31 }

 1 package cn.itcast_09;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 public class MyLineNumberReaderTest2 {
 7     public static void main(String[] args) throws IOException {
 8         // 改进版
 9         MyLineNumberReader2 mlnr2 = new MyLineNumberReader2(new FileReader("my.txt"));
10         
11         mlnr2.setLineNumber(10);
12 
13         String line = null;
14         while ((line = mlnr2.readLine()) != null) {
15             System.out.println(mlnr2.getLineNumber() + ":" + line);
16         }
17 
18         mlnr2.close();
19 
20 
21     }
22 }