黑马程序员-----IO流

1.初识IO流

        IO是Input%Output的缩写，即输入和输出。简单理解，就是通过IO流可以实现对硬盘数据或者键盘录入数据（内存数据）进行操作。

         那么，IO流的体系？

        从流向分，IO里有写入流（Writer和OutputStream：WO）和输出流（Read和InputStream：RI）。

        按操作数据类型分，有字符流（Writer和Read：W、R）和字节流（OutputStream和InputStream：O、I）。

        而由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

        字符流和字节流相比，有两个不同，一个是流式传输的时候传输协议不同，因为传输的数据单位改变了；二是字符流还带有编解码的功能，我们的字符数据在 java 程序里面是以 unicode 编码的形式存在，字符流可以对我们程序中的字符再编码，编码为 utf-8 、gbk 等，可以对其他设备传过来的数据解码，把 utf-8、gbk 等编码解码为 unicode 码。

2.代码示例            

 1、先用FileWriter来简单了解下IO流的基本操作。

[java] view plaincopy

1. // 创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。而且该文件会被创建到指定目录  
2. // 下。如果该目录下已有同名文件，默认将被覆盖。其实该步就是在明确数据要存放的目的地。File类关于文  
3. // 件创建有更多的方式  
4. FileWriter fw = new FileWriter("Test.txt");  
5. // 调用write方法，将字符串写入到流中。  
6. fw.write("abcde");  
7. // 刷新流对象中的缓冲中的数据。  
8. // 将数据刷到目的地中。  
9. fw.flush();  
10. // 关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。  
11. // 将数据刷到目的地中。  
12. // 和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。  
13. fw.close();  

close()和flush()的区别：

flush()：将缓冲区的数据刷到目的地中后，流可以使用。

close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

io异常的处理方式：io一定要写finally；

注：FileWriter可以对已有文件进行续写，构造方法为

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

2. 复制txt文件

示例代码中，演示了IO流的异常处理方式，并用了三种方法来执行文本的复制

[java] view plaincopy

1. //导包动作必须做，否则会出现大片错误提示  
2. import java.io.*;  
3.    
4. class FileReaderDemo  
5. {  
6.        publicstatic void main(String[] args)  
7.        {  
8.               //创建文件读取流和写入流对象，初始化为null。  
9.               FileReader fr = null;  
10.               FileWriter fw=null;  
11.             try    
12.             {    
13.                 fr= new FileReader("source.txt");  //源  
14.                 fw=new FileWriter ("dest.txt");//目的  
15.   
16.                 //方法一：通过字符读取  
17.                 int ch = 0;  
18.                 while((ch=fr.read())!=-1)//调用读取流对象的read方法。返回值为-1时，表示结束到末尾。  
19.                 {  
20.                      fw.write(ch);  
21.                 }  
22.   
23.                 //方法二：通过自定义字符数组读取  
24.                 char[]buf = new char[1024];    
25.   
26.                 int len = 0;    
27.   
28.                 while((num=fr.read(buf))!=-1)    
29.                 {    
30.                     fw.write(buf,0,len);    
31.                 }    
32.   
33.                 //方法三：字符流缓冲区  
34.                 //用此方法时，在finnaly中需要关闭的流是bufr和bufw  
35.                 BufferedReader bufr=new BufferedReader (fr);  
36.                 BufferedWriter bufw=new BufferedWriter(fw);  
37.   
38.                 String line =null;  
39.   
40.                 while ((line=bufr.readLine())!=null)  
41.                 {  
42.                     bufw.write(line);  
43.                     bufw.newLine();  
44.                     bufw.flush();//用到缓冲流就需要刷新  
45.                 }  
46.             }    
47.             catch(IOException e)    
48.             {    
49.                 throw new RuntimeException("复制文件失败");    
50.             }    
51.             finally  //必须执行关流动作  
52.             {    
53.                  try    
54.                  {    
55.                     if(fr!=null)    
56.                         fr.close();  
57.                  }    
58.                  catch(IOException e)    
59.                  {    
60.                      throw new RuntimeException("读取文件失败");    
61.                  }    
62.                  try    
63.                  {    
64.                      if(fw!=null)  
65.                         fw.close();                   
66.                  }    
67.                  catch(IOException e)    
68.                  {    
69.                      throw new RuntimeException("写入文件失败");    
70.                  }    
71.        }  
72. }  

注：此处示例中方法三用到了缓冲字符流，因为这里是txt文件。如果需要复制图片、mp3、视频等需要使用的缓冲流为缓冲字节流，即：BufferedOutputStream和BufferedInputStream。

3.自定义字节流的缓冲区

[java] view plaincopy

1. import java.io.*;  
2.    
3. class MyBufferedInputStream  
4. {  
5.        private InputStream in;  
6.    
7.        private byte[] buf = new byte[1024*4];  
8.               
9.        private int pos = 0,count = 0;  
10.        
11.        MyBufferedInputStream(InputStream in)  
12.        {  
13.               this.in= in;  
14.        }  
15.    
16.        //一次读一个字节，从缓冲区(字节数组)获取。  
17.        public int myRead()throws IOException  
18.        {  
19.               //通过in对象读取硬盘上数据，并存储buf中。  
20.               if(count==0)  
21.               {  
22.                      count= in.read(buf);  
23.                      if(count<0)  
24.                             return-1;  
25.                      pos= 0;  
26.                      byte b = buf[pos];  
27.    
28.                      count--;  
29.                      pos++;  
30.                      return b&255;//取最低八位  
31.               }  
32.               else if(count>0)  
33.               {  
34.                      byte b = buf[pos];  
35.                      count--;  
36.                      pos++;  
37.                      return b&0xff; //十六进制的255  
38.               }  
39.               return -1;  
40.    
41.        }  
42.        public void myClose()throws IOException  
43.        {  
44.               in.close();  
45.        }  
46. }  

4.读取键盘录入

需求：

通过键盘录入数据。

当录入一行数据后，就将该行数据进行打印。

如果录入的数据是over，那么停止录入。

[java] view plaincopy

1. import java.io.*;  
2. class ReadIn  
3. {  
4.        publicstatic void main(String[] args)throws IOException  
5.        {  
6.               InputStreamin = System.in;  
7.               StringBuildersb = newStringBuilder();  
8.    
9.               while(true)  
10.               {  
11.                      intch = in.read();  
12.                      if(ch=='\r')  
13.                             continue;  
14.                      if(ch=='\n')  
15.                      {  
16.                             Strings = sb.toString();  
17.                            if("over".equals(s))  
18.                                    break;  
19.                            System.out.println(s.toUpperCase());  
20.                            sb.delete(0,sb.length());  
21.                      }  
22.                      else  
23.                            sb.append((char)ch);  
24.    
25.               }  
26.        }  
27. }  

5、上述的键盘录入方法是按字节来读取的，比较慢，而readLine方法又属于字符流的派系，那么我们就需要引入转换流的概念

读取转换流InputStreamReader

InputStreamReader是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

每次调用InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。

为了达到最高效率，可要考虑在BufferedReader 内包装InputStreamReader。例如：

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

----------------------------------------------------------------------------------------------------

写入转换流OutputStreamWriter

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。

为了获得最高效率，可考虑将OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。例如：

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

红色的两行代码是在获取键盘录入时最常用的方法。

3.流对象总结

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。

流的操作规律：

1，明确源和目的。

       数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

       数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

       如果是：数据源：Reader

                  数据汇：Writer

       如果不是：数据源：InputStream

                    数据汇：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

       明确操作的数据设备。

       数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

       数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4，需要在基本操作上附加其他功能吗？比如缓冲。

       如果需要就进行装饰。

转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于字节流 +编码表。没有转换，没有字符流。

发现转换流有一个子类就是操作文件的字符流对象：

InputStreamReader

       |--FileReader

OutputStreamWriter

       |--FileWrier

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

FileReader fr = new FileReader("a.txt");

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File =字节流 +默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

四、File类

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

了解file类中的常用方法。

separator(跨平台的目录分隔符==\\)与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

File类常见方法：

1，创建

boolean creatNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

static File   createTempFile(String prefix,String suffix)在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

static File   createTempFile(String prefix,String suffix，File directory)在指定文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖

boolean mkdir();创建文件夹

boolean mkdirs();创建多级文件夹

2，删除

boolean delete():删除失败返回false

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

3，判断

boolean compareTo(File pathname)按字母顺序比较两个抽象路径名。

boolean exists():文件是否存在

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

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

isHidden();/测试此文件是否是一个隐藏文件。

isAbsolute();测试此抽象路径名是否为绝对路径名。

4，获取信息

getName();获取名称

getPath()将此抽象路径名转换为一个路径名字符串。

getParent();返回此抽象路径名父目录的路径名字符串，如果此路径名没有指定父目录，则返回null.

getParentFile()返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null.

getAbsolutePath();返回的是绝对路径名字符串

getAbsoluteFile();返回绝对路径名形式

long  length()返回由此抽象路径名表示的文件的长度。

long  lastModified() 返回最后一次被修改的时间。

5、List

static File listRoots():列出可用的文件系统根，

String[]list(FilenameFilter filter):返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录

list():返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

listFiles():返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

File[] listFiles(FileFilter filter):返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

File[] listFiles(FilenameFilter filter):返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

FilenameFilter:接口，实现此接口的类实例可用于过滤器文件名

boolean accept(File dir,String name):测试指定文件是否应该包含在某一文件列表中。

☆函数递归

函数递归又叫函数嵌套，是指在函数定义的时候调用函数自己

注意：递归时一定要明确结束条件。 
应用场景：当某一功能要重复使用时，可以使用函数递归，函数递归的好处是简化了算法的描述方法，但是是因为函数压栈弹栈，和循环相比降低了程序的运行效率

递归要注意：
  1、限定条件。
  2、要注意递归的次数。尽量避免内存溢出。

函数递归使用实例一：列出指定目录下文件或者文件夹，包含子目录中的内容。

列出指定目录下所有内容。因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数调用自己。这种表现形式，或者编程手法，就称为递归。

[java] view plaincopy

1. //要求：列出指定目录下文件或者文件夹，包含子目录中的内容  
2. import java.io.*;  
3. public class FileDemo3   
4. {  
5.     public static void main(String[] args)  
6.     {  
7.        File dir=new File("d:\\java123");  
8.        showDir(dir,0);  
9.        /*  toBin(6); 
10.        int n=getSum(10); 
11.        System.out.println("n:"+n);*/  
12.     }  
13.     public static String getLevel(int level)  
14.     {  
15.         StringBuilder sb=new StringBuilder();  
16.         sb.append("|--");  
17.         for(int x=0;x<level;x++)  
18.         {  
19.                             //sb.append("!===");  
20.             sb.insert(0, "!--");  
21.         }  
22.         return sb.toString();  
23.     }  
24.     public static void showDir(File dir,int level)  
25.     {   
26.         System.out.println(getLevel(level)+dir.getName());  
27.         level++;  
28.         File[] files=dir.listFiles();  
29.         for(int x=0;x<files.length;x++)  
30.         {  
31.             if(files[x].isDirectory())  
32.                 showDir(files[x],level);  
33.             else  
34.                 System.out.println(files[x]);  
35.         }  
36.     }  
37. }  

函数递归使用实例二：删除一个带内容的目录

[java] view plaincopy

1. import java.io.*;  
2. public class RemoveDir {  
3.     public static void main(String[] args) {  
4.         File dir=new File("d:\\testdir");  
5.         removeDir(dir);  
6.     }  
7.     public static void removeDir(File dir)  
8.     {  // if(dir.exists())  
9.         File[] files=dir.listFiles();  
10.         for(int x=0;x<files.length;x++)  
11.         {  
12.             if(/*!files[x].isHidden()不是隐藏的&&*/files[x].isDirectory())  
13.                 removeDir(files[x]);  
14.             //else  
15.             System.out.println(files[x].toString()+":file:"+files[x].delete());  
16.         }  
17.         System.out.println(dir+"::dir::"+dir.delete());  
18.     }  
19. }  

递归使用实例三：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中，建立一个java文件列表文件

[java] view plaincopy

1. /* 
2. 思路： 
3.  
4.     1，对指定的目录进行递归 
5.  
6.     2，获取递归过程所有的java文件的路径 
7.  
8.     3，将这些路径存储到集合中。 
9.  
10.     4，将集合中的数据写入到一个文件中。 
11. */  
12. import java.io.*;  
13. import java.util.*;  
14. public class JavaFileList {  
15.     public static void main(String[] args) {  
16.         File dir=new File("d:\\java123");  
17.         List<File>list=new ArrayList<File>();  
18.         fileToList(dir,list);  
19.                   //System.out.println(list.size());  
20.         File file=new File(dir,"javalist.txt");  
21.         writerToFile(list,file.toString());  
22.     }  
23.     public static void fileToList(File dir,List<File> list)  
24.     {  
25.         File[] files=dir.listFiles();  
26.         for(File file:files)  
27.         {  
28.             if(file.isDirectory())  
29.                 fileToList(file,list);  
30.             else  
31.             {  
32.                 if(file.getName().endsWith(".java"))  
33.                     list.add(file);  
34.             }  
35.         }  
36.     }  
37.     public static void writerToFile(List<File>list,String javaListFile)  
38.     {  
39.         BufferedWriter bufw=null;  
40.         try {  
41.             bufw = new BufferedWriter(new FileWriter(javaListFile));  
42.             for (File f : list) {  
43.                 String path = f.getAbsolutePath();  
44.                 bufw.write(path);  
45.             }  
46.         } catch (IOException e) {  
47.             throw new RuntimeException();  
48.         }  
49.         finally{  
50.         try {     
51.                 if(bufw!=null)  
52.                     bufw.close();  
53.             } catch (Exception e2) {  
54.                 throw new RuntimeException();  
55.             }  
56.         }  
57.     }  
58. }  

5.配置文件

要求：定义配置文件，记录软件使用次数，超过五次给出提示

[java] view plaincopy

1. import java.util.*;  
2. import java.io.*;  
3. public class RunCount {  
4.     public static void main(String[] args) throws IOException  
5.     {  
6.         Properties prop=new Properties();  
7.         File file=new File("count.ini");  
8.         if(!file.exists())  
9.             file.createNewFile();  
10.         FileInputStream fis=new FileInputStream(file);  
11.         prop.load(fis);//流中的数据加载到集合中。  
12.         int count=0;  
13.         String value=prop.getProperty("time");//time键获取值。  
14.         if(value!=null)  
15.          {count=Integer.parseInt(value);//count记录次数。  
16.             if(count>=5)  
17.             {  
18.                 System.out.println("你好，使用次数已到");  
19.                 return;  
20.             }  
21.          }  
22.         count++;  
23.         prop.setProperty("time", count+"");  
24.         FileOutputStream fos=new FileOutputStream(file);//写回去。  
25.         prop.store(fos, "");//注册信息。  
26.         fos.close();  
27.         fis.close();  
28.     }  
29. }  

6.序列流： SequenceInputStream，对多个流进行合并

操作对象

ObjectInputStream与 ObjectOutputStream被操作的对象需要实现Serializable(标记接口)

SequenceInputStream 表示其他输入流的逻辑串联，它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。多个文件合并成一个文件。

练习：文件分割程序

[java] view plaincopy

1. import java.io.*;  
2. import java.util.*;  
3. public class SequenceDemo {  
4.     public static void main(String[] args) throws IOException  
5.     {  
6.         Vector<FileInputStream> v=new Vector<FileInputStream>();  
7.         v.add(new FileInputStream("c:\\1.tdt"));  
8.         v.add(new FileInputStream("c:\\2.tdt"));  
9.         v.add(new FileInputStream("c:\\3.tdt"));  
10.         Enumeration<FileInputStream>en=v.elements();  
11.         SequenceInputStream sis=new SequenceInputStream(en);//将多个读取流合并成一个流  
12.         FileOutputStream fos=new FileOutputStream("c:\\4.txt");  
13.         byte[]buf=new byte[1024];  
14.         int len=0;  
15.         while((len=sis.read(buf))!=-1)  
16.         {  
17.             fos.write(buf,0,len);  
18.         }  
19.         fos.close();  
20.         sis.close();  
21.     }  
22. }  
23. 切割文件  
24. import java.util.*;  
25. import java.io.*;  
26. public class splitFile {  
27.     public static void main(String[] args)throws IOException  
28.     {     merge();  
29.     //  splitFile();  
30.     }  
31.     public static void merge() throws IOException  
32.     { ArrayList<FileInputStream>al=new ArrayList<FileInputStream>();  
33.       for(int x=1;x<=3;x++)  
34.       {  
35.           al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));  
36.       }  
37.      final Iterator<FileInputStream>it=al.iterator();  
38.       Enumeration<FileInputStream>en=new Enumeration<FileInputStream>()  
39.      {  
40.           public boolean hasMoreElements()  
41.           {  
42.               return it.hasNext();  
43.           }  
44.           public FileInputStream nextElement()  
45.           {  
46.               return it.next();  
47.           }  
48.     };  
49.     SequenceInputStream sis=new SequenceInputStream(en);  
50.     FileOutputStream fos=new FileOutputStream("c:\\splitfiles\\0.jpg");  
51.     byte[] buf=new byte[1024];  
52.     int len=0;  
53.     while((len=sis.read(buf))!=-1)  
54.     {  
55.         fos.write(buf,0,len);  
56.     }  
57.     fos.close();  
58.     sis.close();  
59.     }  
60.    public static void splitFile() throws IOException  
61.    {  
62.        FileInputStream fis=new FileInputStream("c:\\1.jpg");//关联文件  
63.        FileOutputStream fos=null;  
64.        byte[] buf=new byte[1024*1024];//创建缓冲区。  
65.        int len=0;  
66.        int count=1;  
67.        while((len=fis.read(buf))!=-1)  
68.        {  
69.            fos=new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");  
70.            fos.write(buf,0,len);//写入流里面去。  
71.            fos.close();  
72.        }  
73.        fis.close();  
74.    }  
75. }  

对象的序列化：目的：将一个具体的对象进行持久化，写入到硬盘上。

注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。

如何将非静态的数据不进行序列化？用transient 关键字修饰此变量即可。

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。