1 //java基础视频教程第18天-06-IO流(概述)
2 /*
3 这节课主要讲解了IO流的概述，IO流说白了就是处理计算机数据的，一个输入InputStream,一个输出OutputStream
4 java中对数据流的操作都在IO包中
5 按照数据流的类型分为：字符流和字节流，字符流是专门处理文字的，它是基于字节流的，它可以由你来指定编码表
6 按照流向分为：输出流和输入流
7
8 字节流有两个抽象基类：InputStream,OutputStream
9 字符流有两个抽象基类：Reader,Writer
10
11 字节流和字符流的子类都是以父类的名字作为后缀的
12 */
1 //java基础视频教程第18天-07-IO流(FileWriter)
2 /*
3 本节课主要讲解字符流中的FileWriter(用于写入字符的便捷类),它是OutputStreamWriter的子类，而OutputStreamWriter是Wirter的一个子类，而Wirter是一个抽象类，并且它的构造方法受保护，只有子类可以访问（为什么？？？？）其中大部分的方法都是write和append另外还有close和flush
4 IO流操作的主要就是数据，数据一般都是文件，这里就以操作文件为例子，
5 FileWriter的构造方法都必须要有文件传入,并且会抛异常，另外注意一点Write中的方法都抛了IO异常，
Write类有很多write方法，传入的参数有单个字符，字符串，字符数组的一部分，字符数组，以及字符串的某一部分
6 */
7 import java.io.*; //IO流必须导入这个包
8 class FileWriterDemo
9 {
10 public static void main(String[] args) throws IOException //由于FileWrite类中的构造方法FileWrite都抛了IO异常（真心不明白这种结构），为什么抛异常，因为当你传入的文件有可能地址错误，也有可能不能创建这样的文件名就需要抛异常
11 {
12 FileWriter fw = new FileWriter("Demo.txt"); //FileWrite的构造方法必须传入文件，否则出错，这里传入的文件如果不存在将自动建立到指定的目录下，如果文件存在将会覆盖文件内容，其实这里就是明确存放飞位置
13 fw.write("哈哈哈！"); //继承父类Write的方法，将字符串写到流中
14 fw.flush(); //上面的write方法只是将数据写入到内存中，就是写入到流中，需要刷新流，将流数据写入到指定的文件中去
15 fw.write("呵呵呵！"); //流一直存在，一直可以写入数据
16 fw.flush(); //每次都要刷新流才能将数据写入到指定的文件中去
17 fw.write("嘿嘿嘿！"); //java只是调用windows底层系统资源来完成创建文件写入数据，这个就是流资源，所以用完资源后要关闭流
18 fw.close(); //close就是关闭流资源，在关闭之前它也会刷新流中的数据，将数据传递到指定文件中去，之后再也不能写入流文件了
19 //fw.write("执行不到了！"); 这句就会抛出异常，因为流已经被关闭了，不能写入流了，
20 //fw.flush(); Writer类中close和flush的区别在于，前者刷新流之后会关闭流之后就不能继续写数据了，后者刷新流之后不会关闭流，还可以继续写数据
21 }
22 }
1 //java基础视频教程第18天-08-IO流（IO异常处理方式）
2 /*
3 本节课主要讲解了IO流中如何处理IO流的异常
4 凡是涉及到IO流的代码都有会抛异常，无论读还是写。
5 这节课主要以写入流为例子
6
7 写入流的三个步骤都要抛IO异常，这里就
8 */
9 import java.io.*;
10 class FileWriterException
11 {
12 public static void main(String[] args)
13 {
14 FileWriter fw =null; //在try外建立引用，在try内进行初始化，这样fw才可以作用于整个函数
15 try //你要知道为什么在一个try里面同时处理FileWriter和write的异常，因为这两个异常时右关联的，一旦创建文件失败也就不会处理写入数据的操作了，所以这里没有单独try这两个异常而是放在一起try
16 {
17 fw = new FileWriter("Demo.txt"); //调用系统资源创建文件，当初始化抛异常，对象没有建立成功fw还是为null，所以finally中必须判断fw是否为null
18 fw.write("哈哈哈,笨蛋！八格牙路"); //IOException - 如果发生 I/O 错误
19 }
20 catch (IOException e) //IOException - 如果指定文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它 //fw = new FileWriter("K:\\Demo.txt")这个K盘不存在就会出异常FileNotFoundException,它是IOException的一个子类，还要注意一点
windows中的盘符是\\
21 {
22 System.out.println(e.toString());
23 }
24 finally
25 {
26 //if(fw!=null) //也可以放这里
27 try //close()方法也要抛异常，所以也要try
28 {
29 if(fw!=null) //这里是为了防止new FileWriter("K:\\Demo.txt")没有建立成功，当没建立成功fw就会执行null，如果没有这个条件就会有空指针异常null.close(),如果没有if(fw!=null)则会抛异常
30 fw.close(); //这里关闭流必须处理，不论上面是否抛异常，所以必须单独放在fianlly里面try，不能放在上面的那个try里面，如果放在上面那个try里面，但write抛异常了close就执行不到，流资源没有被关闭，还要注意一点，如果开启多个流，关闭流时每个关闭都必须单独try
31 }
32 catch (IOException e)
33 {
34 System.out.println(e.toString());
35 }
36
37 }
38 }
39 }
40
1 //java基础视频教程第18天-09-IO流(文件的续写)
2 /*
3 这节课主要讲解了public FileWriter(File file,boolean append)throws IOException,当boolean是true的时候就不会覆盖原有文件，只会在原有文件的结尾处继续添加数据
4 */
5 import java.io.*;
6 class FileWriterAgain
7 {
8 public static void main(String[] args)
9 {
10 FileWriter fw =null;
11 try
12 {
13 fw = new FileWriter("Demo.txt",true); //文件是字符串,传递一个true代表不覆盖，继续在文件的尾部添加数据
14 fw.write("死啦死啦的！\r\n大日本帝国花姑娘大大的有。"); //在window中换行为\r\n,在lunix中换行为\n
15 }
16 catch (IOException e)
17 {
18 System.out.println(e.toString());
19 }
20 finally
21 {
22 if(fw!=null)
23 try
24 {
25
26 fw.close();
27 }
28 catch (IOException e)
29 {
30 System.out.println(e.toString());
31 }
32 }
33 }
34 }
1 //java基础视频教程第18天-10-IO流（文本文件读取方式一）
2 /*
3 本节课主要讲解了Reader中第一种读取方式read(),返回单个字符，Reader->InputStreamReader中的FileReader,FileReader构造方法也必须传入需要读取的文件参数，并且设计到IO流的方法都需要抛异常
4 public int read()throws IOException，读取单个字符，返回int类型，范围在0-65535，需要转换，当文件中没有可读文件时则返回-1
5
6
7 */
8 import java.io.*;
9 class FileReaderDemo
10 {
11 public static void main(String[] args) throws IOException //这里简单处理了异常
12 {
13 FileReader fr = new FileReader("Demo.txt"); //读取的时候有默认的字符编码GBK
14 /*
15 int ch = fr.read(); //Reader中的方法，读取单个字符，注意，read返回的是一个int类型，需要转换
16 System.out.println(ch); //这个ch范围在0-65535，如果读取文件完毕，没有读的字符了就返回-1，所以可以用循环打印出所有的字符
17 System.out.println((char)ch); //把int字符转换成char
18 int ch1 =fr.read();
19 System.out.println((char)ch1);
20 */
21
22 /*
23 //第一种循环方式
24 while(true)
25 {
26 int ch=fr.read();
27 if(ch==-1)
28 break; //注意这种循环写法，利用break退出
29 System.out.println((char)ch);
30 }
31 */
32 //第二种循环方式
33 int ch =0; //问题：把初始化写在while里面是错误码？？？
34 //while((int ch =fr.read())!=-1) //这种写法错误，理由是while内定义变量，每一循环都会重新在内存中定义一个len，而len本身已经存在，所以出错。
35 while ((ch =fr.read())!=-1) //处理这点问题的关键之处
36 {
37 System.out.println((char)ch);
38 }
39 fr.close(); //也是Reader中方法，关闭流资源，不会刷新流
40
41 }
42 }
1 //java基础视频教程第18天-11-IO流（文本文件读取第二种方式）
2 /*
3 这节课主要讲解了读取文本文件的第二种方式，其中用到的方法如下
4 第一个方法就是Reader中public int read(char[] cbuf)throws IOException,这个read里面传了一个字符数组，read会将读取到的字符存到字符数组中，并且返回的是读取到字符的个数
5 第二个方法就是用到String类中的构造方法String(char[] arr)和String(char[] arr,int offset,int count),这两个方法作用是把字符数组转换成字符串，其中offset是从第几个位置开始，count表示取多少个字符
6 */
7 import java.io.*;
8 class FileReaderDemo1
9 {
10 public static void main(String[] args) throws IOException //简单的抛一下异常，就不在内部写详细的异常处理了
11 {
12
13 FileReader fr = new FileReader("Test.txt"); //假定Test.txt文件中的内容为1234567
14 /*
15 char[] arr = new char[3]; //建立一个数组存放读取到的字符，数组大小不定，先规定为3
16 int num = fr.read(arr); //返回的是读取到的字符个数
17
18 System.out.println(num+"----"+new String(arr)); //第一次打印arr数组中三个字符分别是1，2，3，返回num为3
19
20 int num2 = fr.read(arr);
21 System.out.println(num2+"----"+new String(arr)); //第二次打印arr数组中三个字符分别是4，5，6，返回num为3
22
23 int num3 = fr.read(arr);
24 //System.out.println(num3+"----"+new String(arr)); //第三次打印arr数组中三个字符分别是7，5，6，返回num为1，此处只读到了一个数字，所以arr数组中只覆盖了上一次数组中的第一个位置4，数组后两位没有覆盖，任然是5,6
25 System.out.println(num3+"----"+new String(arr,0,num3)); //此处为了打印出文件Test中结尾的那个字符，就用到String(char[] arr,int offset,int count),这里取返回读取到的字符个数num3,还要注意一点这里的起始位是从0开始的
26
27 int num4 = fr.read(arr);
28 System.out.println(num4+"----"+new String(arr)); //这里文件其实已经没有字符读取了，所以返回的num4为-1,更具这点，就可以通过循环来读取
29
30 fr.close(); //最后必须关闭流资源
31 */
32
33 //第一种循环
34 /*
35 char[] arr = new char[1024]; //一般设置长度为1024
36 int num =0;
37 while((num=fr.read(arr))!=-1)
38 {
39 System.out.println(num+"----"+new String(arr,0,num));
40 }
41 fr.close();
42 */
43 //第二种循环
44 char[] arr = new char[1024];
45 while(true)
46 {
47 int num =fr.read(arr);
48 if(num==-1)
49 break;
50 System.out.println(num+"----"+new String(arr,0,num));
51 }
52 fr.close();
53 }
54 }
1 //java基础视频教程第18天-12-IO流(文本文件读取练习)
2 /*
3 本节课主要练习了读取字符流，是对上一节课的巩固
4 要求：读取一个.java文件，并打印在控制台上
5 */
6 import java.io.*;
7 class FileReaderTest
8 {
9 public static void main(String[] args) throws IOException
10 {
11 FileReader fr = new FileReader("FileWriterAgain.java");
12 char[] arr = new char[1024];
13 int num =0;
14 while((num=fr.read(arr))!=-1)
15 {
16 System.out.print(new String(arr,0,num)); //这里print没有加ln是为了避免数据
17 }
18 fr.close();
19 }
20 }
1 //java基础视频教程第18天-13-IO流(拷贝文本文件)
2 /*
3 重点章节
4 这节课主要讲解了两种方法复制文件
5 要求：将c盘中的文本文件复制到d盘中去
6 步骤：
7 1.确定读取的文件地址和存储文件地址
8 2.复制并存储（两种方法）
9 3.关闭流资源（两种方法）
10
11
12 */
13 import java.io.*;
14 class CopyTest
15 {
16 public static void main(String[] args) throws IOException //第一种方法简单抛异常
17 {
18 Copy1();
19 Copy2();
20 }
21 //方式一：单个单个字符存储
22 public static void Copy1() throws IOException //简单抛异常
23 {
24 FileReader fr = new FileReader("C:\\shool.sql");
25 FileWriter fw = new FileWriter("D:\\java\\shool.txt");
26
27 int num =0;
28 while((num=fr.read())!=-1)
29 {
30 fw.write((char)num); //如何解决编码的问题
31 fw.flush(); //不要忘记刷新数据流
32 }
33 fr.close();
34 fw.close();
35
36 }
37 //方式二：先把整个字符写入到内存中，然后再存入指定文件
38 public static void Copy2()
39 {
40 FileReader fr=null;
41 FileWriter fw=null; //在外部声明finally中的fr,fw才能访问close方法
42 try
43 {
44 fr = new FileReader("C:\\AppServ\\www\\Basic14\\1.php");
45 fw = new FileWriter("D:\\java\\l.txt");
46 char arr[] = new char[1024];
47 int len=0;
48 while((len=fr.read(arr))!=-1) //read(char arr),会将字符读取到字符数组中，并且返回读取字符的个数
49 {
50 fw.write(arr,0,len); //运用到这个方法public abstract void write(char[] cbuf,int off,int len)throws IOException
51 fw.flush(); //需要刷新流吗？？？？？？？？？？？？？？？？？
52 }
53
54 }
55 catch (IOException e) //如果此处真的抛异常的话，说明文件读取失败，所以下面用RuntimeException
56 {
57 throw new RuntimeException("读取失败！");
58 }
59 //第一种关闭流的方法
60
61 finally
62 {
63 if(fr!=null) //防止读取数据抛异常，fr仍然为null而出现控制针异常
64 try
65 {
66 //if(fr!=null) //if条件可以放这里吗？？？？？？？？？？？？？？
67 fr.close();
68 }
69 catch (IOException e)
70 {
71 }
72
73 if(fr!=null) //防止写入数据抛异常，fr仍然为null而出现控制针异常
74 try //也可以单独关闭
75 {
76 //if(fr!=null) //if条件可以放这里吗？？？？？？？？？？？？？？
77 fw.close();
78 }
79 catch (IOException e)
80 {
81 }
82 }
83 //第二种关闭流的方法
84 /*
85 finally
86 {
87 //if(fr!=null) 我可以把if放这里吗？？？？？？？？？？？？？？？？
88 try
89 {
90 if(fr!=null)
91 fr.close();
92 }
93 catch (IOException e)
94 {
95 }
96 finally
97 {
98 if(fw!=null)
99 try
100 {
101 fw.close();
102 }
103 catch (IOException e)
104 {
105 }
106 }
107 }
108 */
109 }
110 }
1 //java基础视频教程第18天-14-IO流(拷贝文本文件图例)
2 /*
3 这节课主要讲解从硬盘c盘复制一个文件到d盘的图例说明
4 流程如下：
5 1.第一步先在硬盘c中读取到需要复制的文件到流中FileReader fr = new FileReader(xxx.txt)
6 2.第二步把流中的数据存入到内存中的数组中，fr.read(char[])
7 3.第三步将内存中的数据写入到流中fw.write(char [])，FileWriter fw = new FileWriter(xxx.txt)
8 4.将流中的数据刷新到d盘中去fw.flush()或者fw.close()
9
10 注意一点：FileReader fr = new FileReader(xxx.txt)，FileWriter fw = new FileWriter(xxx.txt)其实是在调用系统底层资源
11
12 */
1 //java基础视频教程第19天-01-IO流(BufferedWriter)
2 /*
3 本节课主要讲解了Writer的子类BufferedWriter类，BufferedWriter的构造方法都要放入流对象,BufferedWriter是Write的子类，
4 拥有Write的所有方法，而且它有一个新的方法newLine()，它相当于一个跨平台的换行fw.("\r\n");,并且它的关闭方法close就是相当于关闭流资源
5 这是一个缓冲区，它的存在是为了让流读写更加高效，
6 */
7 import java.io.*;
8 class BufferedWriterDemo
9 {
10 public static void main(String[] args) throws IOException //凡是涉及到流的程序都别忘记抛异常
11 {
12 /*
13 FileWriter fw = new FileWriter("Test.txt"); //建立流对象
14 BufferedWriter bw = new BufferedWriter(fw); //建立缓冲对象，并把流对象传给它
15 bw.write("abcd"); //由于BufferedWriter是Writer的子类，所以它也具有Wirte的方法writer，close等方法
16 bw.close(); //这里就相当于fw.close();注意哈，缓冲区关闭就是关闭的流资源
17 */
18
19 FileWriter fw = new FileWriter("Test.txt");
20 BufferedWriter bw = new BufferedWriter(fw);
21 for (int x=0;x<5;x++)
22 {
23 bw.write("abcd"+x);
24 bw.newLine(); //这个是跨平台的fw.write("\r\n");
25 bw.flush();
26 }
27 bw.close();
28 }
29 }
1 //java基础视频教程第19天-02-IO流(BufferedReader)
2 /*
3 本节课主要讲解了Reader的子类BufferedReader缓冲区读取，它有一个方法是读取一行readLine();
4 注意一点，返回的是字符串，没有返回换行符，如果没有可读的字符了则返回null
5 */
6 import java.io.*;
7 class BufferedReaderDemo
8 {
9 public static void main(String[] args) throws IOException
10 {
11 /*
12 FileReader fr = new FileReader("Test.txt");
13 BufferedReader br = new BufferedReader(fr); //缓冲区读取也需要传入流对象
14 String s = br.readLine(); //BufferedReader是Reader的一个子类，不但有Reader的方法，而且有readLine读取一行，返回的是字符串，并且没有返回换行符,当没有字符可以读就返回null,这点就可以作为循环条件了
15 System.out.println(s);
16 br.close(); //缓冲区关闭就相当于关闭流资源fr.close();
17 */
18 FileReader fr = new FileReader("Test.txt");
19 BufferedReader br = new BufferedReader(fr);
20 String s = null;
21 while((s=br.readLine())!=null) //注意readLine返回包含该行内容的字符串，不包含任何行终止符，如果已达到流末尾，则返回null
22 {
23 System.out.println(s);
24 }
25 br.close();
26 }
27 }
1 //java基础视频教程第19天-03-IO流(通过缓冲区复制文本文件)
2 /*
3 本节课主要讲解了通过字符流的缓冲区复制文件,这个程序写了异常处理
4 */
5 import java.io.*;
6 class CopyTextByBuf
7 {
8 public static void main(String[] args)
9 {
10 BufferedReader br= null; //此处不写FileReader,会在下面直接传递
11 BufferedWriter bw= null; //此处不写FileWriter，会在下面直接传递
12 try
13 {
14 br = new BufferedReader(new FileReader("CopyTextByBuf.java"));
15 bw = new BufferedWriter(new FileWriter("CopyTextByBuf.txt"));
16 String s = null; //中间量中转站，读去和写入通过一个内存中的一个String来传递数据
17 while((s =br.readLine())!=null)
18 {
19 bw.write(s); //继承于Writer的方法
20 bw.newLine(); //br.readLine()只是返回了String，而没有返回换行，所以bw中才会有独立的换行方法newLine
21 bw.flush();
22 }
23 }
24 catch (IOException e)
25 {
26 throw new RuntimeException("读写失败");
27 }
28 finally
29 {
30 try
31 {
32 if(br!=null)
33 br.close();
34 }
35 catch (IOException e)
36 {
37 throw new RuntimeException("读取关闭失败");
38 }
39 try
40 {
41 if(bw!=null)
42 bw.close();
43 }
44 catch (IOException e)
45 {
46 throw new RuntimeException("写入关闭失败");
47 }
48 }
49 }
50 }
1 //java基础视频教程第19天-04-IO流(readLine的原理)
2 /*
3 本节课主要讲解了readLine方法如何确保了读取一行的原理，它的内部结构其实有一个数组，原理还是read方法，读一个字符存一个字符
4 它判断一行的原理是\r\n，当遇到\r就继续向下读取，当读到\n就会把之前的数据存到数组中去。
5 注意：readLine之所以比read高效是因为readLine将读取的数据都装到数组中，但遇到回车(\r\n)时才一次性把数据返回，而read()是读取一个字符返回一个字符对应的Unicode码
7 效率相对低下，而read(arr),它是将字符一个一个的读取到数组中返回的是读取到字符的个数，如果达到流的末尾就返回-1，而且它要打印字符还要通过new String（）方法，在循环中8 每次都要new String(),所以效率也低下，这就是BufferedReader的高效所在
6 */
1 //java基础视频教程第19天-05-IO流(MyBufferedReader)
2 /*
3 本节课主要讲解了模拟BufferedReader的功能,主要模拟它的readLine方法，深入理解read()和StringBuilder()方法
4 它的功能其实就是调用的Reader中的read方法，将字符一个存入数组，最后将数组以字符串的形式返回
5 换行是的原理是当读取到\r时继续读下一个字符，当读到\n时就返回字符串，当没有可读的字符时返回null
6 */
7 import java.io.*;
8 class MyBufReader
9 {
10 private FileReader fr;
11 MyBufReader(FileReader fr) //构造方法传入FileReader,因为BufferedReader需要运用到流文件
12 {
13 this.fr=fr;
14 }
15 public String MyReadLine() throws IOException //用到了IO流都需要抛异常，谁调用谁处理
16 {
17 StringBuilder sb = new StringBuilder(); //这里用StringBuilder来代替数组装读到的字符
18 int num = 0;
19 while((num=fr.read())!=-1) //read返回的是int
20 {
21 if(num==(int)'\r') //当遇到\r就继续读取下一个字符,此处注意是单引号，不是双引号，其实转换可以自动转换的，不需强制转换
22 continue;
23 if(num==(int)'\n') //当读取到\n就返回sb中的字符串
24 return sb.toString();
25 else
26 sb.append((char)num);
27 }
28
29 /*
30 if(sb.toString().length()!=0) //防止结尾处没有\r\n，但实际上已经把数据存入了BufferedBuilder,并没有返回
31 {
32 return sb.toString();
33 }
34 */
35 if(sb.length()!=0) //也可以用这种方法代替上面，防止结尾处没有\r\n
36 {
37 return sb.toString();
38 }
39 return null; //没有字符可以读取了就返回null
40 }
41 public void Myclose()throws IOException //readLine有close方法，MyReadLine也有单独的关闭方法简单抛异常，谁调用谁处理
42 {
43 fr.close();
44 }
45
46 }
47 class MyBufferedReader
48 {
49 public static void main(String[] args) throws IOException //调用了抛异常的类方法，也的处理异常
50 {
51 FileReader fr = new FileReader("Demo.txt");
52 MyBufReader mbr = new MyBufReader(fr);
53 String line = null;
54 while((line=mbr.MyReadLine())!=null)
55 {
56 System.out.println(line);
57 }
58 mbr.Myclose();
59 }
60 }
1 //java基础视频教程第19天-06-IO流（装饰设计模式）
2 /*
3 这节课主要讲解了什么是装饰设计模式，并用一个人吃饭的简单例子来阐述装饰设计模式
4 所谓装饰设计模式是指本来一个类中有一个方法，但是这个方法不够强大，
5 这时就新建一个类，然后在构造方法里传入第一个类的引用，在第一个类的基础上加强原有的方法
6
7 例如：FileReader中有read方法，而BufferedReader中有readLine方法，当用BufferedReader时就传入了FileReader的引用，readLine就是对read的装饰增强
8 */
9 class Person
10 {
11 public void chifan()
12 {
13 System.out.println("吃饭"); //原有方法
14 }
15 }
16 class SuperPerson
17 {
18 Person p;
19 SuperPerson(Person p)
20 {
21 this.p = p;
22 }
23 public void chifan()
24 {
25 System.out.println("开胃酒"); //增强原有方法
26 p.chifan();
27 System.out.println("甜点"); //增强原有方法
28 System.out.println("来一根"); //增强原有方法
29 }
30 }
31 class PersonDemo
32 {
33 public static void main(String[] args)
34 {
35 Person p = new Person();
36 //p.chifan();
37 SuperPerson sp = new SuperPerson(p);
38 sp.chifan();
39 }
40 }
1 //java基础视频教程第19天-07-IO流（装饰和继承的区别）
2 //听到这些课时感觉好难接受，人要接受一样思想需要时间和理解，我学到此时感觉好难受，思想，思想，总结，总结
3 /*
4 这节课主要讲解了装饰和继承的区别：流程是讲解从继承到装饰的发展过程
5 装饰模式比继承更加灵活，避免了继承体系的臃肿，降低了类与类之间的关系，从继承结构转变成了组合结构
6
7 装饰类因为增强已有对象，具备的功能和已有的功能时相同的，只不过提供了更强功能
8 所以装饰类和被装饰类通常都是属于一个体系中的
9 主要以伪例子来说明装饰和继承的区别
10 MyReader()
11 |--MyTxtReader()
12 |--MyBufferedTxtReader(); //继承方式加强父类
13 |--MyMaediaReader()
14 |--MyBufferedMediaReader(); //继承方式加强父类
15 |--MyDataReader()
16 |--MyBufferedDataReader(); //继承方式加强父类
17
18 上面这种体系有重复，可以抽取共性，把每个类的缓冲类抽取出来组成一个新的类，于是就有了下面的类
19
20 class MyBufferedReader
21 {
22 MyBufferedReader(MyTxtReader text) //构造的时候我只要传入需要加强的类，这样相对于继承而已提高及代码的灵活性，需要加强那个就传那个，减少了继承的臃肿性
23 {
24
25 }
26 MyBufferedReader(MyMediaReader media)
27 {
28
29 }
30 MyBufferedReader(MyDataReader Data)
31 {
32
33 }
34 }
35 上面的类还可以进一步通过多态来简化代码
36 class MyBufferedReader extends MyReader //MyBufferedReader本生功能就是为MyReader子类的增强的，现在分离出来成为MyReader的一个子类
37 {
38 MyBufferedReader(MyReader r)
39 {
40
41 }
42 }
43
44 设计模式是为优化而存在的，于是从上面的过程，体系也发生了变化
45 MyReader()
46 |--MyTextReader()
47 |--MyMadieReader()
48 |--MyDataReader()
49 |--MyBufferedReader() 体系的转变，从继承转变成修饰类
50
51 装饰模式比继承更加灵活，避免了继承体系的臃肿，降低了类与类之间的关系，从继承结构转变成了组合结构
52
53 装饰类因为增强已有对象，具备的功能和已有的功能时相同的，只不过提供了更强功能
54 所以装饰类和被装饰类通常都是属于一个体系中的
55 */
1 //java继承视频教程第19天-08-IO流（自定义装饰类）
2 /*
3 自定义装饰类
4
5 */
6 import java.io.*;
7 class MyBufReader extends Reader //继承Reader成为它的子类，成为一个自定义装饰类的前提条件，继承了它需要实现它的抽象方法，Reader中有连个抽象方法，close()和read(char[] cbuf,int off,int len)
8 {
9 Reader fr; //把FileReader改为Reader，运用了多态形式，提高了代码的复用性
10 MyBufReader(Reader fr)
11 {
12 this.fr=fr;
13 }
14 public String myReaderLine() throws IOException
15 {
16 StringBuilder sb = new StringBuilder();
17 int num=0;
18 while((num=fr.read())!=-1)
19 {
20 if(num=='\r')
21 continue;
22 if(num=='\n')
23 return sb.toString();
24 else
25 sb.append((char)num);
26 }
27 if(sb.length()!=0)
28 return sb.toString();
29 return null;
30 }
31 public void close() throws IOException //继承了Reader需要重写Reader中的抽象方法
32 {
33 fr.close();
34 }
35 public int read(char[] cbuf,int off,int len) throws IOException //这个方法不知道如何复写 //继承了Reader需要重写Reader中的抽象方法
36 {
37 return fr.read(cbuf,off,len); //此处用了Reader子类的方法，因为不知道如何写这个方法，所以用了传入的子类的这个方法
38 }
39 public void Myclose() throws IOException //自定义的关闭方法
40 {
41 fr.close();
42 }
43 }
44 class MyBufferedReader1
45 {
46 public static void main(String[] args) throws IOException
47 {
48 FileReader fr = new FileReader("Demo.txt");
49 MyBufReader mbr = new MyBufReader(fr);
50 String line=null;
51 while((line=mbr.myReaderLine())!=null)
52 {
53 System.out.println(line);
54 }
55 mbr.Myclose();
56 }
57 }
1 //java基础视频教程第19天-09-IO流（LineNumberReader）
2 /*
3 主要讲解了BufferedReader下的一个子类LineNumberReader,它也是一个包装类（修饰类）,
4 它有两个新的方法，在BufferedReader的基础上加强了功能
5 public void setLineNumber(int lineNumber) 设置行号
6 public int getLineNumber() 获取行号
7 包装类主要就是对已有的类的功能强化
8 */
9 import java.io.*;
10 class LineNumberReaderDemo
11 {
12 public static void main(String[] args) throws IOException
13 {
14 FileReader fr = new FileReader("LineNumberReaderDemo.java");
15 LineNumberReader lnr = new LineNumberReader(fr); //代替了BufferedReader，加强了它，有了行号的功能
16 lnr.setLineNumber(100); //设置行号重100开始，默认是从0开始的
17 String line =null;
18 while((line=lnr.readLine())!=null)
19 {
20 System.out.println(lnr.getLineNumber()+line); //LineNumberReader中的获取行号的功能
21 }
22 lnr.close();
23
24 }
25 }
1 //java基础视频教程第19天-10-IO流(MyLineNumberReader)
2 /*
3 这节课主要讲解了LineNumberReader的原理，它是一个装饰类，加强BufferedReader,并且BufferedReader也是一个装饰类，这里通过MyLineNuberReader方法来阐述它的原理，其实内部有一个计数器
4 通过读取一行就自增一次
5
6 另外一点是把重复的类容同父类中的方法代替了，简化了代码
7 */
8 import java.io.*;
9 /*
10 class MyLineNumberReader
11 {
12 private int LineNumber;
13 private Reader r;
14 MyLineNumberReader(Reader r)
15 {
16 this.r=r;
17 }
18 public void setLineNumber(int LineNumber)
19 {
20 this.LineNumber = LineNumber;
21 }
22 public int getLineNumber()
23 {
24 return LineNumber;
25 }
26
27 public String MyReadLine()throws IOException
28 {
29 LineNumber++; //在调用readLine方法的时候LineNumber就要自增一次
30
31 StringBuilder sb = new StringBuilder();
32 int num =0;
33 while((num=r.read())!=-1)
34 {
35 if(num=='\r')
36 continue;
37 if(num=='\n')
38 return sb.toString();
39 else
40 sb.append((char)num);
41 }
42 if(sb.length()!=0)
43 return sb.toString();
44 return null;
45 }
46 public void Myclose()throws IOException
47 {
48 r.close();
49 }
50 }
51 */
52 class MyLineNumberReader extends MyBufreader //继承这个类，调用父类相同的方法
53 {
54 private int LineNumber;
55 //private Reader r;
56 MyLineNumberReader(Reader r)
57 {
58 //this.r=r;
59 super(r);
60 }
61 public void setLineNumber(int LineNumber)
62 {
63 this.LineNumber = LineNumber;
64 }
65 public int getLineNumber()
66 {
67 return LineNumber;
68 }
69
70 public String MyReadLine()throws IOException //LineNumberReader之所以要复写BufferedReader中的readLine()方法，而没有继承是应为它内部有一自加器LineNumber++
71 {
72 LineNumber++; //这里自加一次是根据调用调用一次MyReaderLine就自加一次
73 /*
74 StringBuilder sb = new StringBuilder();
75 int num =0;
76 while((num=r.read())!=-1)
77 {
78 if(num=='\r')
79 continue;
80 if(num=='\n')
81 return sb.toString();
82 else
83 sb.append((char)num);
84 }
85 if(sb.length()!=0)
86 return sb.toString();
87 return null;
88 */
89 return super.myReaderLine();
90 }
91
92 /*
93 public void Myclose()throws IOException //子类继承了父类的关闭方法，所以不用写
94 {
95 r.close();
96 }
97 */
98
99
100
101 }
102
103 class MyLineNumberReaderDemo
104 {
105 public static void main(String[] args) throws IOException
106 {
107 FileReader fr = new FileReader("MyLineNumberReaderDemo.java");
108 MyLineNumberReader mlnr = new MyLineNumberReader(fr);
109 mlnr.setLineNumber(100); //调用设置行号的方法，设置行号从100开始
110 String line = null;
111 while((line=mlnr.MyReadLine())!=null)
112 {
113 System.out.println(mlnr.getLineNumber()+line); //获取行号
114 }
115 mlnr.Myclose();
116
117 }
118 }
1 //java基础视频教程第19天-11-IO流(字节流file读取操作)
2 /*
3 本节课主要讲解了字节流的写入FileOutPutStream,它没有flush就可以写入数据的理由,并且它的write方法传入的是字节数组而非像字符流那样传入的的是字符数组，另外还要注意一点把字符串转换成字节数组的方法是getBytes(),把字符串转换成字符数组的方法是toCharArray()
4 字节流的读入FileInputStream,它有一个新的方法available()可以获取文件字节流的个数,从而可以精确的知道需要传入的字节数组需要传入多少个字节数，但最后还是不建议用这样的方法，因为虚拟机分配的空间只有64M的大小，当你要复制一个超过64M大小的文件则会内存溢出
注意：字符流中的read和write方法传的参数都是字符数组，而字节流中的read和write方法传的参数都是字节数组
5 */
6 import java.io.*;
7 class FileStream
8 {
9 public static void main(String[] args) throws IOException
10 {
11 fileWrite();
12 fileRead();
13 fileRead1();
14 fileRead2();
15 }
16 public static void fileWrite()throws IOException //写入文件
17 {
18 FileOutputStream fos = new FileOutputStream("fos.txt");
19
20 fos.write("abcde".getBytes()); //字节流的的写入方法必须放字节或者字节数组，String有个方法可以把字节转变为字节数组
21 fos.close(); //字节流的写入没有flush方法，不需要刷新就可以把数据写入文件中是因为，字节流不像字符流那样，
22 //一个字符由两个字节组成的，当写入文件时，需要先把两个字符读入缓存中，然后去查找对应的字符表，然后刷新才能写入文件中,而字节流完全不需要查表什么的，所以直接就可以写入文件中
23
24 }
25 public static void fileRead()throws IOException
26 {
27 FileInputStream fis = new FileInputStream("fos.txt");
28 //System.out.println(fis.read()); //read()返回的还是int数字，需要转换成字符
29
30 int num =0;
31 while((num=fis.read())!=-1) //单个单个的读取字节
32 {
33 System.out.println((char)num);
34 }
35
36 fis.close();
37
38 }
39 public static void fileRead1() throws IOException
40 {
41 FileInputStream fis = new FileInputStream("fos.txt");
42 byte[] arr = new byte[1024];
43 int len =0;
44 while((len=fis.read(arr))!=-1)
45 {
46 System.out.println(new String(arr,0,len));
47 }
48 fis.close();
49
50 }
51 public static void fileRead2() throws IOException
52 {
53 FileInputStream fis = new FileInputStream("fos.txt");
54 //System.out.println(fis.available()); //读取到的是字节的个数
55 byte[] arr = new byte[fis.available()]; //注意：这种方法只有在文件小的时候可以用，文件大了还是以上面的数组为准，因为虚拟机的分配的空间大小是固定的，当你需要读入的文件大于虚拟机的分配空间则会出现内存溢出的情况。
56 int len=0;
57 while((len=fis.read(arr))!=-1)
58 {
59 System.out.println(new String(arr)); //数组有了精确的个数就不用new String(arr,0,len);
60 }
61 }
62 }
1 //java基础视频教程第19天-12-IO流（拷贝图片）
2 /*
3 本节课主要讲解了如何通过字节流拷贝一个图片，并且用到了处理异常的方式
4 遭了，我写成了复制音乐了，算了就这样吧
5 这里还说明一点：不要拿字符流去复制媒体文件，否则容易出现打不开的情况（为什么呢？？？？？？）
6 */
7 import java.io.*;
8 class CopyImage
9 {
10 public static void main(String[] args)
11 {
12 FileInputStream fis=null;
13 FileOutputStream fos=null;
14 try
15 {
16 fis=new FileInputStream("D:\\TTPmusic\\Two Steps From Hell\\Two Steps From Hell - Down.mp3");
17 fos=new FileOutputStream("Down.mp3");
18 byte[] arr = new byte[1024];
19 int len=0;
20 while((len=fis.read(arr))!=-1)
21 {
22 fos.write(arr,0,len);
23 }
24 }
25 catch (IOException e)
26 {
27 System.out.println(new RuntimeException("读写文件失败！"));
28 }
29 finally
30 {
31 try
32 {
33 if(fis!=null)
34 fis.close();
35 }
36 catch (IOException e)
37 {
38 System.out.println(new RuntimeException("读取关闭失败"));
39 }
40 try
41 {
42 if(fos!=null)
43 fos.close();
44 }
45 catch (IOException e)
46 {
47 System.out.println(new RuntimeException("写入关闭失败！"));
48 }
49 }
50 }
51 }
1 //java基础视频教程第19天-13-IO流(字节流的缓冲区)
2 /*
3 本节课主要通过字节流的缓冲区来拷贝图片，并查看复制花费的时间System.currentTimeMillis();
4 */
5 import java.io.*;
6 class CopyMp3
7 {
8 public static void main(String[] args)throws IOException
9 {
10 long start = System.currentTimeMillis();
11 copy();
12 long end = System.currentTimeMillis();
13 long time = end-start;
14 System.out.println(time+"毫秒");
15 }
16 public static void copy()throws IOException
17 {
18 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\努力.jpg"));
19 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("奋斗.jpg"));
20 int num=0;
21 while((num=bis.read())!=-1) //从缓冲区读一个存一个
22 {
23 bos.write(num);
24 }
25 bis.close();
26 bos.close();
27 }
28 }
1 //java基础视频教程第19天-14-IO流(自定义字节流的缓冲区-read和write的特点)
2 /*
3 这个程序不怎么会写
4 本节课主要写了一个自定义的字节流缓冲区，
5 并且有一个很重要的注意事项就是为什么字节流读取的是字节，返回的为什么是int类型，
6 这是由于读取媒体文件都是10二进制，有可能读到多个1的=-1的情况，这时就会退出循环，不在读取数据，导致复制失败
7
8 需要分析：其实BufferedInputStream是一个修饰类而已，是对FileInputStream的加强，不是单个单个读，而是放入到数组中，把数组当成一个缓冲区，然后从数组中读到指定位置。
9 我要自己写一个字节流缓冲区，首先它的作用是将一个媒体文件复制到另一个地方，其实复制的的是二进制，如何复制的？？
10 当数组个数为空的时候，就冲原来的媒体文件读取固定个数的二进制存入指定的字节数组中，然后逐个的读取，直到读取完毕之后在从原媒体文件读取
11 这节课说明了，字节流的read方法是读取一个字节（八位二进制），然后强转为int（四个八位二进制），字节流的write方法也有强转的动作，只写入int的低八位
12 java中基本数据类型byte short int lang分别是一个字节，二个字节，四个字节，八个字节，一个字节由8个二进制组成
13 */
14 import java.io.*;
15 class MyBufferedInputStreamDemo
16 {
17 public static void main(String[] args)throws IOException
18 {
19 long start = System.currentTimeMillis();
20 copy();
21 long end = System.currentTimeMillis();
22 long time = end-start;
23 System.out.println(time+"毫秒");
24 }
25 public static void copy()throws IOException
26 {
27 MyBufferedInputStream mbis = new MyBufferedInputStream(new FileInputStream("D:\\TTPmusic\\Two Steps From Hell\\Two Steps From Hell - Down.mp3"));
28 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("奋斗.mp3"));
29 int num=0;
30 long count=0;
31 while((num=mbis.myRead())!=-1) //从缓冲区读一个存一个
32 {
33 count++;
34 System.out.println("第"+count+"个字节:"+num);
35 bos.write(num);//write有强制转换功能，把int类型的数据强制转换成byte类型
36 }
37 //System.out.println("第"+count+"个字节:"+num); //可以观察到当没有&255时读取到数据为-1的情况
38 mbis.myClose();
39 bos.close();
40 }
41 }
42
43 class MyBufferedInputStream //这个我写不来，真的好锤子
44 {
45 private InputStream in;
46 private byte[] buf = new byte[1024]; //都私有化了,我指定的数组元素类型是byte类型，byte是8个字节
47 private int pos = 0,count = 0;
48 MyBufferedInputStream(InputStream in)
49 {
50 this.in = in;
51 }
52 public int myRead()throws IOException //你知道为什么接收的是byte类型二返回的是int类型
53 {
54 if(count==0)
55 {
56 count=in.read(buf); //read方法明确说明了读取的是byte类型，也就是说读取媒体文件的二进制，是八个二进制位为一个元素
57 if(count<0)
58 return -1;
59 pos =0;
60 byte b = buf[pos];
61 count--;
62 pos++;
63 return b&255; //防止读取到-1终止程序
64 /*
65 由于媒体文件是二进制，而这里的read读取的byte，八个八个二进制读取为一个元素存入字节数组中，读取当中有可能连续读取八个1的情况，byte的八个1就是十进制的-1，这是就会退出循环，而这个时候数据并没有读取完毕
66 为了防止这个情况，就会把类型提升到int再&上255，保留有效位，最后在写入的时候，write会强制将int类型的数据转换成byte类型
67 11111111(byte的-1)->11111111 11111111 11111111 11111111(int的-1)
68 00000000 00000000 00000000 11111111(int 255)
69
70 11111111 11111111 11111111 11111111
71 &00000000 00000000 00000000 11111111
72 ----------------------------------------
73 00000000 00000000 00000000 11111111(保留byte的有效数位)
74
75 */
76 }
77 else if(count>0)
78 {
79 byte b =buf[pos];
80 count--;
81 pos++;
82 return b&255; //防止读取到-1终止程序
83 }
84 return -1;
85 }
86 public void myClose()throws IOException
87 {
88 in.close();
89 }
90 }
1 //java基础视频教程第19天-15-IO流(读取键盘录入)
2 /*
3 本节课主要讲解了键盘录入,java.lang包下的System的字段in,它装入的是一个输入读取流
4 \r=10
5 \n=13
6 */
7 import java.io.*;
8 class KeyBordReadIn
9 {
10 public static void main(String[] args) throws IOException
11 {
12 InputStream in = System.in;
13 StringBuilder sb = new StringBuilder();
14
15 while(true) //要求写入一段字符变成大写，当写入over则结束循环，
16 {
17 int ch = in.read(); //in明显是一个InputStream类型，是一个抽象类，怎么可以直接调用read方法呢?
18 if(ch=='\r')
19 continue;
20 if(ch=='\n')
21 {
22 String s = sb.toString();
23 if("over".equals(s))
24 break;
25 System.out.println(s.toUpperCase());
26 sb.delete(0,sb.length()); //每次写完需要清空sb
27 }
28 else
29 sb.append((char)ch);
30
31 }
32
33 }
34 }
1 //java基础视频教程第19天-16-IO流(读取转换流)
2 /*
3 主要讲解如何将字节流转换成字符流InputStreamReader()，然后用字符流的BufferReader中的方法
4 */
5 import java.io.*;
6 class TransStreamDemo
7 {
8 public static void main(String[] args) throws IOException
9 {
10 InputStream in = System.in;
11 InputStreamReader isr = new InputStreamReader(in); //将字节流转换成字符流
12 BufferedReader br= new BufferedReader(isr);
13 String line = null;
14 while((line=br.readLine())!=null) //用字符流的方法readLine读取一行
15 {
16 if(line.equals("over"))
17 break;
18 System.out.println(line);
19 }
20 br.close();
21 }
22 }
1 //java基础视频教程第19天-17-IO流(写入转换流)
2 /*
3 本节课主要讲述的字符流转为字节流的方法OutputStreamWriter
4 java.lang包中System中的out的类型是PrintSream，这个是OutputStream的子类，所以可以用OutputStream来接收它
5 注意一点，转换成字节流之后并没有使用到字节流的方法，而是转换之后以字节形式打印出来
录入是字符，存在硬盘上是字节
InputStreamReader:是Reader的子类，将输入的字节流变为字符流，即将一个字节流的输入对象变为字符流的输入对象
OutputStreamWrite：是Write的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流输出对象
6 */
7 import java.io.*;
8 class TransStreamDemo1
9 {
10 public static void main(String[] args) throws IOException
11 {
12 /*
13 InputStream is = System.in; //键盘输入流
14 InputStreamReader isr = new InputStreamReader(is); //将字节流传入转变为字符流
15 BufferedReader br = new BufferedReader(isr); //想用BufferedReader中的读取一行的方法readLine
16 */
17 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //简写键盘输入
18
19 /*
20 OutputStream os = System.out; //System.out本生就是一个输出流//标准输出流public static final PrintStream out ，PrintStream是OutputStream的子类
21 OutputStreamWriter osw = new OutputStreamWriter(os); //OutPutStreamWriter需要传入一个输出流，将字符流转换成字节流
22 BufferedWriter bw = new BufferedWriter(osw); //包装类，用它的换行功能
23 */
24
25 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); //简写屏幕输出
26 String line = null;
27 while((line=br.readLine())!=null)
28 {
29 if("over".equals(line))
30 break;
31 bw.write(line);
32 bw.newLine();
33 bw.flush();
34
35 }
36
37
38 }
39 }
40
1 //java基础视频教程第19天-18-IO流（流程作规律-1）
2 /*
3 本节课很重要
4 本节课主要讲解了在众多的流对象当中，如何确定源和目标选择体系，明确数据是否为纯文本，以及明确体系之后根据设备选用体系当中的那个具体对象去完成指定要求操作流
5 主要有三个明确，一个是否
6 1.明确源和目标
7 源：InputStream,Reader
8 目标: OutputStream,Writer
9 2.明确数据是否为纯文本
10 是：字符流，选择字符流
11 不是：字节流，选择字节流
12 3.根据设备选择体系中具体的对象
13 源设备：内存，硬盘，键盘
14 目标设备：内存，硬盘，控制台
15 4.是否需要提高效率
16 是就用到相关体系中的缓冲区
17
18 1.需求：将键盘录入打印在控制台上
19
20 2.需求：将键盘录入的数据存储到一个文本中
21 3.需求：将一个文本数据打印在控制台上
22 4.需求：将一个文件中的数据存储到另一个文件中
23 分析：源有两种InputStream和Reader，输入数据是纯文本，选择Reader，源设备是硬盘，应该选择体系中的FileReader对象，是否要提高效率，是就用到这个体系中BufferedReader
24 目标两种OutputStream和Writer，输出数据也是纯文本，闲着Writer，目标设备也是硬盘，应该选择体系中的FileWriter对象，是否要提高效率，是就用到这个体系中的BufferedWriter
25
26 5.将一个图片文件中数据村粗到另一个文件中
27 分析：源有两种InputStream和Reader，输入数据是非纯文本，选择InputStream，源设备是硬盘，应该选择体系中的FileInputStream对象，是否要提高效率，是就用到这个体系中的BufferedInputStream
28 目标两种OutputStream和Writer，输出数据是非纯文本，选着OutputStream，源设备也是硬盘，应该选择体系中的FileOutputStream对象，是否要提高效率，是就用到体系中的BufferedOutputStream
29 */
30 import java.io.*;
31 class TransStreamDemo2
32 {
33 public static void main(String[] args) throws IOException //凡是输入输出流都要抛异常
34 {
35 /*
36 InputStream is = System.in; //键盘录入是一个输入流，是源
37 InputStreamReader ist = new InputStreamReader(is); //字节流转换成字符流
38 BufferedReader br = new BufferedReader(ist); //字符输入流装饰类
39
40
41
42 OutputStream os = System.out; //控制台是一个输出流，是一个目的地
43 OutputStreamWriter osw = new OutputStreamWriter(os); //将数据写入到控制台上
44 BufferedWriter bw = new BufferedWriter(osw); //为了使用它的newLine功能
45 */
46 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //简写
47 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); //简写
48 String line=null;
49 while((line=br.readLine())!=null)
50 {
51 bw.write(line.toUpperCase()); //写入一行并全部大写
52 if("over".equals(line)) //这个停止标记放在哪个地方最好？？？？？？？？？？
53 break;
54 bw.newLine(); //BufferedWriter的特有方法
55
56 bw.flush(); //字符流写入都需要刷新流
57
58
59 //注意没有关闭资源流，是因为这里的控制流的是键盘录入和控制台，当循环结束就就意味着流就不存在了
60 }
61 }
62 }
1 //java基础视频教程第19天-19-IO流（流操作规律-2）
2 /*
3 本节课主要以讲解将键盘录入的数据保存到一个文件中的分析，然后讲到转换流的真正作用,是用于按照指定的字符集去读写数据的
4 注意：转换流什么时候用，通常涉及到字符编码转换时都会用到转换流
5 读取转换流和写入转换流
6 需求1:将键盘录入的数据保存到一个文件中
7 分析:
8 数据来源
9 1.源有两种InputStream，Reader
10 2.是否为纯文本，是，键盘录入是存文本（注意哈），选用体系中的Reader
11 问题，键盘录入是System.in,是InputStream，而体系选择确实Reader，这里为了方便操作键盘录入，需要将字节流转换成字符流，就用到了InputStreamReader
12 3.设备是键盘即InputStream is = System.in
13 4.需要提高效率吗，需要就用到BuffferedReader
14 目标
15 1.目标两种OutputStream，Writer
16 2.是否为纯文本，是，选择Writer
17 3.设备是硬盘，FileWriter()
18 4.需要提高效率吗，需要就用到了BufferedWriter
19
20 需求1:将键盘录入的数据按指定的编码表 保存到一个文件中
21 分析:
22 数据来源
23 1.源有两种InputStream，Reader
24 2.是否为纯文本，是，键盘录入是存文本（注意哈），选用体系中的Reader
25 问题，键盘录入是System.in,是InputStream，而体系选择确实Reader，这里为了方便操作键盘录入，需要将字节流转换成字符流，就用到了InputStreamReader
26 3.设备是键盘即InputStream is = System.in
27 4.需要提高效率吗，需要就用到BuffferedReader
28 目标
29 1.目标两种OutputStream，Writer
30 2.是否为纯文本，是选择Writer
31 3.设备是硬盘选择FileWriter，由于FileWriter是按照默认的编码表GBK来写入文件的，而这里需要按照指定的编码表来写入，所以这里用到了OutputStreamWriter(FileOutputStream(),"UTF-8")
32 4.需要高效吗，需要则用到BufferedWriter
33 注意：转换流的最大作用就是指定编码，OutputStreamWrite和InputStreamReader的构造方法都有传入指定的编码，如果没有传入就是默认的字符编码
34 */
35 import java.io.*;
36 class TransStreamDemo3
37 {
38 public static void main(String[] args)throws IOException
39 {
40 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
41 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter("d.txt"),"UTF-8");
42
43 String line =null;
44 while((line=br.readLine())!=null)
45 {
46
47 if("over".equals(line))
48 break;
49 bw.write(line);
50 bw.newLine();
51 bw.flush();
52 }
53 }
54 }
1 //java基础视频教程第19天-20-IO流（改变标准输入输出设备）
2 /*
3 本节课主要讲解了System中的两个方法setIn,setOut改变输入输出流
4 public static final PrintStream out
5 public static final InputStream in
6 */
7 import java.io.*;
8 class TransStreamDemo4
9 {
10 public static void main(String[] args)throws IOException
11 {
12 System.setIn(new FileInputStream("d.txt")); //改变输入流
13 System.setOut(new PrintStream("dd.txt")); //改变输出流，传递的是PrintStream
14
15 BufferedReader br = new BufferedReader(new InputStreamReader(System.in,"UTF-8")); //以UTF-8读取
16 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
17 String line=null;
18 while((line=br.readLine())!=null)
19 {
20 bw.write(line);
21 if("over".equals(line))
22 break;
23 bw.newLine();
24 bw.flush();
25 }
26 }
27 }
28
1 //java基础视频教程第19天-21-IO流（异常的日志信息）
2 /*
3 本节课主要讲解将异常信息存储到硬盘上,并打印上时间
4 运用到的方法public void printStackTrace(PrintStream s)
5 PrintStream s = System.out
6 */
7 import java.io.*;
8 import java.text.*; //SimpleDateFormat需要
9 import java.util.*; //Date需要
10 class ExceptionInfo
11 {
12 public static void main(String[] args)
13 {
14 Date d = new Date();
15 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
16 String time = sdf.format(d);
17 try
18 {
19 String[] s = new String[3];
20 System.out.println(s[3]);
21 }
22 catch (Exception e)
23 {
24 try
25 {
26 PrintStream ps = new PrintStream("ExceptionInfo.txt"); //new PrintStream需要抛异常的
27 //ps.write(d.toString().getBytes()); //PrintStream对象有write方法也有println方法，write方法写入时间需要将时间转换成字符串然后再转换成字节数组
28 ps.println(time);
29 System.setOut(ps);
30 }
31 catch (Exception r)
32 {
33 throw new RuntimeException("日志文件创建失败！"); //如果建立日志文件失败则直接抛RuntimeException异常
34 }
35
36 e.printStackTrace(System.out); //打印堆栈跟踪信息不用打印的
37 }
38
39 }
40 }
1 //java基础视频教程第19天-22-IO流(系统信息)
2 /*
3 本节课主要讲解了将系统System属性信息getProperties()存储到本地硬盘上，主要通过Properties对象的list方法来完成
4 public static Properties getProperties(),返回类型为Properties,而Properties对象有list方法
5 public void list(PrintStream out)，将属性列表输出到指定的输出流
6
7 */
8 import java.util.*; //引入Properties的list需要
9 import java.io.*;
10 class SystemInfo
11 {
12 public static void main(String[] args) throws IOException
13 {
14 Properties p = System.getProperties();
15 p.list(new PrintStream("SystemInfo.txt"));
16
17
18 }
19 }
1 //java基础视频教程第20天-01-IO流(File概述)
2 /*
3 本节课主要讲解了io流中的File文件对象，主要讲解了它的三个构造方法以及它的一个字段separator,它是一个跨平台的目录分隔符
4 public File(String pathname)
5 public File(String parent,String child) 这里的File Parent是一个字符串
6 public File(File parent,String child),这里的File Parent是一个对象
7
8 File可以将已有的和未出现的文件和文件夹封装成对象
9
10 */
11 import java.io.*;
12 class FileDemo
13 {
14 public static void main(String[] args)
15 {
16 File file = new File("Demo.txt");
17 File file1 = new File("D://","Demo1.txt"); //它的好处在于动态的传递文件
18 File f = new File("D://");
19 File file2 = new File(f,"Demo2.txt");
20 System.out.println(file); //是相对位置就打印相对位置，是绝对位置就打印绝对位置
21 System.out.println(f); //是路径就打印路径
22 System.out.println(file1);
23 System.out.println(file2);
24 System.out.println("C:"+File.separator+"Demo.txt"); //File的字段separator是一个跨平台的目录分隔符
25 }
26 }
1 //java基础视频教程第20天-02-IO流（File对象功能-创建和删除）
2 /*
3 本节课主要讲解了File对象的创建文件和删除文件方法
4 1.创建：
5 public boolean createNewFile()throws IOException,这个方法调用的系统资源创建文件，有可能创建不成功所以要抛异常
6 public static File createTempFile(String prefix,String suffix)throws IOException，在当前目录下创建临时文件，prefix是文件的前缀名，suffix是文件的后缀名
7 public static File createTempFile(String prefix,String suffix,File directory)throws IOException，也是创建临时文件，只不过指定了创建的目录
8 2.删除
9 public boolean delete()，删除文件或目录
10 public void deleteOnExit()，在虚拟机终止时删除文件
11
12 */
13 import java.io.*;
14 class FileDemo1
15 {
16 public static void main(String[] args)throws IOException //创建文件就可能出错，所以要抛异常
17 {
18 File file = new File("Demo.txt"); //将文件Demo.txt封装成一个对象
19 File dir = new File("abc\\ac\\cc\\dd\\cc\\ad");
20 System.out.println(file.createNewFile()); //创建成功返回true，否则false，它调用了底层文件，有可能出现问题，所以要抛异常
21 System.out.println(file.mkdir()); //创建单级目录,创建成功返回true
22 System.out.println(dir.mkdirs()); //创建多级目录，创建成功返回true
23 //file.deleteOnExit(); //虚拟机结束时删除文件
24 System.out.println(file.delete()); //删除文件，删除成功返回true否则返回false
25 }
26 }
1 //java基础视频教程第20天-03-IO流（File对象功能-判断）
2 /*
3 本节课主要讲解File对象的判断方法，方法如下
4 public boolean canExecute()，判断文件是否可以执行
5 public boolean canRead()，判断文件是否可读
6 public boolean canWrite()，判断文件是否可写
7 public int compareTo(File pathname)，比较文件的字母顺序
8 public boolean isAbsolute(),判断是否为绝对路径
9 注意：判断是否是文件或者是否是目录，是否是隐藏额前提必须要判断该对象封装的内容是否存在exists()
10 public boolean isDirectory()，判断是否为目录
11 public boolean isFile()，判断是否为文件
12 public boolean isHidden()，判断文件是否为隐藏文件
13 重点：public boolean exists()，判断文件或者目录是否存在
14
15
16 */
17 import java.io.*;
18 class FileDemo2
19 {
20 public static void main(String[] args) throws IOException
21 {
22 File file = new File("FileDemo2.java");
23 File dir = new File("abc\\ac\\cc\\dd\\cc\\ad");
24 sop(dir.mkdir()); //只能创建一级目录
25 sop(dir.mkdirs()); //创建多级目录
26 sop(file.exists());
27 sop(file.canExecute()); //文件是否可以执行
28 //在判断是否为文件或目录，必须先判断该文件对象封装的内容是否存在
29 if(file.exists())
30 {
31 sop(file.isDirectory());
32 sop(file.isFile());
33 sop(file.isHidden()); //判断是隐藏
34 sop(file.isAbsolute()); //判断文件是否为绝对路径
35 }
36
37 }
38 public static void sop(Object o)
39 {
40 System.out.println(o);
41 }
42 }
1 //java基础视频教程第20天-04-IO流(file对象功能-获取)
2 /*
3 本节课主要讲解了File对象的获取功能
4 public String getName(),获取文件名
5 public String getParent()，获取父目录
6 public String getPath()，获取文件名路径
7 public String getAbsolutePath()，获取文件的绝对路径
8 public File getAbsoluteFile(),这个也是返回绝对路径，只不过它把返回来的绝对路径封装成了对象它们之间可以转换，file对象可以通过toString()转换成字符串，字符串可以通过new File(String)转换成文件对象
9 public long lastModified()，获取文件最后修改的时间，注意返回值是long
10 public long length()，获取文件的长度，注意返回值是long
11 public boolean renameTo(File dest)，改文件名字
12
13 */
14 import java.io.*;
15 class FileDemo3
16 {
17 public static void main(String[] args)throws IOException
18 {
19 File file = new File("D:\\java\\Test.txt");
20 File dir = new File("D:\\java\\Demo.txt");
21 File f = new File("haha.txt");
22
23 sop(file.createNewFile()); //注意是create,多一个e
24 sop(file.getName());
25 sop(file.getPath()); //该方法返回的是绝对路径中的父目录，如果获取的是相对路径则返回null，如果有上一级目录则返回上一级目录
26 sop(f.getParent()); //注意，如果文件对象中的路径是一个相对路径，它获取到的父目录是null，如果文件对象中的路径是一个绝对路径则返回父路径，如果文件对象有上一级目录则返回上一级目录
27 sop(file.getAbsolutePath()); //绝对路径其实就是getParent()+getPath();
28 sop(file.length());
29 sop(file.lastModified());
30 sop(file.renameTo(dir)); //可以跨盘符，相当于剪切
31 }
32 public static void sop(Object o)
33 {
34 System.out.println(o);
35 }
36 }
1 //java基础视频教程第20天-05-IO流(File对象功能-文件列表)
2 /*
3 本节课主要讲解File对象的两个方法
4 public static File[] listRoots()，列出文件系统的根目录,它是一个静态方法，类直接可以调用
5 public String[] list()，返回当前路径下的文件夹和文件,注意，当指定的路劲不存在则会抛空指针异常NullPointerException
6
7 */
8 import java.io.*;
9 class FileDemo4
10 {
11 public static void main(String[] args)
12 {
13 File[] files = File.listRoots(); //静态方法类名直接调用，获取机器上有效的盘符
14 File dir = new File("D:\\java.txt"); //列出系统中有效的盘符
15 for(File f : files) //高级for循环中放的是集合或者是数组
16 {
17 System.out.println(f);
18 }
19 String[] names = dir.list(); //注意，调用list方法必须要求这个dir对象是一个封装的一个目录，并且这个目录还必须存在，否则包报空指针异常nullPointException
20 for(String s : names)
21 {
22 System.out.println(s);
23 }
24 }
25 }
1 //java基础视频教程第20天-06-IO流(File对象功能-文件类表2)
2 /*
3 本节课主要讲解列出一个文件对象中指定目录中的所有文件以及文件夹的两个方法
4 public String[] list() //返回文件对象中的路径下的所有文件和文件名，是以字符串数组的形式返回的
5 public String[] list(FilenameFilter filter) //这个也是返回文件对象中指定路径下的所有文件和文件名，也是以字符串数组形式返回，只不过在传了一个接口类型的参数，这个参数的作用是过滤
6 public File[] listFiles() //返回文件对象中指定的路径下的所有文件和文件名，是以文件对象数组形式返回的
7 public File[] listFiles(FilenamFilter filter) //以文件对象形式返回指定文件对象路径下的所有文件很文件夹
8 public interface FilenameFilter //这是一个接口，它有一个方法boolean accept(File dir,String name);它作为list以及listFile的参数
9 另外本节课还用到了String类中的endsWith方法，public boolean endsWith(String suffix);
10 在匿名内部类中我们学过当一个接口有少于三个方法时，作为参数传递给一个方法，那么这个传递的就是一个匿名内部类
11 */
12 import java.io.*;
13 class FileDemo5
14 {
15 public static void main(String[] args)
16 {
17 File dir = new File("c:\\");
18 File file = new File("d:\\");
19 String[] str = dir.list();
20 for(String s : str)
21 {
22 System.out.println(s);
23 }
24 System.out.println("*****************************************************************************");
25 String[] arr = file.list(new FilenameFilter(){
26 public boolean accept(File dir,String name)
27 {
28 //System.out.println(dir+"-------"+name); //dir是需要被过滤的，你懂我说的意思吗
29 //return true; //如果没有加限制就返回所有的文件和文件夹
30 return name.endsWith(".jpg"); //直接返回，不需做if那样麻烦,如果是.jpg文件才返回true，其它的文件返回false，就可以达到过滤文件
31 }
32 });
33 for(String s: arr)
34 {
35 System.out.println(s);
36 }
37
38 System.out.println("*****************************************************************************");
39 File[] arr1 = file.listFiles(); //返回的是文件对象数组
40 for(File f : arr1)
41 {
42 System.out.println(f.getName()+"---"+f.getPath()) ; //listFile的好处就是在于返回的是文件对象，文件对象就可以对文件进行更多的操作，所以在选用list和listFiles时，先选用listFiles
43 }
44 System.out.println("*****************************************************************************");
45 File[] arr2 = dir.listFiles(new FilenameFilter(){
46 public boolean accept(File dir,String name)
47 {
48 return name.endsWith(".txt"); //只筛选出.txt文件
49 }
50 });
51 for(File d : arr2)
52 {
53 System.out.println(d.length()+"---"+d.getName()+"---"+d.getAbsolutePath());
54 }
55 }
56 }
1 //java基础视频教程第20天-07-IO流(列出目录下所有内容-递归)
2 /*
3 本节课主要讲解四点，但是这四点都是围绕着递归来讲的
4 1.通过文件对象的listFiles()方法去打印出指定路径中的文件以及文件夹中的所有的文件，这里就用到了递归了
5 2.计算一个正数的二进制,通过递归
6 3.计算一个正数数到1的和,通过递归，
7
8
9 */
10 import java.io.*;
11 class FileDemo6
12 {
13 public static void main(String[] args)
14 {
15 File dir = new File("d:\\java");
16 //getListFiles(dir);
17 //toBin(7);
18 System.out.println(getSum1(10));
19 System.out.println(getSum(10465)); //递归不要递归太多，不然就会内存溢出，因为栈内存空间有限，不断的递归会在栈内存内开辟空间调用方法
20 }
21 public static void getListFiles(File dir)
22 {
23 System.out.println("---------------"+dir+"---------------------"); //打印文件之前先把文件夹打印出来
24 File[] file = dir.listFiles();
25 for(int x =0;x<file.length;x++)
26 {
27 if(file[x].isDirectory()) //如果是文件夹就继续调用本方法打印出文件夹的文件，如此不断循环，直到打印出所有文件夹中的所有文件
28 getListFiles(file[x]);
29 else
30 System.out.println(file[x]);
31 }
32 }
33 public static void toBin(int num)
34 {
35 if(num>0)
36 {
37 toBin(num/2);
38 System.out.println(num%2);
39 }
40 }
41 public static int getSum1(int num)
42 {
43 int sum=0;
44 if(num>0)
45 {
46 sum=num+getSum1(--num); //注意一个问题，方法中涉及到--，++的时候要用前置的不要用后置，后置的要出问题，因为你传的值给变量。
47 }
48 return sum;
49 }
50 /*
51 public static int getSum(int x)
52 {
53 int sum=x;
54 if(x>0)
55 {
56 sum+=getSum(--x);
57 System.out.println(x);
58 }
59 return sum;
60 }
61 */
62 public static int getSum(int n)
63 {
64 if(n==1)
65 return 1;
66 return n+getSum(n-1);
67 }
68 }
1 //java基础视频教程第20天-08-IO流(列出目录下所有的内容-带层次)
2 /*
3 这节课主要讲解在上一节课的基础上为各个层级添加|--
4 本节课主要用到StringBuffer中的append()和insert()方法
5 */
6 import java.io.*;
7 class FileDemo7
8 {
9 public static void main(String[] args)
10 {
11 File dir = new File("D:\\java\\abc");
12 getlistFiles(dir,0);
13 }
14 public static String addLevel(int level)
15 {
16 StringBuffer sb = new StringBuffer();
17 sb.append("|--");
18 for(int x=0;x<level;x++)
19 {
20 sb.insert(0," ");
21
22 }
23 return sb.toString();
24 }
25 public static void getlistFiles(File dir,int level)
26 {
27 System.out.println(addLevel(level++)+dir.getName());
28 File[] file = dir.listFiles(new FilenameFilter(){
29 public boolean accept(File dir,String name)
30 {
31 return true;
32 }
33 });
34 /*
35 for(File f : file)
36 {
37 if(f.isDirectory())
38 getlistFiles(f,level);
39 else
40 System.out.println(f.getName());
41 }
42 */
43 for (int x=0;x<file.length;x++)
44 {
45 if(file[x].isDirectory())
46 getlistFiles(file[x],level);
47 else
48 System.out.println(file[x].getName());
49 }
50 }
51 }
//java基础视频教程第20天-09-IO流（删除带内容的目录）
/*
本节课主要讲解如何删除一个带文件以及文件夹的目录,主要通过迭代来删除。流程如下
(1)主方法中创建一个目录并判断目录是否存在，存在则调用删除方法，将这个目录作为参数传递进去
File dir = new File("D:\\java\\abc");
if(dir.exists())
remove(dir);
(2)创建删除方法，并列出传入的目录下所有的文件以及文件夹
File[] files = dir.listFiles();
(3)遍历文件和文件夹，如果遍历到的文件是非隐藏以及是一个目录就继续调用删除方法，如果是文件则删除掉文件
for(int x=0;x<files.length;x++)
{
if(!files[x].isHidden() && files[x].isDirectory())
remove(files[x]);
else
System.out.println(files[x].toString()+"-file-"+files[x].delete());
}
(4)删除完文件之后在删除掉文件夹
System.out.println(dir+"-dir-"+dir.delete());
*/
import java.io.*;
class RemoveFileAndDir
{
public static void main(String[] args)
{
File dir = new File("D:\\java\\abc");
if(dir.exists())
remove(dir);
}
public static void remove(File dir)
{
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(!files[x].isHidden() && files[x].isDirectory())
remove(files[x]);
else
System.out.println(files[x].toString()+"-file-"+files[x].delete());
}
System.out.println(dir+"-dir-"+dir.delete()); //当删完文件之后才删除文件夹
}
}
//java视频教程第20天-10-IO流(创建java文件列表)
/*
本节课需求是将一个目录中后缀名为.java的文件列表存储到一个txt文件中
这个程序分三步
(1)主函数中指定需要查询的目录并且建立list类表
(2)建立获取列表的方法，将目录和列表传递给这个方法，遍历目录，
如果遍历到的文件还是目录则用迭代继续，如果遍历到的是文件并且复合塞选要求则将这个文件添加到list列表中
(3)建立列表文件，将list传递给它，然后通过io流将list中的文件写到指定的txt文件中去。
*/
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args)
{
File dir = new File("D:\\java");
List<File> list = new ArrayList<File>();
if(dir.exists())
getList(dir,list);
listFile(list);
}
public static void getList(File dir,List<File> list) //获取指定目录下的清单并将符合的文件添加到list列表中
{
File[] files = dir.listFiles();
for(File file:files)
{
if(file.isDirectory())
getList(file,list);
else if(file.toString().endsWith("java"))
list.add(file);
}
}
public static void listFile(List<File> list) //将list中的文件保存在硬盘上的一个txt文件中
{
BufferedWriter bw = null;
try
{
bw = new BufferedWriter(new FileWriter("D:\\java\\JavaFileList.txt"));
for (File file : list)
{
bw.write(file.getName());
bw.newLine();
bw.flush();
}
}
catch (Exception e)
{
throw new RuntimeException();
}
finally
{
if(bw!=null)
try
{
bw.close();
}
catch (Exception e)
{
System.out.println("关闭失败");
}
}
}
}
//java基础视频教程第20天-11-IO流(Properties概述)
/*
本两节课讲解一个很重要的类Properties，
(1),它是Hashtable的子类,也就是说它具备map集合的特点，它里面存储的键值对都是字符串
(2),它是集合和IO技术结合的集合容器
(3),该对象特点是用于键值对形式的配置文件,所以这个配置文件必须是键值对，并且键=值模式
*/
//java基础视频教程第20天-12-IO流(Properties存取)
/*
本节课主要讲解了Properties中的三个方法
public String getProperty(String key),通过键获取属性
public Object setProperty(String key,String value),设置键值对
public Set<String> stringPropertyNames(),将Map集合转换成Set集合然后遍历取键值对
*/
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)
{
setAndGet();
}
public static void setAndGet()
{
Properties pro = new Properties();
pro.setProperty("张三","27");
pro.setProperty("李四","33");
String value = pro.getProperty("李四");
System.out.println(pro); //注意:可以直接打印出集合的，
System.out.println(value);
Set<String> names = pro.stringPropertyNames();
for(String name : names)
{
System.out.println(name+"->"+pro.getProperty(name));
}
}
}
//java基础视频教程第20天-13-IO流(Properties存取配置文件)
/*
本节课主要讲解了在本地硬盘上有一个键值对配置文件，现在要求读取这个配置文件，然后然后把键值对放到Properties中，
但是这是发现了Properties中的键值对有错误，那么就改正，然后在存入到一新的配置文件中
本节课主要用到的方法有，
public void load(InputString inStream) throws IOExcetion,载入一个输入流到property中，这个流中载入了本地配置文件的
public void load(Reader reader) throws IOException,这个是JDK1.6以后才出现的，
public String[] split(String regix),字符串的切割功能
public object setProperty(String key,String value);
public void list(PrintStream out); 将属性列表输出到指定的输出字节流中
public void list(PrintWriter out); 将属性列表输出到指定的输出字符流中
public void store(OutputStream out,String comments)throws IOException;将此Properties表中的属性列表写入到输出字流，第二个参数是注释
public void store(Writer writer,String comments)throws IOException，将此Properties表中的 属性列表写入到输出字符流,第二个参数是注释
综上可以看出properties中的方法都有字节流和字符流的两种方式
*/
import java.io.*;
import java.util.*;
class PropertiesDemo1
{
public static void main(String[] args) throws Exception
{
//getKeyAndValue(); //这个方法就是load的过程
//propertyLoad();
//propertyList();
propertyStore();
}
public static void getKeyAndValue() throws Exception //这个方法就是load的过程
{
Properties pro = new Properties();
BufferedReader bw = new BufferedReader(new FileReader("D:\\java\\IO\\property.txt"));
String line = null;
while((line=bw.readLine())!=null)
{
String[] str = line.split("=");
pro.setProperty(str[0],str[1]);
}
System.out.println(pro);
bw.close();
}
public static void propertyLoad() throws Exception //展示load方法
{
Properties pro = new Properties();
BufferedReader bis = new BufferedReader(new FileReader("D:\\java\\IO\\property.txt")); //这个是在JDK1.6之后才会出现的
pro.load(bis);
System.out.println(pro);
bis.close();
}
public static void propertyList() throws Exception //展示list方法
{
Properties pro = new Properties();
BufferedReader bis = new BufferedReader(new FileReader("D:\\java\\IO\\property.txt")); //如果用字节流的话就汉字就要注意字符编码问题
pro.load(bis);
System.out.println(pro);
pro.setProperty("王五","33");
PrintWriter pw = new PrintWriter("D:\\java\\IO\\property1.txt");
pro.list(pw);
pw.flush();
bis.close();
pw.close();
}
public static void propertyStore()throws Exception //展示store方法
{
Properties pro = new Properties();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\java\\IO\\property.txt"));
pro.load(bis);
System.out.println(pro);
pro.setProperty("张三","22");
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\IO\\xxxx.txt"));//这个编码有问题，如果不是汉字可以用这个
pro.store(bos,"你是猪八戒");
bis.close();
bos.close();
}
}
//java基础视频教程第20天-14-IO流（Properties练习）
/*
本节课主要模拟一个运行一个软件次数，如果次数超多了规定的次数就禁止运行软件
本节课还是用到了properties中的一些方法
*/
import java.io.*;
import java.util.*;
class RunCount
{
public static void main(String[] args) throws Exception
{
count();
}
public static void count()throws Exception
{
Properties pro = new Properties();
File file = new File("count.ini");
if(!file.exists())
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
pro.load(fis); //我现在已经把流载入到properties中了
int count = 0;
String value = pro.getProperty("time"); //第一次可能没有time，返回value则为null
if(value!=null) //如果value不为空则将value转换成数字并记录，count满足5次则停止使用
{
count = Integer.parseInt(value);
if(count>=5)
{
System.out.println("你好，使用次数已到，要想继续使用请注册付钱");
return;
}
}
count++;
pro.setProperty("time",count+"");
FileOutputStream fos = new FileOutputStream(file);
pro.store(fos,"叽里叽里叽里，呱啦呱啦叽里");
fos.close();
fis.close();
}
}
//java基础视频教程第20天-15-IO流(PrintWriter)
/*
本节课主要介绍字节打印流PrintStream和字符打印流PrintWriter,它们最强的方法是print功能，能够直接打印基本数据类型
(1).字节打印流PrintStream，它的构造方法可以传File对象，OutputStream输出流，字符串路径，如果传入的是字节流都可以添加一个自动刷新功能
public PrintStream(File file) throws FileNotFoundException
public PrintStream(File file,String csn)throws FileNotFoundException UnsuportedEncodingException
public PrintStream(OutputStream out)
public PrintStream(OutputStream out,boolean autoFlush)
public printStream(OutpuStream out,boolean autoFlush,String encoding)throws UnsupportEcodingException
public PrintStream(String fileName)throws FileNotFoundException
public PrintStream(String fileName,String encoding)
综上构造方法中打印流都涉及到编码和自动刷新
(2).字符打印流PrintWriter，它的构造方法可以传File对象，OutputStream输出流，字符串路径以及Writer输出流，如果传入的是字节流或者字符流都可以添加一个自动刷新功能
public PrintWriter(File file)throws FileNotFoundException
public PrintWriter(File file,String csn)throws FileNotFoundException UnsupportEncodingException
public PrintWriter(OutputStream out)
public PrintWriter(OutputStream out,boolean autoFlush)
public PrintWriter(String fileName)throws FileNotFoundException
public PrintWriter(String fileName,String csn)throws FileNotFoundException UnsupportEncodingException
public PrintWriter(Writer writer)
public PrintWriter(Writer writer,boolean autoFluesh)
综上构造方法，字符打印流比字节打印流多一个传递字符流的功能，并且也涉及到字符编码和自动刷新
本节课要求将键盘输入通过打印流存储到指定位置
注意一点，如果构造方法中传入了自动换行的话，那么打印处必须要用println才可以实现自动换行功能
凡是涉及到流的都有可以传入刷新功能
*/
import java.io.*;
class PrintWriterDemo
{
public static void main(String[] args) throws Exception
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out,true); //打印流中凡是传入的是流，就可以添加自动属性
String line = null;
while((line=br.readLine())!=null)
{
if("over".equals(line))
break;
pw.println(line.toUpperCase()); //打印流最强大的功能是打印，它能够直接打印很多数据类型，这里还要注意一点如果构造函数中加上自动换行功能的话必须要用println才可以
//pw.flush();
}
br.close();
pw.close();
}
}
//java基础视频教程第20天-16-IO（合并流）
/*
本节课讲解合并流SequenceInputStream,它可以将多个输入流合并成一个流，它只有输入流没有对应的输出流
public SequenceInputStream(InputStream s1,InputStream s2) //合并两个流
public SequenceInputStream(Enumeration<? extends InputStream> e) //通过枚举添加多个输入流，这样可以合并对个流
这个类是从JDK1.0就开始的。
本节课要求将三个输入流合并成一个流，然后把合并流中是数据输出到新的文件中
*/
import java.io.*;
import java.util.*;
class SequenceDemo
{
public static void main(String[] args)throws Exception
{
Vector<InputStream> vc = new Vector<InputStream>();
vc.add(new FileInputStream("1.txt"));
vc.add(new FileInputStream("2.txt"));
vc.add(new FileInputStream("3.txt"));
Enumeration<InputStream> en = vc.elements();
SequenceInputStream sis = new SequenceInputStream(en); //将以上三个流合并到一个流中
FileOutputStream fos = new FileOutputStream("4.txt");
int num =0;
while((num=sis.read())!=-1)
{
fos.write((char)num);
}
sis.close();
fos.close();
}
}
//java基础视频教程第20天-17-IO流（切割文件）
/*
本节课主要讲解如何切割一个文件，然后又如何通过枚举，以及合并流来将切割的碎片文件重组为完成文件
本节课重要点：
我把数据存入到ArrayList中，如何用枚举来取？
*/
import java.io.*;
import java.util.*;
class SplitFile
{
public static void main(String[] args) throws Exception
{
//splitFile();
combine();
}
public static void splitFile()throws Exception //分割文件
{
FileInputStream fis = new FileInputStream("1.jpg");
byte[] buf = new byte[1024*1024*3];
int len = 0;
int count =1;
while((len=fis.read(buf))!=-1)
{
FileOutputStream fos = new FileOutputStream(count+++".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public static void combine()throws Exception
{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>(); //通过筛选把碎片文件筛选出来
File dir = new File("D:\\java\\IO");
File[] files = dir.listFiles(new FilenameFilter(){
public boolean accept(File dir,String name)
{
return name.endsWith(".part");
}
});
for(File file : files)
{
al.add(new FileInputStream(file)); //
}
final Iterator<FileInputStream> it = al.iterator(); //局部内部类调用局部变量时，这个局部变量要设置为final类型
//最关键的一步来了，我将数据存入到ArrayList中，如何通过枚举取出来,可以新建一个枚举内部类来取
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en); //通过合并流将枚举中的流合并
FileOutputStream fos = new FileOutputStream("xxxxx.jpg");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
//java基础视频教程第21天-01-IO流（对象的序列化）
/*
本节课主要讲解操作对象的流，将对象存储到硬盘上，并且给他对象添加数字标识,然后再把对象读取出来
(1)ObjectOutputStream
public ObjectOutputStream(OutputStream out)throws IOException, //操作对象输出流
public final void writeObject()throws IOException //写入对象的方法
(2)对于要存储的对象需要继承java.io.Serializable接口，这个接口没有要实现的方法，这只是一个标识接口
public interface Serializable
(3)ObjectInputStream
public ObjectInputStream(InputStream in)throws IOException
public final Object readObject()throws IOException ClassNotFoundException //注意:读取返回的是对象，需要转型
对象中的序列是通过成员计算出来的，如果你改变类中的成员那么那么存储的对象就找不到相应的类文件
为了能够在改变类中成员之后还能使用哪个类可以将自己定义序列
public static final long serialVersionUID = 42L;记得重写写入类文件
*/
import java.io.*;
class ObjectStreamDemo
{
public static void main(String[] args)throws Exception
{
//ObjectOutputStreammethod();
ObjectInputStreammethos();
}
public static void ObjectOutputStreammethod()throws Exception //将对象存储到文件中
{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Object.txt"));
oos.writeObject(new Person("王麻子",1999));
oos.close();
}
public static void ObjectInputStreammethos()throws Exception
{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Object.txt"));
Object obj = ois.readObject();
System.out.println((Person)obj);
}
}
//java基础视频教程第21天-02-IO流(管道流)
/*
本节课主要讲解管道流，涉及到多线程的IO流
PipedInputStream和PipedOutputStream
(1)管道流的构造方法传递的参数是管道流，如果没有传递则有方法将输入流和输出流结合起来
PipedOutputStream
public PipedOutputStream() //创建尚未连接到管道输入流的管道输出流
public PipedOutputStream(PipedInputStream snk)throws IOException //创建连接到指点管道输入流的管道输出流
public void connect(PipedInputStream snk) throws IOException //将此管道输出流连接到接收者
PipedInputStream
public PipedInputStream() //创建尚未连接的管道输入流
Public PipedInputStream(int popeSize) //创建尚未连接并且指点大小缓冲区的管道输入流
public PipedInputStream(PipesOutputStream src)throws IOExcetpion //创建一个连接到管道输出流的管道输入流
public PipedInputStream(PipedOutputStream src,int pipeSize)throws IOException //创建一个连接到管道输出流并且指点大小缓冲的管道输入流
public void connect(PipedOutputStream src)throws IOException //将此管道输入流连接到管道输出流
(2)read()和write方法都是阻塞式方法，就相当于多线程，没有数据就等待
(3)对于管道流建议用多线程避免死锁
*/
import java.io.*;
class Read implements Runnable
{
PipedInputStream pis;
Read(PipedInputStream pis)
{
this.pis = pis;
}
public void run()
{
try
{
byte[] buf = new byte[1024];
int len;
while((len=pis.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
pis.close();
}
catch (Exception e)
{
System.out.println("读取失败");
}
}
}
class Write implements Runnable
{
PipedOutputStream pos;
Write(PipedOutputStream pos)
{
this.pos = pos;
}
public void run()
{
try
{
byte[] buf = "Hi guy,I'm coming!".getBytes();
pos.write(buf,0,buf.length);
pos.close();
}
catch (Exception e)
{
System.out.println("写入失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args) throws Exception
{
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
pis.connect(pos);
Write w = new Write(pos);
Read r = new Read(pis);
new Thread(w).start();
new Thread(r).start();
}
}
//javas基础视频教程21天-03-IO流（RandomAccessFile）
/*
本节课讲解IO中一个自成一派的类RandomAccessFile随机访问文件，它直接继承Object
(1)它构造方法只接受文件对象和字符串文件，后面的表示模式，模式有读r，读写rw，以及rws和rwd
public RandomAccessFile(File file,String mode)throws FileNotFoundException
public RandomAccessFile(String name,String mode)throws FileNotFoundException
(2)这个类不经有读的功能还有写的功能，而且还有读取高于八位和写高于八位等方法
public final int readInt()throws IOException
public final void writeInt(int v)throws IOException
为什么会出现这个呢？
因为read和write方法只能读写最低八位，如果给定的某个数超过了255则就会数据丢失，
为了防止数据丢失就需要读写高于八位的数据
(3)列外这个类最大的好处在于它可以设置指针插入点，这样就可以在指定的位置上读取数据或者写入数据
public void seek(long pos)throws IOException //设置指针位置，它可以前后任意设置指针
public int skipBytes(int n)throws IOException //这个是跳过多个字节，只能向后移动指针，不能向前跳指针
(4)如果模式为r，指定的文件不存在则会报异常，并且它不会创建文件
如果模式为rw，指定的文件不存在则会创建，如果文件存在，则不会覆盖文件
*/
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args)throws IOException
{
//writeFile();
//System.out.println(Integer.toBinaryString(355));
readFile();
}
public static void writeFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("file.txt","rw");
raf.write("张三".getBytes());
//raf.write(355); write只写入了最低八位，如果数据超过了256，就会数据丢失，为了避免丢失数据，就有了writeInt()方法
raf.writeInt(55);
raf.write("李四".getBytes());
raf.writeInt(46);
raf.close();
}
public static void readFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("file.txt","r");
byte[] buf = new byte[4];
raf.read(buf);
System.out.println("neme="+new String(buf));
System.out.println("age="+raf.readInt());
raf.close();
}
}
//java基础教程第21天-04-IO流(操作基本数据类型的流对象)
/*
本节课主要讲解了操作基本数据的流对象DataInputStream和DataOutputStream
(1).构造方法
public DataInputStream(InputStream in)
public DataOutputStream(OutputStream out)
(2).这两个类的特点
这两个类的特点是将基本数据类型和流相结合，所以他们有很多操作基本数据类型的方法
比如直接读写布尔值，整型，字符型等等
(3).特有方法
public static final String readUTF(DataInput in)throws IOException
public final void writeUTF(String str)throws IOException
这两个方法都是以UTF-8修改版来读写操作的，如果用这个写，就必须用这个读，不然读不了数据
*/
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args)throws Exception
{
DataStreamWrite();
DataStreamRead();
DataStreamUTFWrite();
DataStreamUTFRead();
}
public static void DataStreamWrite()throws Exception
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("DataFile.txt"));
dos.writeInt(135); //int四个字节
dos.writeBoolean(true); //boolean一个字节
dos.writeDouble(322.22); //double八个字节
dos.close();
}
public static void DataStreamRead()throws Exception
{
DataInputStream dis = new DataInputStream(new FileInputStream("DataFile.txt"));
System.out.println(dis.readInt()); //要对应着取，不然读取数据错乱
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());
dis.close();
}
public static void DataStreamUTFWrite()throws Exception
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("UTF-8.txt"));
dos.writeUTF("你好吗"); //只有中文才涉及到UTF-8
dos.close();
}
public static void DataStreamUTFRead()throws Exception
{
DataInputStream dis = new DataInputStream(new FileInputStream("UTF-8.txt"));
System.out.println(dis.readUTF()); //用UTF-8修改版写就需要UTF-8修改版读取
dis.close();
}
}
//java基础视频教程第21天-05-IO流(ByteArrayStream)
/*
本节课主要讲解字节数组流，字符数组流和字符串流，它们内存的源和目的
(1).ByteArrayInputStream和ByteArrayOutputStream
构造方法
public ByteArrayInputStream(byte[] buf)
public ByteArrayInputStream(byte[] buf,int offset,int length)
public ByteArrayOutputStream()
pulibc ByteArrayOutputStream(int size) //创建一个指定大小缓冲区的字节数组输出流
这个两个类都没有用到底层资源，输入流是一个字节数组没有用到本地资源调用本地文件，
输出流是将字节存储到字节数组缓冲区，并且这个缓冲区会自动增加，也没有调用本地资源，
所以它们都不需要关闭资源,不需要抛IO异常
另外输出流ByteArrayOutputStream()可以通过toByteArray()和toString()将缓冲数组中的数据获取到
(2).字节数组流和数组的区别
将数据存储到数组流缓冲区中提高多用性，用流的思想操作数据，
(3).其它内存源和目的
在操作IO规则中源和目的中都有内存，内存代表就是ArrayStream数组流
除了字节数组流还有字符数组流和字符串流,它们的用法如同字节数组流
CharArrayReader
CharArrayWriter
StringReader
StringWriter
*/
import java.io.*;
class ByteArrayStreamDemo
{
public static void main(String[] args)
{
ByteArrayInputStream bais = new ByteArrayInputStream("abcddfal".getBytes());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int num =0;
while((num=bais.read())!=-1)
{
baos.write(num);
}
System.out.println(baos.size());
System.out.println(baos.toString());
}
}
//java基础视频教程第21天-06天-IO流(转换流的字符编码)
/*
本节课主要讲解了编码的问题，主要有以下四点
(1).IO中涉及到字符编码的流除了转换流之外还有两个PrintStream和PrintWriter
(2).常见编码
老美的ASICC码，用一个字节的7位表示
欧洲的ISO8859-1，用一个字节的8位表示
中国的GB2312,GBK.两个字节表示一个文字
国际标准码Unicode，两个字节表示一个文字
国际标准码转换格式UTF-8,最少用一个字节表示一个字符，最多用三个字符表示一个字符
(3).GBK编码的中文文件用UTF-8去解码
GBK一个字符有两个字节
(4).UTF-8编码的中文文件用UTF-8去解码
UTF-8一个字符由三个字节
*/
import java.io.*;
class EncodeStream
{
public static void main(String[] args)throws Exception
{
//encodeWrite();
encodeRead();
}
public static void encodeWrite()throws Exception
{
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf-8.txt"),"UTF-8");
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"GBK");
osw.write("你好");
osw.close();
}
public static void encodeRead()throws Exception
{
//InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"),"GBK");//UTF-8编码的中文，用GBK去解码
InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"),"UTF-8"); //GBK编码的中文，用UTF-8去解码
char[] buf = new char[4];
int len = isr.read(buf);
System.out.println(new String(buf,0,len));
isr.close();
}
}
//java基础视频教程第21天-07-字符编码
/*
本节课主要讲解编码和解码，以及用GBK编码后用ISO8859-1解码失败，然后用ISO8859-1继续反编码在用GBK正确解码，
在一个就是用GBK编码后用UTF-8解码失败，不能用UTF-8继续反编码再用GBK正确编码
(1).编码和解码
编码：将字符串转换成字节数组
public byte[] getBytes() //使用默认字符编码进行编码
public byte[] getBytes(Charset charset) //使用指定的字符编码进行编码
解码：将字节数组转换成字符串
public String(byte[] bytes) //默认字符编码
public String(byte[] bytes,Charset charset) //可以指定字符编码
注意，虽然默认中文编码是GBK，但是如果你指定编码的话必须要抛异常，因为有可能你给的字符编码不存在
*/
import java.util.*;
class CharsetDemo
{
public static void main(String[] args) throws Exception
{
//encodAndDecode();
noticeEncode();
}
public static void encodAndDecode()throws Exception
{
byte[] b1 = "你好".getBytes(); //默认编码为GBK
byte[] b2 = "你好".getBytes("GBK");
byte[] b3 = "你好".getBytes("UTF-8");
System.out.println(Arrays.toString(b1)); //将数组中的内容以字符串打印出来
System.out.println(Arrays.toString(b2));
System.out.println(Arrays.toString(b3));
System.out.println(new String(b1)); //解码
System.out.println(new String(b2,"GBK"));
System.out.println(new String(b3,"UTF-8"));
}
public static void noticeEncode()throws Exception
{
byte[] b= "你好".getBytes("GBK");
System.out.println(Arrays.toString(b));
String str = new String(b,"ISO8859-1");
System.out.println(str);
byte[] b1 = str.getBytes("ISO8859-1");
System.out.println(Arrays.toString(b1));
System.out.println(new String(b1,"GBK"));
String str1 = new String(b,"UTF-8");
System.out.println(str1); //为什么是三个？呢？？？？？？？？？
//下面这种反编码是错误的,原因是UTF-8也是被中文字
byte[] b2 = str1.getBytes("UTF-8");
System.out.println(Arrays.toString(b2));
System.out.println(new String(b2,"GBK"));
}
}
浙公网安备 33010602011771号