java基础学习_IO流03_字符流、IO流小结、案例_day21总结
=============================================================================
=============================================================================
涉及到的知识点有：
1:字符流(掌握)
(1)转换流出现的原因及作用
(2)转换流其实是一个字符流。
(3)编码表
A:编码表的概述
B:常见的编码表
C:字符串中的编码问题
(4)IO流中的编码问题
(5)字符转换流的5种写数据的方式
(6)字符转换流的2种读数据的方式
(7)面试题
(8)字符转换流(= 字符流 = 转换流) ==> 字符转换简化流 ==> 字符流
(9)字符缓冲区流
(10)字符流
2:IO流小结(掌握)
3:案例(掌握)
A:复制文本文件(用字符流) 5种方式(掌握)
B:复制图片/视频/音频(用字节流) 4种方式(掌握)
C:把ArrayList集合中的数据存储到文本文件
D:从文本文件中读取数据(每一行为一个字符串数据)到ArrayList集合中，并遍历集合
E:我有一个文本文件中存储了几个名字，请大家写一个程序实现随机获取一个人的名字。
F:复制指定单级文件夹中的所有文件(里面只有文件，且文件各种各样)
G:复制指定单级文件夹中的指定的文件，并修改文件后缀名(里面只有文件，且文件各种各样，但是本例题为了增加一点难度，使该单级文件夹中增加一个文件夹名为hello.java的文件夹)
H:复制多级文件夹
I:键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低存入文本文件。
J:已知在s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”，请编写程序读取s.txt文件的数据内容，把读取到的数据排序后写入到ss.txt中。
K:用Reader来模拟BufferedReader的特有功能readLine()
L:用自定义类来模拟LineNumberReader的特有功能getLineNumber()和setLineNumber()
=============================================================================
=============================================================================
1:字符流(掌握)
(1)转换流出现的原因及作用
转换流出现的原因：字节流操作中文数据不是特别的方便，所以，java就提供了转换流。
转换流的作用：就是把字节流转换字符流来使用。
(2)转换流其实是一个字符流。
字符流 = 字节流 + 编码表
---------------------------------------
(3)编码表
A:编码表的概述
就是由现实世界的字符和对应的数值组成的一张表。
B:常见的编码表
ASCII：美国标准信息交换码。
用一个字节的7位表示(最高位为符号位，其余位为数值位)。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示，Java语言使用的就是Unicode编码。
ISO-8859-1：拉丁码表。欧洲码表。
用一个字节的8位表示。
GB2312：中国的中文编码表。(简体中文)
GBK：中国的中文编码表升级，融合了更多的中文文字符号。(简体中文)
GB18030：GBK的取代版本。(简体中文)
BIG5：通用于台湾、香港地区的一个繁体字编码方案，俗称“大五码”。
UTF-8：最多用三个字节来表示一个字符。
UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容：
它将Unicode编码为 00000000-0000007F 的字符，用单个字节来表示；
它将Unicode编码为 00000080-000007FF 的字符，用两个字节表示；
它将Unicode编码为 00000800-0000FFFF 的字符，用三个字节表示。
C:字符串中的编码问题
String类的构造方法：
public String(byte[] bytes, String charsetName) 通过指定的字符集解码字节数组
String类的成员方法：
public byte[] getBytes(String charsetName) 使用指定的字符集合把字符串编码为字节数组
编码：把看得懂的变成看不懂的
String --> byte[]
解码：把看不懂的变成看得懂的
byte[] --> String
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 } StringDemo.java
---------------------------------------
(4)IO流中的编码问题
A:OutputStreamWriter字符转换输出流
public OutputStreamWriter(OutputStream os) 默认编码
public OutputStreamWriter(OutputStream os, String charsetName) 指定编码
B:InputStreamReader字符转换输入流
public InputStreamReader(InputStream is) 默认编码
public InputStreamReader(InputStream is, String charsetName) 指定编码
C:编码问题其实很简单
编码解码只要一致即可。
---------------------------------------
(5)字符转换流的5种写数据的方式
OutputStreamWriter类的成员方法：
public void write(int c) 写一个字符
public void write(char[] cbuf) 写一个字符数组
public void write(char[] cbuf, int off, int len) 写一个字符数组的一部分
public void write(String str) 写一个字符串
public void write(String str, int off, int len) 写一个字符串的一部分
(6)字符转换流的2种读数据的方式
InputStreamReader类的成员方法：
public int read() 一次读取一个字符
返回值是下一个数据字符，如果已到文件末尾，则返回-1。
public int read(char[] chs) 一次读取一个字符数组
返回值是实际读取的字符个数，如果已到文件末尾，则返回-1。
---------------------------------------
(7)面试题：
close()和flush()的区别?
A:close()关闭流对象，但是先刷新一次缓冲区。流对象关闭之后，流对象不可以再继续使用了。
B:flush()仅仅是刷新缓冲区，刷新之后，流对象还可以继续使用。
(8)字符转换流(= 字符流 = 转换流) ==> 字符转换简化流 ==> 字符流
字符转换流的简化写法
FileWriter
FileReader
由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。
而字符转换流的名称有点长，所以，为了简化我们的书写，Java就提供了字符转换流的子类供我们使用。
OutputStreamWriter = FileOutputStream + 本地默认编码
||
FileWriter = FileOutputStream + 本地默认编码
InputStreamReader = FileInputStream + 本地默认编码
||
FileReader = FileInputStream + 本地默认编码
(9)字符缓冲区流
字符流为了高效读写，也提供了对应的字符缓冲区流。
BufferedWriter:字符缓冲区输出流
BufferedReader:字符缓冲区输入流
字符缓冲区流的特殊方法：
BufferedWriter类的方法:
public void newLine() 根据系统属性来决定换行符
BufferedReader类的方法:
public String readLine() 一次读取一行数据(字符串)
返回值是：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。
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 } BufferedWriterDemo.java
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 } BufferedReaderDemo.java
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 } BufferedDemo.java
需求：把 当前项目目录下的a.txt内容 复制到 当前项目目录下的b.txt 中 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 // 一次读写一个字符数组
26 char[] chs = new char[1024];
27 int len = 0;
28 while ((len = br.read(chs)) != -1) {
29 bw.write(chs, 0, len);
30 bw.flush();
31 }
32
33 // 释放资源
34 bw.close();
35 br.close();
36 }
37 } 需求：把 当前项目目录下的a.txt内容 复制到 当前项目目录下的b.txt 中
使用字符缓冲区流的特殊读写方法 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 *
14 * 数据源：
15 * a.txt --> 读取数据 --> 字符转换流 --> InputStreamReader --> FileReader --> BufferedReader
16 * 目的地：
17 * b.txt --> 写出数据 --> 字符转换流 --> OutputStreamWriter --> FileWriter --> BufferedWriter
18 */
19 public class CopyFileDemo2 {
20 public static void main(String[] args) throws IOException {
21 // 封装数据源
22 BufferedReader br = new BufferedReader(new FileReader("a.txt"));
23 // 封装目的地
24 BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
25
26 // 读写数据，一次读写一行数据(字符串)(要与newLine()方法配合使用)
27 String line = null;
28 while ((line = br.readLine()) != null) {
29 bw.write(line); // 一次写一行数据(字符串)(要与newLine()方法配合使用)
30 bw.newLine(); // 根据系统属性来决定换行符
31 bw.flush();
32 }
33
34 // 释放资源
35 bw.close();
36 br.close();
37 }
38 } ---------------------------------------
(10)字符流
Reader(抽象类)
|--FilterReader(抽象类:字符过滤输入流)
|--InputStreamReader(字符转换输入流)
|--FileReader(字符转换输入流的简化写法)
|--BufferedReader(字符缓冲区输入流)
Writer(抽象类)
|--FilterWriter(抽象类:字符过滤输出流)
|--OutputStreamWriter(字符转换输出流)
|--FileWriter(字符转换输出流的简化写法)
|--BufferedWriter(字符缓冲区输出流)
-----------------------------------------------------------------------------
2:IO流小结(掌握)
IO流
|--字节流
|--字节输入流
InputStream
int read() 一次读取一个字节
int read(byte[] bys) 一次读取一个字节数组
|--FileInputStream
|--BufferedInputStream
|--字节输出流
OutputStream
void write(int by) 一次写一个字节
void write(byte[] bys, int index, int len) 一次写一个字节数组的一部分
|--FileOutputStream
|--BufferedOutputStream
|--字符流
|--字符输入流
Reader
int read() 一次读取一个字符
int read(char[] chs) 一次读取一个字符数组
|--InputStreamReader
|--FileReader
|--BufferedReader
String readLine() 一次读取一行数据(字符串)
|--字符输出流
Writer
void write(int ch) 一次写一个字符
void write(char[] chs, int index, int len) 一次写一个字符数组的一部分
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
void newLine() 写一个换行符
void write(String line) 一次写一行数据(字符串)(要与newLine()方法配合使用)
-----------------------------------------------------------------------------
3:案例(掌握)
A:复制文本文件(用字符流) 5种方式(掌握)
基本字符流两种
高效字符缓冲区流两种
特殊字符缓冲区流一种
复制文本文件(用字符流和用字节流) 9种方式
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 } 复制文本文件(用字符流) 5种方式
---------------------------------------
B:复制图片/视频/音频(用字节流) 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
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 } 复制图片/视频/音频(用字节流) 4种方式
---------------------------------------
C:把ArrayList集合中的数据存储到文本文件
只有写出数据，没有读取数据。
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 } 把ArrayList集合中的数据存储到文本文件
---------------------------------------
D:从文本文件中读取数据(每一行为一个字符串数据)到ArrayList集合中，并遍历集合
只有读取数据，没有写出数据。
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 } 从文本文件中读取数据(每一行为一个字符串数据)到ArrayList集合中，并遍历集合
---------------------------------------
E:我有一个文本文件中存储了几个名字，请大家写一个程序实现随机获取一个人的名字。
1:把文本文件中的数据存储到集合中
2:随机产生一个索引，并设定索引的范围
3:根据该索引获取一个值
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 } 我有一个文本文件中存储了几个名字，请大家写一个程序实现随机获取一个人的名字
---------------------------------------
F:复制指定单级文件夹中的所有文件(里面只有文件，且文件各种各样)
1:封装数据源File对象+封装目的地File对象
2:获取数据源目录下的所有文件的File数组
3:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
4:把该File进行复制
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 } 复制指定单级文件夹中的所有文件(里面只有文件，且文件各种各样)
---------------------------------------
G:复制指定单级文件夹中的指定的文件，并修改文件后缀名(里面只有文件，且文件各种各样，但是本例题为了增加一点难度，使该单级文件夹中增加一个文件夹名为hello.java的文件夹)
1:封装数据源File对象+封装目的地File对象
2:获取数据源目录下的所有.java文件的File数组(加入了判断条件)
3:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
4:把符合条件的File进行复制
5:获取目的地目录下的所有文件的File数组
6:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示
7:把该File重命名为新名字 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 } 复制指定单级文件夹中的指定的文件，并修改文件后缀名
回顾：批量修改文件名称代码和视频(day19)
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 } 批量修改文件名称代码
---------------------------------------
H:复制多级文件夹
1:封装数据源File对象+封装目的地File对象
2:判断该数据源File对象是文件夹还是文件
a:是文件夹
就在目的地目录下创建该文件夹(创建前先拼接一个新的文件夹路径名的抽象表示)
获取该数据源File对象下的所有文件或者文件夹的File数组
遍历该File数组，得到每一个File对象
回到B(递归)
b:是文件(文件各种各样，用字节流复制)
就在目的地目录下复制该文件(复制前先拼接一个新的文件路径名的抽象表示)
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 } 复制多级文件夹
---------------------------------------
I:键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低存入文本文件。
1:创建学生类
2:创建集合对象(比较器排序:匿名内部类实现)
TreeSet<Student>
3:键盘录入学生信息并存储到集合
4:遍历集合，把数据写到文本文件 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 } Student.java
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 } 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低存入文本文件
回顾：键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低输出到控制台。(day17)
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 } 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低输出到控制台
---------------------------------------
J:已知在s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”，请编写程序读取s.txt文件的数据内容，把读取到的数据排序后写入到ss.txt中。
1:封装数据源File对象
2:读取该File对象的内容，存储到一个字符串中
3:把字符串转换为字符数组
4:对字符数组进行排序(使用数组工具类的排序方法)
5:把排序后的字符数组转换为字符串(通过字符串的构造方法实现)
6:封装目的地File对象
7:通过该File对象把字符串写入到ss.txt中
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 } 已知在s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”，请编写程序读取s.txt文件的数据内容，把读取到的数据排序后写入到ss.txt中
---------------------------------------
K:用Reader来模拟BufferedReader的特有功能readLine()
注意：测试MyBufferedReader的时候，你就把它当作BufferedReader一样来使用就好。
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 } MyBufferedReader.java
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 } MyBufferedReaderDemo.java
---------------------------------------
L:用自定义类来模拟LineNumberReader的特有功能getLineNumber()和setLineNumber()
LineNumberReader类的特有功能：
public int getLineNumber() 获取当前行号
public void setLineNumber(int lineNumber) 设置当前行号
一般来说，如果某个类里面有getXxx()和SetXxx()方法，那么该类的成员变量一定有个Xxx的成员变量。
方式一：
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 } MyLineNumberReader.java
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 } MyLineNumberReaderTest.java
方式二：
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 } MyLineNumberReader2.java
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 } MyLineNumberReaderTest2.java
============================================================================= 我的GitHub地址：
https://github.com/heizemingjun我的博客园地址：
http://www.cnblogs.com/chenmingjun我的蚂蚁笔记博客地址：
http://blog.leanote.com/chenmingjunCopyright ©2018 黑泽明军
【转载文章务必保留出处和署名，谢谢！】