分布式-网络通信-IO-基础（1）

IO整体图架构

 

 一、IO流概述

概述：

         IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，Java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。

分类：

        按操作数据分为：字节流和字符流。 如：Reader和InpurStream

        按流向分：输入流和输出流。如：InputStream和OutputStream

IO流常用的基类：

         * InputStream    ，    OutputStream

字符流的抽象基类：

         * Reader       ，         Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀：

            如：FileReader和FileInputStream

二、字符流

1. 字符流简介：

* 字符流中的对象融合了编码表，也就是系统默认的编码表。我们的系统一般都是GBK编码。

* 字符流只用来处理文本数据，字节流用来处理媒体数据。

* 数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter。

2.字符流读写：

注意事项：

* 写入文件后必须要用flush()刷新。

* 用完流后记得要关闭流

* 使用流对象要抛出IO异常

 

* 定义文件路径时，可以用“/”或者“\”。

* 在创建一个文件时，如果目录下有同名文件将被覆盖。

* 在读取文件时，必须保证该文件已存在，否则出异常

示例1：在硬盘上创建一个文件,并写入一些文字数据

1. class FireWriterDemo {  
2. public static void main(String[] args) throws IOException {             //需要对IO异常进行处理   
4. //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。  
5. //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。  
7. FileWriter fw = new FileWriter("F:\1.txt");//目的是明确数据要存放的目的地。  
9. //调用write的方法将字符串写到流中  
10. fw.write("hello world!");  
12. //刷新流对象缓冲中的数据，将数据刷到目的地中  
13. fw.flush();  
15. //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();  
16. fw.write("first_test");  
17. fw.close();  
18. //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。  
20. }  
21. }  

示例2：FileReader的reade()方法.

要求：用单个字符和字符数组进行分别读取

1. class FileReaderDemo {  
2. public static void main(String[] args) {  
3. characters();  
4. }  
7. /*****************字符数组进行读取*********************/  
8. private static void characters() {  
10. try {  
12. FileReader fr = new FileReader("Demo.txt");  
13. char []  buf = new char[6];   
14. //将Denmo中的文件读取到buf数组中。  
15. int num = 0;      
16. while((num = fr.read(buf))!=-1) {  
18. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符  
19. sop(new String(buf,0,num));  
20. }  
21. sop(' ');  
22. fr.close();  
23. }  
24. catch (IOException e) {  
25. sop(e.toString());  
26. }  
27. }  
34. /*****************单个字母读取*************************/  
35. private static void singleReader() {  
37. try {  
39. //创建一个文件读取流对象，和指定名称的文件关联。  
40. //要保证文件已经存在，否则会发生异常：FileNotFoundException  
41. FileReader fr = new FileReader("Demo.txt");  
44. //如何调用读取流对象的read方法？  
45. //read()方法，一次读取一个字符，并且自动往下读。如果到达末尾则返回-1  
46. int ch = 0;  
47. while ((ch=fr.read())!=-1) {  
48. sop((char)ch);  
49. }  
50. sop(' ');  
51. fr.close();  
54. /*int ch = fr.read(); 
55. sop("ch=" + (char)ch); 
57. int ch2 = fr.read(); 
58. sop("ch2=" + (char)ch2); 
60. //使用结束注意关闭流 
61. fr.close(); */    
65. }  
66. catch (IOException e) {  
67. sop(e.toString());  
68. }  
70. }  
73. /**********************Println************************/  
74. private static void sop(Object obj) {  
75. System.out.print(obj);  
76. }  
78. }  

 

示例3：对已有文件的数据进行续写

 

 

[java] view plain copy

1. import java.io.*;  
3. class  FileWriterDemo3 {  
4. public static void main(String[] args) {  
6. try {  
7. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写  
8. FileWriter fw = new FileWriter("F:\java_Demo\day9_24\demo.txt",true);  
9. fw.write(" is charactor table?");  
10. fw.close();  
11. }  
12. catch (IOException e) {  
13. sop(e.toString());  
14. }  
16. }  
18. /**********************Println************************/  
19. private static void sop(Object obj)  
20. {  
21. System.out.println(obj);  
22. }  
23. }  

三、缓冲区

1. 字符流的缓冲区：BufferedReader和BufferedWreiter

* 缓冲区的出现时为了提高流的操作效率而出现的.

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader示例：

读取流缓冲区提供了一个一次读一行的方法readline，方便对文本数据的获取。
readline()只返回回车符前面的字符，不返回回车符。如果是复制的话，必须加入newLine()，写入回车符

newLine()是java提供的多平台换行符写入方法。

1. import java.io.*;  
4. class BufferedReaderDemo {  
5. public static void main(String[] args)  throws IOException {  
7. //创建一个字符读取流流对象，和文件关联  
8. FileReader rw = new FileReader("buf.txt");  
10. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可  
11. BufferedReader brw = new BufferedReader(rw);  
14. for(;;) {  
15. String s = brw.readLine();  
16. if(s==null) break;  
17. System.out.println(s);  
18. }  
20. brw.close();//关闭输入流对象  
22. }  
23. }  

BufferedWriter示例：

1. import java.io.*;  
4. class BufferedWriterDemo {  
5. public static void main(String[] args)  throws IOException {  
7. //创建一个字符写入流对象  
8. FileWriter fw = new FileWriter("buf.txt");  
10. //为了提高字符写入效率，加入了缓冲技术。  
11. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可  
12. BufferedWriter bfw = new BufferedWriter(fw);  
14. //bfw.write("abc de");  
15. //bfw.newLine();               这行代码等价于bfw.write(" "),相当于一个跨平台的换行符  
16. //用到缓冲区就必须要刷新  
17. for(int x = 1; x < 5; x++) {  
18. bfw.write("abc");  
19. bfw.newLine();                  //java提供了一个跨平台的换行符newLine();  
20. bfw.flush();  
21. }  
25. bfw.flush();                                                //刷新缓冲区  
26. bfw.close();                                                //关闭缓冲区，但是必须要先刷新  
28. //注意，关闭缓冲区就是在关闭缓冲中的流对象  
29. fw.close();                                                 //关闭输入流对象  
31. }  
32. }  

 

四、字节流

1.概述：

 

1、字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。

2、字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）

3、读写字节流：InputStream   输入流（读）和OutputStream  输出流（写）

4、字节流操作可以不用刷新流操作。

5、InputStream特有方法：

        int available();//返回文件中的字节个数

注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

练习：

需求：复制一张图片F:java_Demoday9_281.BMP到F:java_Demoday9_282.bmp

1. import java.io.*;  
4. class CopyPic {  
5. public static void main(String[] args){  
6. copyBmp();  
7. System.out.println("复制完成");  
8. }  
10. public static void copyBmp() {  
12. FileInputStream fis = null;  
13. FileOutputStream fos = null;  
14. try {  
15. fis = new FileInputStream("F:\java_Demo\day9_28\1.bmp");             //写入流关联文件  
16. fos = new FileOutputStream("F:\java_Demo\day9_28\2.bmp");            //读取流关联文件  
17. byte[] copy = new byte[1024];  
18. int len = 0;  
19. while((len=fis.read(copy))!=-1) {  
20. fos.write(copy,0,len);  
21. }  
22. }  
23. catch (IOException e) {  
24. e.printStackTrace();  
25. throw new RuntimeException("复制文件异常");  
26. }  
27. finally {  
28. try {  
29. if(fis!=null) fis.close();  
30. }  
31. catch (IOException e) {  
32. e.printStackTrace();  
33. throw new RuntimeException("读取流");  
34. }  
35. }  
37. }  
39. }  

2. 字节流缓冲区

* 字节流缓冲区跟字符流缓冲区一样，也是为了提高效率。

注意事项：

1. read()：会将字节byte()提升为int型值

2. write()：会将int类型转换为byte()类型，保留最后的8位。

练习：

1.复制MP3文件   1.MP3 -->  2.MP3

2.自己写一个MyBufferedInputStream缓冲类，提升复制速度

1. import java.io.*;  
4. //自己的BufferedInputStream  
5. class MyBufferedInputStream  {  
6. private InputStream in;                         //定义一个流对象  
7. private byte [] buf = new byte[1024*4];  
8. private int count = 0,pos = 0;  
9. public MyBufferedInputStream(InputStream in){  
10. this.in = in;  
11. }  
13. public  int MyRead() throws IOException{  
14. if(count==0) {              //当数组里的数据为空时候，读入数据  
15. count = in.read(buf);  
16. pos = 0;  
17. byte b = buf[pos];  
18. count--;  
19. pos++;  
20. return b&255;       //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111  
21. }  
22. else if(count > 0) {  
23. byte b = buf[pos];  
24. pos++;  
25. count--;  
26. return b&0xff;      //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111  
27. }  
28. return -1;  
29. }  
31. public void myClose() throws IOException{  
32. in.close();  
33. }  
35. }  
40. class BufferedCopyDemo {  
41. public static void main(String[] args) {  
42. long start = System.currentTimeMillis();  
43. copy();  
44. long end = System.currentTimeMillis();  
45. System.out.println("时间:"+(end-start)+"ms");  
48. start = System.currentTimeMillis();  
49. copy1();  
50. end = System.currentTimeMillis();  
51. System.out.println("时间:"+(end-start)+"ms");  
52. }   
54. public static void copy1() {                //    应用自己的缓冲区缓冲数据  
56. MyBufferedInputStream bis = null;  
57. BufferedOutputStream  bos = null;  
58. try {  
59. bis = new MyBufferedInputStream(new FileInputStream("马旭东-入戏太深.mp3"));//匿名类，传入一个InputStream流对象  
60. bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));  
61. int buf = 0;  
62. while((buf=bis.MyRead())!=-1) {  
63. bos.write(buf);  
64. }  
65. }  
66. catch (IOException e) {  
67. e.printStackTrace();  
68. throw new RuntimeException("复制失败");  
69. }  
70. finally {  
71. try {  
72. if(bis!=null)  {  
73. bis.myClose();  
74. bos.close();  
75. }  
76. }  
77. catch (IOException e) {  
78. e.printStackTrace();  
79. }  
81. }  
83. }  
84. }   

 

五、流操作规则

1. 键盘读取，控制台打印。

System.out: 对应的标准输出设备：控制台  //它是PrintStream对象，（PrintStream：打印流。OutputStream的子类）

System.in: 对应的标准输入设备：键盘     //它是InputStream对象

示例：

1.  /*================从键盘录入流，打印到控制台上================*/  
2. public static void InOutDemo(){  
3. //键盘的最常见的写法  
4. BufferedReader bufr = null;  
5. BufferedWriter bufw = null;  
6. try {  
8. /*InputStream ips = System.in;        //从键盘读入输入字节流 
9. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流 
10. bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率  
13. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符  
14. bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要写入流中的字符编码成字节  
15. String line = null;  
16. while((line = bufr.readLine())!=null){  
17. if("over".equals(line)) break;  
18. bufw.write(line.toUpperCase());                     //打印  
19. bufw.newLine();                                     //为了兼容，使用newLine()写入换行符  
20. bufw.flush();                                       //必须要刷新。不然不会显示  
21. }  
22. if(bufw!=null) {  
23. bufr.close();  
24. bufw.close();  
25. }  
26. }  
27. catch (IOException e) {  
28. e.printStackTrace();  
29. }  
32. }  
33. }  

2. 整行录入

1.从键盘录入数据，并存储到文件中。

2. 我们在键盘录入的是时候，read()方法是一个一个录入的，能不能整行的录入呢？这时候我们想到了BufferedReader中ReadLine()方法。

3. 转换流

为了让字节流可以使用字符流中的方法，我们需要转换流。

 1. InputStreamReader:字节流转向字符流；

  a、获取键盘录入对象。

              InputStream in=System.in;

  b、将字节流对象转成字符流对象，使用转换流。

              InputStreamReaderisr=new InputStreamReader(in);

  c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

//键盘录入最常见写法

              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字符流通向字节流

示例：

 

1. /*================把键盘录入的数据存到一个文件中==============*/  
2. public static void inToFile() {  
3. //键盘的最常见的写法  
4. BufferedReader bufr = null;  
5. BufferedWriter bufw = null;  
6. try {  
8. /*InputStream ips = System.in;        //从键盘读入输入字节流 
9. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流 
10. bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率  
13. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符  
14. bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要写入流中的字符编码成字节  
15. String line = null;  
16. while((line = bufr.readLine())!=null){  
17. if("over".equals(line)) break;  
18. bufw.write(line.toUpperCase());                     //打印  
19. bufw.newLine();                                     //为了兼容，使用newLine()写入换行符  
20. bufw.flush();                                       //必须要刷新。不然不会显示  
21. }  
22. if(bufw!=null) {  
23. bufr.close();  
24. bufw.close();  
25. }  
26. }  
27. catch (IOException e) {  
28. e.printStackTrace();  
29. }  
32. }  

4. 流操作基本规律

为了控制格式我将其写入了Java代码段中，如下：

示例1：文本 ~ 文本

1. /*  
2. 流操作的基本规律。  
3. 一、两个明确：(明确体系)  
4. 1. 明确源和目的  
5. 源：输入流  InputStream  Reader  
6. 目的：输出流  OutputStream Writer  
8. 2. 操作的数据是否是纯文本  
9. 是： 字符流  
10. 否： 字节流  
11. 二、明确体系后要明确具体使用的对象  
12. 通过设备区分：内存，硬盘，键盘  
13. 目的设备：内存，硬盘，控制台  
16. 示例1：将一个文本文件中的数据存储到另一个文件中: 复制文件  
17. 一、明确体系  
18. 源：文件-->读取流-->(InputStream和Reader)  
19. 是否是文本：是-->Reader  
22. 目的：文件-->写入流-->(OutputStream Writer)  
23. 是否纯文本：是-->Writer  
25. 二、 明确设备  
26. 源：Reader  
27. 设备：硬盘上一个文本文件 --> 子类对象为：FileReader  
28. FileReader fr = new FileReader("Goods.txt");  
30. 是否提高效率：是-->加入Reader中的缓冲区：BufferedReader  
31. BufferedReader bufr = new BufferedReader(fr);  
33. 目的：Writer  
34. 设备：键盘上一个文本文件 --> 子类对象：FileWriter  
35. FileWriter fw = new FileWriter("goods1.txt");  
36. 是否提高效率：是-->加入Writer的缓冲区：BufferedWriter  
37. BufferedWriter bufw = new BufferedWriter(fw);  
41. 示例2：将一个图片文件数据复制到另一个文件中：复制文件  
42. 一、明确体系  
43. 源：文件-->读取流-->(InputStream和Reader)  
44. 是否是文本：否-->InputStream  
47. 目的：文件-->写入流-->(OutputStream Writer)  
48. 是否纯文本：否-->OutputStream  
50. 二、 明确设备  
51. 源：InputStream  
52. 设备：硬盘上一个媒体文件 --> 子类对象为：FileInputStream  
53. FileInputStream fis = new FileInputStream("Goods.txt");  
55. 是否提高效率：是-->加入InputStream中的缓冲区：BufferedInputStream  
56. BufferedInputStream bufi = new BufferedInputStream(fis);  
58. 目的：OutputStream  
59. 设备：键盘上一个媒体文件 --> 子类对象：FileOutputStream  
60. FileOutputStream fos = new FileOutputStream("goods1.txt");  
61. 是否提高效率：是-->加入OutputStream的缓冲区：BufferedOutputStream  
62. BufferedOutputStream bufo = new BufferedOutputStream(fw);  
64. 示例3：将键盘录入的数据保存到一个文本文件中  
65. 一、明确体系  
66. 源：键盘-->读取流-->(InputStream和Reader)  
67. 是否是文本：是-->Reader  
70. 目的：文件-->写入流-->(OutputStream Writer)  
71. 是否纯文本：是-->Writer  
73. 二、 明确设备  
74. 源：InputStream  
75. 设备：键盘 --> 对用对象为：System.in --> InputStream  
76. 为了操作方便，转成字符流Reader --> 使用Reader中的转换流：InputStreamReader  
77. InputStreamReader isr = new InputStreamReader(System.in);  
79. 是否提高效率：是-->加入Reader中的缓冲区：BufferedReader  
80. BufferedReader bufr = new BufferedReader(isr);  
82. 目的：Writer  
83. 设备：键盘上一个文本文件 --> 子类对象：FileWriter  
84. FileWriter fw = new FileWriter("goods1.txt");  
85. 是否提高效率：是-->加入Writer的缓冲区：BufferedWriter  
86. BufferedWriter bufw = new BufferedWriter(fw);  

5.指定编码表(转换流可以指定编码表)

要求：用UTF-8编码存储一个文本文件

 

[java] view plain copy

1. import java.io.*;  
2. public class IOStreamLaw {  
4. /** 
5. * @param args 
6. */  
7. public static void main(String[] args) throws IOException {  
8. //键盘的最常见写法  
9. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
10. BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));  
11. String line = null;  
12. while((line=bufr.readLine())!=null){  
13. if("over".equals(line)) break;  
14. bufw.write(line.toUpperCase());  
15. bufw.newLine();  
16. bufw.flush();  
17. }  
18. bufr.close();  
19. }  
22. }