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

  1. 云栖社区>
  2. 博客>
  3. 正文

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

黑泽明军 2018-03-31 23:44:00 浏览594
展开阅读全文

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() 一次读取一个字符
                返回值是下一个数据字符,如果已到文件末尾,则返回-1public 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 }
Student.java
 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 }
MyBufferedReader.java
 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/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名,谢谢!】

网友评论

登录后评论
0/500
评论
黑泽明军
+ 关注