黑马程序员——Java语言：IO

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、IO流

IO流用来处理设备之间的数据传输。Java对数据的操作是通过流的方式。

Java用于操作流的对象都在IO包中。

输入流和输出流相对于内存设备而言。

流按操作数据分为两种：字节流与字符流。

字节流的抽象基类：InputStream，OutputStream。

字符流的抽象基类：Reader，Writer。

字符流只能操作文本数据，字节流还可以操作媒体数据

二、字符流

2.1字符流用来处理文本数据（读写）

通过下列代码了解字符流使用流程

2.1.1需求：需求：在硬盘创建一个文件并写入一些文字数据 （FileWriter对象，写）

[java]  view plain copy

1. //1.导包  
2. import java.io.*;   
3. class  FileWriterDemo  
4. {  
5.     public static void main(String[] args) throws IOException//抛出异常  
6.     {  
7.         //2.创建一个FileWriter对象，该对象一被初始化就必须要明确要被操作的文件  
8.       
9.         FileWriter fw = new FileWriter("demo.txt");  
10.         //该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖  
11.   
12.         //3.调用write方法，将字符串写入流中  
13.         fw.write("abcd");  
14.           
15.         //4.刷新流对象中的缓冲中的数据，将数据保存到目标文件  
16.         fw.flush();  
17.   
18.         //5.关闭流资源，关闭前会刷新缓冲数据,关闭后无法再写入数据  
19.         fw.close();  
20.           
21.     }  
22. }  

注意：

1、已有文件的数据续写：在构造函数传递一个boolean参数，true则不覆盖（如果已存在的话），在已有文件的末尾处进行文件续写

FileWriter fw = new FileWriter("demo.txt",true);

2、由于在创建对象时，需要指定创建文件位置，如果指定的位置不存在，就会发生IOException异常，所以在整个步骤中，需要对IO异常进行try处理。以下为标准处理格式。

[java]  view plain copy

1. import java.io.*;  
2. class  FileWriterDemo2  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         FileWriter fw = null;//代码块外创建流，这样所有代码块里都可以调用对象  
7.         try  
8.         {  
9.             fw = new FileWriter("demo.txt");//代码块内初始化流  
10.             fw.write("abcd");  
11.               
12.         }  
13.         catch (IOException e)  
14.         {  
15.             System.out.println(e.toString());  
16.         }  
17.         finally  
18.         {  
19.             try  
20.             {  
21.                 if(fw!=null)  
22.                     fw.close();  
23.             }  
24.             catch(IOException e)  
25.             {  
26.                 System.out.println(e.toString());  
27.             }     
28.         }  
29.     }  
30. }  

2.1.2 文本文件读取方式（FileReader对象，读）

读取方式：

int read() 读取单个字符

int read(char[] cbuf) 通过数组读取，返回字符个数

[java]  view plain copy

1. import java.io.*;  
2. class  FileReaderDemo  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         //创建一个文件读取流对象，和指定名称的文件相关联  
7.         //要保证该文件是存在的，否则会发生FileNotFoundException  
8.         FileReader fr = null;  
9.         try  
10.         {  
11.             fr = new FileReader("demo.txt");  
12.             //调用read方法读取字符  
13.             //read方法一次读一个字符，而且自动往下读  
14.   
15.             int ch = 0;  
16.             while((ch=fr.read())!=-1)  
17.             {  
18.                 System.out.println("ch="+(char)ch);  
19.             }  
20.         }  
21.         catch (IOException e)  
22.         {  
23.             System.out.println(e.toString());  
24.         }  
25.         finally  
26.         {  
27.             try  
28.             {  
29.                 if(fr!=null)  
30.                     fr.close();  
31.             }  
32.             catch (IOException e)  
33.             {  
34.                 System.out.println(e.toString());  
35.             }  
36.         }  
37.     }  
38. }  

2.2字符流的缓冲区：BufferedWriter、BufferedReader

是为了提高流的操作效率而出现的，在创建缓冲区之前，必须要先有流对象，在构造缓冲区对象时将流对象赋给缓冲区对象。

BufferedWriter

[java]  view plain copy

1. FileWriter fw = new FileWriter("buf.txt");  
2. //为了提高字符写入流的效率，加入了缓冲技术  
3. BufferedWriter bufw = new BufferedWriter(fw);  
4. bufw.write("abcdef");  
5. bufw.newLine();  
6. bufw.write("abcdef");  
7. bufw.flush();  
8. bufw.close();//关闭缓冲区，就是关闭缓冲区中的流对象  

BufferedReader

[java]  view plain copy

1. FileReader fr = new FileReader ("buf.txt");  
2. BufferedReader bufr = new BufferedReader(fr);  
3. String st = null;  
4. while((st=bufr.readLine())!=null)         
5. {                                             
6. <span style="white-space:pre">    </span>System.out.println(st);  
7. }  
8. bufr.close();  

写入换行使用BufferedWriter类中的newLine()方法。

读取一行数据使用BufferedReader类中的readLine()方法。

练习：通过缓冲区复制一个.java文件

[java]  view plain copy

1. mport java.io.*;  
2. class  BufferedCopy  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         BufferedReader bufr = null;  
7.         BufferedWriter bufw = null;  
8.   
9.         try  
10.         {  
11.             bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));  
12.             bufw = new BufferedWriter(new FileWriter("e:\\BufferedWriterDemo.txt"));  
13.             String buf = null;   
14.             while((buf=bufr.readLine())!=null)  
15.             {  
16.                 bufw.write(buf);  
17.                 bufw.newLine();//readLine不返回回车符，所以得输入回车符  
18.                 bufw.flush();  
19.             }  
20.         }  
21.         catch (IOException e)  
22.         {  
23.             throw new RuntimeException("读写异常");  
24.         }  
25.         finally  
26.         {  
27.             if(bufw!=null)  
28.             {  
29.                 try  
30.                 {  
31.                     bufw.close();  
32.                 }  
33.                 catch (IOException e)  
34.                 {  
35.                     throw new RuntimeException("写入关闭异常");  
36.                 }  
37.             }  
38.             if(bufr!=null)  
39.             {  
40.                 try  
41.                 {  
42.                     bufr.close();  
43.                 }  
44.                 catch (IOException e)  
45.                 {  
46.                     throw new RuntimeException("读取关闭异常");  
47.                 }  
48.             }  
49.         }  
50.     }  
51. }  

2.3 LineNumberReader 

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

[java]  view plain copy

1. import java.io.*;  
2. class  LineNumberReaderDemo  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         FileReader fr = null;  
7.         LineNumberReader lnr = null;  
8.         try  
9.         {  
10.             fr = new FileReader("CopyTest.java");  
11.             lnr = new LineNumberReader(fr);  
12.   
13.             String line = null;  
14.             lnr.setLineNumber(10); //行号从11开始  
15.             while((line=lnr.readLine())!=null)  
16.             {  
17.                 System.out.println(lnr.getLineNumber()+":  "+line);  
18.             }  
19.         }  
20.         catch (IOException e)  
21.         {  
22.             throw new RuntimeException("读写异常");  
23.         }  
24.         finally  
25.         {  
26.             try  
27.             {  
28.                 if(lnr!=null)  
29.                     lnr.close();  
30.                 try  
31.                 {  
32.                     if(fr!=null)  
33.                         fr.close();  
34.                 }  
35.                 catch (IOException e)  
36.                 {  
37.                     throw new RuntimeException("关闭读取异常");  
38.                 }  
39.             }  
40.             catch (IOException e)  
41.             {  
42.                 throw new RuntimeException("关闭读取异常");  
43.             }  
44.         }  
45.     }  
46. }  

2.4 装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类

1、装饰类通常会通过构造方法接受被装饰的对象

2、装饰类比继承要灵活，避免了继承体系的臃肿而且降低了类与类之间的关系

3、装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能

所以装饰类和被装饰类通常是属于一个体系中的

[java]  view plain copy

1. class  SuperPerson  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         Person p = new Person();  
6.         PersonUp pu = new PersonUp(p);  
7.         pu.chifanUp();  
8.     }  
9. }  
10. class Person  
11. {  
12.     public void chifan()  
13.     {  
14.         System.out.println("吃米饭");  
15.     }  
16. }  
17. class PersonUp  //装饰类  
18. {  
19.     private Person p;  
20.     PersonUp(Person p)  
21.     {  
22.         this.p = p;  
23.     }  
24.     public void chifanUp()  
25.     {  
26.         System.out.println("吃开胃菜");  
27.         p.chifan();  
28.         System.out.println("饭后甜点");  
29.     }  
30. }  

三、字节流

基本操作与字符流类相同。但它不仅可以操作字符，还可以操作其他媒体文件。

字节流操作最小的数据单位，不需要刷新。

基类：InputStream(输入)  OutputStream(输出)

练习：复制一张图片

[java]  view plain copy

1. import java.io.*;  
2. class  CopyPicture  
3. {  
4.     public static void main(String[] args)   
5.         FileOutputStream fos = null;  
6.   
7.         FileInputStream fis = null;  
8.         try  
9.         {  
10.             fos =  new FileOutputStream("Copy.png");  
11.             fis = new FileInputStream("copy1.png");  
12.             byte[] buf = new byte[1024*1024];//用于缓冲数据  
13.             int len = 0;  
14.             while((len=fis.read(buf))!=-1)  
15.             {  
16.                 fos.write(buf,0,len);  
17.             }  
18.         }  
19.         catch (IOException e)  
20.         {  
21.             throw new RuntimeException ("读写失败");  
22.         }  
23.         finally  
24.         {  
25.             try  
26.             {  
27.                 if(fos!=null)  
28.                     fos.close();  
29.             }  
30.             catch (IOException e)  
31.             {  
32.                 throw new RuntimeException ("写入关闭失败");  
33.             }  
34.             try  
35.             {  
36.                 if(fis!=null)  
37.                     fis.close();  
38.             }  
39.             catch (IOException e)  
40.             {  
41.                 throw new RuntimeException ("读取关闭失败");  
42.             }  
43.         }  
44.     }  
45. }  

3.1 字节流缓冲区

字节流的缓冲区：同样是提高了字节流的读写效率。

读写特点：

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

   write()：会将int型强转为byte型，即保留二进制数的最后八位。

练习：自定义字节流缓冲区

[java]  view plain copy

1. import java.io.*;  
2. class  myBufferedInputStream  
3. {  
4.     private InputStream in;  
5.     private byte[] buf = new byte[1024];  
6.     private int pos = 0,count = 0;  
7.     myBufferedInputStream(InputStream in)  
8.     {  
9.         this.in = in;  
10.     }  
11.     //自定义读方法，一次读一个字节  
12.     public int myread() throws IOException  
13.     {  
14.         if(count==0)  
15.         {    
16. //通过in对象读取硬盘上数据，并存储by中。    
17. //存储在数组中的数据被读取完，再通过in对象从硬盘上读取数据   
18.             count = in.read(buf);  
19.             if(count<0)//文件数据全部被读取出来了    
20.                 return -1;  
21.             pos = 0;  
22.             byte b = buf[pos];  
23.             count--;  
24.             pos++;  
25.             return b&255;  
26.         }  
27.         else if(count>0)  
28.         {  
29.             byte b = buf[pos];  
30.             count--;  
31.             pos++;  
32.             return b&0xff;  
33.         }  
34.         return -1;  
35.     }  
36.   
37.     public void myclose() throws IOException  
38.     {  
39.         in.close();  
40.     }  
41. }  

四、 流的操作规律

4.1键盘录入

键盘本身就是一个标准的输入设备。对于java而言，对于这种输入设备都有对应的对象。

标准输入输出流

    System.in：对应的标准输入设备，键盘。

    System.out：对应的是标准的输出设备，控制台。

    System.in的类型是InputStream.

    System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。 

4.2 转换流

能不能直接用readLine方法来完成键盘录入一行数据的读取呢

readLine是字符流BufferedReader类中的方法

而键盘录入的read方法是字节流InputStream类中的方法

能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢

InputStreamReader 是字节流通向字符流的桥梁，解码

OutputStreamWriter 是字符流通向字节流的桥梁，编码

字节流处理的是文本数据，可以转换成字符流，操作更方便。

练习：获取用户键盘录入的数据并将数据变成大写显示在控制台上，如果用户输入的是over，结束键盘录入。

[java]  view plain copy

1. import java.io.*;  
2. class  ReadIn  
3. {  
4.     public static void main(String[] args)  throws IOException  
5.     {  
6.         //获取键盘录入对象  
7.         //InputStream in = System.in;  
8.           
9.         //将字节流对象转换成字符流对象，使用转换流InputStreamReader,  
10.                 //InputStreamReader 是字节流通向字符流的桥梁  
11.         //InputStreamReader isr = new InputStreamReader(in);  
12.           
13.         //为了提高效率。将字符串进行缓冲区技术高效操作，使用BufferedReader  
14.         //BufferedReader br = new BufferedReader(isr);  
15.   
16.         BufferedReader br =   
17.                 new BufferedReader(new InputStreamReader(System.in));//键盘录入最常见写法  
18.   
19.           
20.         //OutputStream out = System.out;  
21.         //OutputStreamWriter osw = new OutputStreamWriter(out);  
22.         //BufferedWriter buw = new BufferedWriter(osw);  
23.   
24.         BufferedWriter buw = new BufferedWriter(  
25.             new OutputStreamWriter(System.out));  
26.   
27.         String line = null;  
28.         while((line=br.readLine())!=null)  
29.         {  
30.             if("over".equals(line))  
31.                 break;  
32.             buw.write(line.toUpperCase());  
33.             buw.newLine();  
34.             buw.flush();  
35.         }  
36.         br.close();  
37.     }  
38. }  

4.3 IO流操作规律

流的对象很多，不知道该用哪一个，通过3个明确来完成

1.明确源和目的

源：输入流 InputStream  Reader

目的： 输出流 OutputStream  Writer

2.操作的数据是否是纯文本

是：字符流

不是：字节流

 3.当体系明确后，再明确要使用哪个具体的对象。通过设备来进行区分：

        源设备：内存，硬盘，键盘

        目的设备：内存，硬盘，控制台

示例：将键盘录入的数据保存到一个文件中。

源：InputStream和Reader

是不是纯文本？是，Reader

设备：键盘。对应的对象是System.in。为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。所以既然明确了Reader，那么就将System.in转换成Reader。用Reader体系中转换流,InputStreamReader

     InputStreamReaderisr = new InputStreamReader(System.in);

需要提高效率吗？需要，BufferedReader

     BufferedReaderbufr = new BufferedReader(isr);

4.4 字符编码

字符流的出现方便了操作字符，更重要的是加入了编码转换

通过子类转换流来完成

InputStreamReader

OutputStreamWriter

在两个对象构造时可以加入字符集

[java]  view plain copy

1. import java.io.*;  
2. class  EncodeStream  
3. {  
4.     public static void main(String[] args)  throws IOException  
5.     {  
6.         readText();  
7.     }  
8.   
9.     public static void readText() throws IOException  
10.     {  
11.         InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"GBK");  
12.         char[] buf = new char[10];  
13.         int len = 0;  
14.         len = isr.read(buf);  
15.         String str = new String(buf,0,len);  
16.         System.out.println(str);  
17.         isr.close();  
18.     }  
19.     public static void writeText() throws IOException  
20.     {  
21.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");  
22.         osw.write("你好");  
23.         osw.close();  
24.     }  
25. }  

原因分析：由于utf.txt文件中是UTF-8编码的“你好”，6个字节。

使用FileReader类是用GBK编码进行读取，6个字节代表3个字符，并且按照GBK进行解码，因此才出现如上结果。

五、File类

File类用来将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。File对象可以作为参数传递给流的构造函数。流只能操作数据，不能操作文件。

File对象创建

方式一：      File f =new File("a.txt");

  将a.txt封装成File对象。可以将已有的和未出现的文件或者文件夹封装成对象。

 方式二： File f2=newFile("c:\\abc","b.txt");

     将文件所在目录路径和文件一起传入，指定文件路径。

 方式三： File d=new File("c:\\abc");

          File f3=new File(d,"c.txt");

    将文件目录路径封装成对象。再创建文件对象。降低了文件于父目录的关联性。

小知识：

        File.separator表示目录分隔符，可以跨平台使用。相当于路径中的“\”（双斜杠\\在windows中表示表示转义后的分隔符，但是在linux系统中就不是）。

 File类常见方法

1.创建

boolean createNewFile() 指定位置创建文件，存在则返回flase

boolean mkdir() 创建此抽象路径名指定的目录。      

boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

2.删除

 boolean delete() 删除此抽象路径名表示的文件或目录

 void deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。

3.判断

boolean exists() 测试此抽象路径名表示的文件或目录是否存在。 

    boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。

    boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。

    isHidden()

isAbsolute()  

4.获取信息

String getName()

String getPath()

String getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名

没有指定父目录，则返回 null。 

    File getParentFile()  返回此抽象路径名父目录的抽象路径名；

如果此路径名没有指定父目录，则返回 null

File getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。

    String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。

long lastModified()

long length()

 5、列出文件及文件过滤

static File[] listRoots(); //列出可用的文件系统根目录，即系统盘符

String[] list(); //列出当前目录下所有文件，包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录还必须存在。

String[]list(FilenameFilter filter); //返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。

File[] listFiles();//返回一个抽象路径名数组，获取当前文件夹下的所有文件和文件夹

File[] ListFiles(FilenameFilterfilter);//返回抽象路径名数组，获取目录中满足指定过滤器的文件或目录。

练习：常用方法操作

[java]  view plain copy

1. import java.io.*;  
2. class  FileDemo2  
3. {  
4.     public static void main(String[] args) throws IOException  
5.     {  
6.         method_5();  
7.     }  
8.   
9.     public static void method_1() throws IOException  
10.     {  
11.           
12.         File f = new File("e:\\file.txt");  
13.         File dir = new File("e:\\zz");  
14.         sop("mkdir:"+dir.mkdir());  
15.         sop("creat:"+f.createNewFile());  
16.           
17.         sop("delete:"+f.delete());  
18.         sop("exists:"+dir.exists());  
19.     }  
20.     public static void method_2()  
21.     {  
22.         File f = new File("e:\\file.txt");  
23.         sop("execute:"+f.canExecute());  
24.     }  
25.     public static void method_3()  
26.     {  
27.         //在判断文件对象是目录或者文件时，必须要先判断该文件对象封装的内容是否存在  
28.         //用exists判断  
29.         File f = new File("file.txt");  
30.         f.mkdir();  
31.         sop("Directory:"+f.isDirectory());  
32.         sop("File:"+f.isFile());  
33.     }  
34.     public static void method_4()  
35.     {  
36.         File f = new File("file.txt");  
37.         sop("path:"+f.getPath());  
38.         sop("Abspath:"+f.getAbsolutePath());  
39.         sop("parent:"+f.getParent()); //该方法返回的是绝对路径中的父目录，如果获取相对路径返回上一层目录或null  
40.         sop(f.length());  
41.         sop(f.lastModified());  
42.       
43.     }  
44.     public static void method_5() throws IOException  
45.     {  
46.         File f1 = new File("e:\\file.txt");  
47.         File f2 = new File("e:\\file22.txt");  
48.         f1.createNewFile();  
49.         sop(f1.renameTo(f2));  
50.   
51.     }  
52.     public static void sop(Object obj)  
53.     {  
54.         System.out.println(obj);  
55.     }  
56. }  

练习：获取一个目录下所有的.java文件

[java]  view plain copy

1. import java.io.*;  
2. class  FileDemo3  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         listDemo_1();  
7.     }  
8.     public static void listDemo_1()//获取文件名称，返回字符串，不能对文件进行操作  
9.     {  
10.         File f = new File("C:\\Users\\JXH\\Desktop\\java\\day13");  
11.         String[] st = f.list(new FilenameFilter()  
12.         {  
13.             public boolean accept(File dir, String name)  
14.             {  
15.                 return name.endsWith(".java");  
16.             }  
17.         });  
18.         for(String s:st)  
19.         {  
20.             System.out.println(s);  
21.         }  
22.     }  
23. }  

六、打印流

PrintWriter与PrintStream：可以直接操作输入流和文件。

PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

与其他输出流不同，PrintStream永远不会抛出IOException。

PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。

在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。

PrintStream:字节打印流

1. 提供了打印方法可以对多种数据类型值进行打印，并保持数据的表示形式

2. 它不抛IOException

构造函数，接收三种类型的值：

1. 字符串路径

2. File对象

3. 字节输出流

PrintWriter：字符打印流

构造函数参数：

1. 字符串路径

2. File对象

3. 字节输出流

4. 字符输出流

[java]  view plain copy

1. import java.io.*;  
2. import java.util.*;  
3. class  PrintWriterDemo  
4. {  
5.     public static void main(String[] args)  throws IOException  
6.     {  
7.         BufferedReader bufr =   
8.             new BufferedReader(new InputStreamReader(System.in));  
9.   
10.         PrintWriter out = new PrintWriter(System.out,true);  
11.   
12.         String line = null;  
13.   
14.         while((line=bufr.readLine())!=null)  
15.         {  
16.             if("over".equals(line))  
17.                 break;  
18.               
19.             out.println(line.toUpperCase());  
20.             //out.flush();  
21.         }  
22.   
23.         out.close();  
24.         bufr.close();  
25.   
26.     }  
27. }  

七、序列流

SequenceInputStream：对多个流进行合并。

常用构造函数 SequenceInputStream(Enumeration<?extends FileInputStream> e)

[java]  view plain copy

1. import java.io.*;  
2. import java.util.*;  
3. class  SequenceDemo  
4. {  
5.     public static void main(String[] args) throws IOException  
6.     {  
7.         Vector<FileInputStream> v = new Vector<FileInputStream>();  
8.   
9.         v.add(new FileInputStream("1.txt"));  
10.         v.add(new FileInputStream("2.txt"));  
11.         v.add(new FileInputStream("3.txt"));  
12.   
13.         Enumeration<FileInputStream> en = v.elements();  
14.         SequenceInputStream sis = new SequenceInputStream(en);  
15.         FileOutputStream fos = new FileOutputStream("4.txt");  
16.   
17.         byte[] buf = new byte[1024];  
18.         int len = 0;  
19.         while((len=sis.read(buf))!=-1)  
20.         {  
21.             fos.write(buf,0,len);  
22.         }  
23.   
24.         fos.close();  
25.         sis.close();  
26.     }  
27. }