黑马程序员_IO流1

-----------android培训、java培训、期待与您交流！ ------------

1.IO流概述
*IO流用来处理设备之间的数据传输
*Java对数据的操作时通过流的方式
*Java用于操作流的对象都在IO包里
*流按照操作数据分为两种：字节流和字符流
*流按照流向分为：输入流，输出流


2.FileWriter的使用
在硬盘上创建一个文件并写入一些文字数据

[java]  view plain copy

1. import java.io.*;  
2.     class FileWriterDemo {  
3.           
4.         public static void main(String[] args) throws IOException {  
5.             /* 
6.              *创建一个FileWriter对象，创建了一个流，该对象一被初始化就必须要明确被操作的文件 
7.              *如果目标目录下已经有同名文件，将被覆盖 
8.              */  
9.             FileWriter fw = new FileWriter("F:\\test1\\aa.java");  //反斜杠要两个\\                          
10.               
11.             /* 
12.              *调用write方法将字符串写入流中 
13.              *调用flush方法刷新流的缓冲区，将数据写入目标文件中去 
14.              */  
15.             fw.write("abc");  
16.             fw.flush();  
17.               
18.             //关闭流资源，关闭之前会刷新一次流  
19.             fw.close();  
20.         }  
21.     }  

3.IO异常处理方式

[java]  view plain copy

1. import java.io.*;  
2.     class IOExceptionDemo {  
3.         public static void main(String[] args) {  
4.           
5.             FileWriter fw = null;  //如果声明在try代码块中，fw.close()将会报错  
6.             try {  
7.                 fw = new FileWriter("demo.txt");  
8.                 fw.write("abcde");  
9.             } catch(IOException e) {  
10.                 System.out.println(e.toString());  
11.             }  
12.               
13.             finally{ //finally中存放的是一定要执行的操作，一般是关闭资源   
14.                   
15.                 try {  
16.                     if(fw!=null)  //防止空指针异常  
17.                         fw.close();  
18.                 } catch (IOException e) {  
19.                     System.out.println(e.toString());  
20.                 }  
21.             }  
22.         }  
23.     }  

4.文件的续写
意义：因为new FileWriter()会将同名文件覆盖，为了防止数据丢失，应使用续写

[java]  view plain copy

1. import java.io.*;  
2.     class FileWrite {  
3.       
4.         public static void main(String[] args) {  
5.           
6.             //传递一个true参数，代表不覆盖已有的文件，并在已经有的文件末尾处进行数据续写  
7.             FileWriter fw = null;    
8.             //一定要做好异常的处理  
9.             try {  
10.                 fw = new FileWriter("demo.txt",true);  
11.                 fw.write("abcde\r\n");  //\r\n才表示换行，只有\n在记事本中是一个小黑块  
12.             } catch(IOException e) {  
13.                 System.out.println(e.toString());  
14.             }  
15.               
16.             finally{   
17.                   
18.                 try {  
19.                     if(fw!=null)    
20.                         fw.close();  
21.                 } catch (IOException e) {  
22.                     System.out.println(e.toString());  
23.                 }  
24.             }  
25.         }  
26.     }  

5.文件文本读取方式

[java]  view plain copy

1. import java.io.*;  
2.     class FileReaderDemo {  
3.         public static void main(String[] args) {  
4.         /* 
5.          *创建一个文件读取流对象，和指定名称的文件相关联 
6.          *要保证该文件是已经存在的，如果不存在，会发生异常 
7.          */  
8.             FileReader fr = null;  
9.             int ch = 0;  
10.             try {  
11.                 fr = new FileReader("demo.txt");  
12.                 while(ch=fr.read()!=-1){  //注意是返回的int型数据,一次只读一个字符,而且会自动往下读  
13.                     System.out.println("ch="+(char)ch);  
14.                     }  
15.             } catch(IOException e){  
16.                 System.out.println(e.toString());  
17.             }  
18.   
19.             finally{  
20.                 try {  
21.                     if(fr!=null)  
22.                         fr.close();  
23.                 } catch(IOException e) {  
24.                     System.out.println(e.toString());  
25.                 }  
26.             }  
27.         }  
28.     }  

[java]  view plain copy

1. //文本读取的第二种方式：将字符读入数组  
2.     import java.io.*;  
3.     class FileReadDemo {  
4.         public static void main(String[] args) {  
5.             FileReader fr = null;  
6.             char[] buf = new char[1024];  
7.             int len = 0;  
8.             /* 
9.              *定义一个字符数组，用于存储读到的字符 
10.              *该read(char[] buf)返回的是读到的字符个数 
11.              */  
12.               
13.             try{  
14.                 fr = new FileReader("F:\\test1\\aa.java");  
15.           
16.                 while((len = fr.read(buf))!=-1){  //返回-1表示没有数据  
17.                     System.out.println(new String(buf,0,len)); //读到几个打印几个  
18.                 }  
19.             } catch(IOException e){  
20.                 System.out.println(e.toString());  
21.             }  
22.               
23.             finally{  
24.                 try {  
25.                     if(fr!=null)  
26.                         fr.close();  
27.                 } catch(IOException e) {  
28.                     System.out.println(e.toString());  
29.                 }  
30.         }  
31.     }  

6.拷贝文本文件
复制原理：
1.在目标目录下创建一个文件，用于存储被复制文件的数据
2.定义读取流和原文件的关联
3.通过不断的读写完成数据存储
4.关闭资源

[java]  view plain copy

1. import java.io.*;  
2. class Test {  
3.     public static void   main(String[] args) {  
4.           
5.         String directory1 = "F:\\java\\kk.java";  
6.         String directory2 = "F:\\test1\\test.txt";  
7.         copy(directory1,directory2);  
8.     }  
9.       
10.     public static void copy (String str, String str1) {  
11.         FileReader fr = null;  
12.         FileWriter fw = null;  
13.         char[] buf = new char[1024];  
14.         int len = 0;  
15.           
16.         try {  
17.             fr = new FileReader(str);  
18.             fw = new FileWriter(str1,true);  
19.             while ((len = fr.read(buf))!=-1) {  
20.                 fw.write(buf,0,len);  
21.                 //fw.flush();  因为finally代码块中fw.close()刷新了流  
22.             }  
23.               
24.         } catch (IOException e) {  
25.             System.out.println(e.toString());  
26.         }  
27.           
28.         finally {  
29.            // 2个异常一定要分别try catch处理  
30.             try {  
31.                 if(fr!=null) {  
32.                     fr.close();           
33.                 }  
34.             } catch (IOException e) {  
35.                 System.out.println(e.toString());  
36.             }  
37.             try {  
38.                 if(fr!=null) {  
39.                     fw.close();  
40.                 }  
41.             } catch (IOException e) {  
42.                 System.out.println(e.toString());  
43.             }  
44.         }  
45.     }  
46. }  

7.BufferedWriter
缓冲区的出现时为了提高流的操作效率而出现的 
创建缓冲区之前，必须要有流对象

[java]  view plain copy

1. import java.io.*;  
2. class Demo {  
3.   
4.     public static void main(String[] args) throws IOException{  
5.         //创建一个字符写入流对象  
6.         FileWriter fw = new FileWriter("F:\\test1\\xx.java");  
7.         //为了提高字符写入流效率，加入了缓冲技术  
8.         //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可  
9.         BufferedWriter bufw = new BufferedWriter(fw);  
10.           
11.         bufw.write("ddddf");   
12.         //换行  
13.         bufw.newLine();  
14.         //只要用到缓冲区，就要记得刷新  
15.         bufw.flush();  
16.         //关闭缓冲区，就是在关闭缓冲区中的流对象，因此无需fw.close()  
17.         bufw.close();  
18.     }  
19. }  

8.BufferedReader 

[java]  view plain copy

1. //创建一个读取流对象  
2.     FileReader fr = new FileReader("demo.txt");  
3.     //将读取流对象传递给缓冲区的构造函数  
4.     BufferedReader bufr = new BufferedReader();  
5.     //一行一行读取是高效的,bufr.readLine()  
6.     String line = null;  
7.       
8.     while ((line = bufr.readLine())!=null) {  
9.         System.out.println(line);  
10.     }  
11.     //关闭缓冲区  
12.     bufr.close();  

9.通过缓冲区复制一个文件

[java]  view plain copy

1. import java.io.*;  
2. class Test {  
3.     public static void   main(String[] args) {  
4.           
5.         String directory1 = "F:\\java\\kk.java";  
6.         String directory2 = "F:\\test1\\xx.java";  
7.         copy(directory1,directory2);  
8.     }  
9.       
10.     public static void copy (String str, String str1) {  
11.         FileReader fr = null;  
12.         FileWriter fw = null;  
13.           
14.         try {  
15.             fr = new FileReader(str);  
16.             fw = new FileWriter(str1,true);  
17.               
18.             BufferedWriter bufw = new BufferedWriter(fw);  
19.             BufferedReader bufr = new BufferedReader(fr);  
20.             String line = null;  
21.             while ((line = bufr.readLine())!=null) {//不读取换行符  
22.                 bufw.write(line);   
23.                 bufw.newLine(); //注意要换行  
24.                 bufw.flush();  
25.             }     
26.         } catch (IOException e) {  
27.             System.out.println(e.toString());  
28.         }  
29.   
30.         finally {  
31.            // 2个异常一定要分别try catch处理  
32.             try {  
33.                 if(fr!=null) {  
34.                     bufr.close();             
35.                 }  
36.             } catch (IOException e) {  
37.                 System.out.println(e.toString());  
38.             }  
39.             try {  
40.                 if(fr!=null) {  
41.                     bufw.close();  
42.                 }  
43.             } catch (IOException e) {  
44.                 System.out.println(e.toString());  
45.             }  
46.         }  
47.     }  
48. }  

10.装饰设计模式
什么情况下使用装饰设计模式
当我们需要对一个类的功能进行改进、增强的时候
装饰模式的基本格式。
含有被装饰类的引用
通过构造函数传入被装饰类对象
被装饰类含有同样的方法，其中调用被装饰类的方法，对其进行改进、增强
和被装饰类继承同一个类或实现同一个接口，可以当做被装饰类来使用
装饰和继承的区别：
装饰模式比继承要灵活，避免了继承体系的臃肿
而且降低了类与类之间的关系
装饰类因为增强已有对象，具备的功能和已有的时相同的，只不过提供了更强的功能
所以装饰类和被装饰类通常是都属于一个体系中的
实例:

[java]  view plain copy

1. //把一次读一个字符的方法装饰成一次读一行的方法  
2. public String myReadLine() throws IOException {  
3.         StringBuilder sb = new StringBuilder();  
4.         int ch = 0;  
5.         while ((ch = rean())!= -1) {  
6.             if(ch == '\r')  
7.                 continue;  
8.             if(ch == '\n')  
9.                 return sb.toString();  
10.         }  
11.         if(sb.length() != 0)  
12.             return sb.toString();  
13.         return null;  
14. }  

11.LineNumberReader
跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。 
例：

[java]  view plain copy

1. package cn.itcast;  
2.   
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. import java.io.LineNumberReader;  
6.   
7. class Test {  
8.     public static void main(String[] args) throws IOException {  
9.         FileReader fr = new FileReader("PersonDemo.java");  
10.         LineNumberReader lnr = new LineNumberReader(fr);  
11.         String line = null;  
12.         while ((line = lnr.readLine()) != null) {  
13.             System.out.println(line);  
14.         }  
15.         lnr.close();  
16.     }  
17. }  

12.字节流File读写操作
字节流主要是操作byte的类型数据
字节流与字符流不同:
a.字节流可以操作任意类型数据，而字符流只能操作文本文件
b.字节流的使用比字符流更加广泛，但是操作中文的文本文件时，字符流比字节流好用


字符流操作:主要操作文本文件
FileReader
FileWriter
BufferedReader
BufferedWriter


字节流操作
InputStream 
方法:
void close() 关闭此输入流并释放与该流关联的所有系统资源。
int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len)将输入流中最多 len 个数据字节读入 byte 数组。


OutputStream
方法:
void close()关闭此输出流并释放与此流有关的所有系统资源。
void flush()刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。


实例：拷贝图片

[java]  view plain copy

1. package cn.itcast;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6.   
7. class Test {  
8.     public static void main(String[] args) {  
9.         FileOutputStream fos = null;  
10.         FileInputStream fis = null;  
11.         try {  
12.             fos = new FileOutputStream("C:\\2.bmp");  
13.             fis = new FileInputStream("C:\\1.bmp");  
14.             byte[] buf = new byte[1024];  
15.             int len = 0;  
16.             while ((len = fis.read(buf)) != -1) {  
17.                 fos.write(buf, 0, len);  
18.             }  
19.         } catch (IOException e) {  
20.             throw new RuntimeException("复制文件失败");  
21.         } finally {  
22.             try {  
23.                 if (fis != null)  
24.                     fis.close();  
25.             } catch (IOException e) {  
26.                 throw new RuntimeException("读取关闭失败");  
27.             }  
28.             try {  
29.                 if (fos != null)  
30.                     fos.close();  
31.             } catch (IOException e) {  
32.                 throw new RuntimeException("写入关闭失败");  
33.             }  
34.         }  
35.     }  
36. }  

13.字节流的缓冲区
BufferedInputStream
BufferedOutputStream
实例:复制mp3文件

[java]  view plain copy

1. package cn.itcast;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8.   
9. class Test{  
10.     public static void main(String[] args)throws IOException {  
11.         copy();  
12.     }  
13.     public static void copy() throws IOException {  
14.         BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("C:\\1.mp3"));  
15.         BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("D:\\2.mp3"));  
16.           
17.         int by = 0;  
18.         while ((by=bufis.read()) != -1) {  
19.             bufos.write(by);  
20.         }  
21.         bufos.close();  
22.         bufis.close();  
23.     }  
24. }  

14.读取键盘录入
System.out:对应的是标准输出设备，控制台
System.in:对应的是标准输入设备：键盘
例:

[java]  view plain copy

1. import java.io.*;  
2. class Test{  
3.     public static void main(String[] args) throws IOException {  
4.         InputStream in = System.in;  
5.         int by = in.read(); //只能读一个字节  
6.         System.out.println(by);  
7.     }  
8. }  

15.读写转换流
类InputStreamReader
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集
为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。例如： 
 BufferedReader in
   = new BufferedReader(new InputStreamReader(System.in));
构造方法
InputStreamReader(InputStream in) 


类OutputStreamWriter
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。 
为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。例如： 


 Writer out
   = new BufferedWriter(new OutputStreamWriter(System.out));
构造方法
OutputStreamWriter(OutputStream out) 


转换流实例：

[java]  view plain copy

1. package cn.itcast;  
2. import java.io.BufferedReader;  
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.InputStreamReader;  
6. class Test{  
7.     public static void main(String[] args) throws IOException {  
8.         //获取键盘录入对象  
9.         InputStream in = System.in;  
10.         //将字节流对象转成字符流对象，使用转换流  
11.         InputStreamReader isr = new InputStreamReader(in);  
12.         //为了提高效率，将字符流进行缓冲区技术的高效操作  
13.         BufferedReader bufr = new BufferedReader(isr);  
14.         String line = null;  
15.         while ((line=bufr.readLine())!=null) {  
16.             System.out.println(line.toUpperCase());  
17.         }  
18.         bufr.close();  
19.     }  
20. }  

16.流操作规律
如何选取流对象
通过三个明确来完成
a.明确源和目的
源:输入流 InputStream    Reader
目的:输出流  OutputStream   Writer
b.操作的数据是否是纯文本
是：使用字符流
否：使用字节流
c.当体系明确之后，再明确要使用哪个具体的对象
通过设备来进行区分：
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台

选取流操作实例:
需求1：将一个文本文件中数据存储到另一个文件中，复制文件
源：InputStream Reader
是否是文本文件？
是，这时就可以选择Reader
明确设备：硬盘上的文件
Reader体系中可以操作文件的对象是FileReader
是否需要提高效率？
是，使用BufferedReader


目的：OutputStream Writer
是否是纯文本？
是，选择writer
设备：硬盘
可以使用FileWriter
是否需要提高效率？
是，使用BufferedWriter

需求2：将键盘录入的数据保存到一个文件中
源：InputStream Reader
是否是纯文本？
是，选择Reader
设备：键盘，对应的对象System.in
由于System.in对应的是字节流
因此使用转换流InputStreamReader
需要提高效率？
使用BufferedReader

目的：OutputStream Writer
是否是文本文件？
是，Writer,但是如果涉及编码问题则选择字节流后转成字符流
设备：硬盘
使用FileWriter，如需要加入指定的编码表，则需要使用转换流OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
是否要提高效率？
是，使用BufferedWriter

-----------android培训、java培训、期待与您交流！ ------------