java中的IO操作

转自：http://www.zaojiahua.com/1453.html

在使用io操作之前，先看一下java中的文件类File如何使用。File包括文件和目录，对文件和目录的操作是新建目录mkdir，新建文件createNewFile，删除文件和目录delete，以及其他的一些操作。

1 package zaojiahua;
2
3 import java.io.File;
4 import java.io.IOException;
5
6 /* 对文件类的操作 */
7 public class Test
8 {
9     public static void main(String[] args) throws IOException
10     {
11         //新建一个目录
12         File file = new File("1/2");
13         //判断目录是否存在
14         if(!file.exists())
15         {
16             //创建多层目录
17             file.mkdirs();
18         }
19
20         //创建文件
21         File file2 = new File(file,"1.txt");
22         file2.createNewFile();
23
24         //创建文件
25         File file3 = new File("2.txt");
26         file3.createNewFile();
27         //获取文件的绝对路径
28         System.out.println(file3.getAbsolutePath());
29         System.out.println(file2.getParent());
30         //删除目录
31         file.delete();
32
33         File file4 = new File("1/3");
34         //遍历目录中的文件和目录，是单层遍历
35         String str[] = file4.list();
36         for(String s : str)
37         {
38             System.out.println(s);
39         }
40
41         //列出一个目录下的所有文件
42         System.out.println("**********************listAll**********************");
43         listAll(file4);
44     }
45
46     static void listAll(File filename)
47     {
48         if(filename.isDirectory())
49         {
50             File fileDir [] = filename.listFiles();
51             for(File file : fileDir)
52             {
53                 if(file.isDirectory())
54                 {
55                     System.out.println("目录:"+file);
56                     listAll(file);
57                 }
58                 else
59                     System.out.println("文件:"+file);
60             }
61         }
62         else
63         {
64             System.out.println("文件:"+filename);
65         }
66     }
67
68 }

接下来是java中IO类的操作，IO分类如下图所示，这里只说几个常用的。

首先是FileInputStream和FileOutputStream，这一对流是对文件进行读写的，读写方法是从父类inputStream和OutputStream继承下来的read和write方法。

1 package com.zaojiahua.iodemo;
2
3 import java.io.File;
4 import java.io.FileInputStream;
5 import java.io.FileOutputStream;
6 import java.io.IOException;
7
8 public class Test {
9
10     public static void main(String[] args) throws IOException {
11
12         File file = new File("file.txt");
13         //实现数据的拷贝
14         FileInputStream inputStream = new FileInputStream(file);
15         FileOutputStream outputStream = new FileOutputStream("1.txt");
16
17 //      int i;
18 //      while((i = inputStream.read() ) != -1)
19 //      {
20 //          //read的返回值是int，如果遇到了文件尾则返回-1
21 //          outputStream.write(i);
22 //      }
23
24         //或者使用如下的方法
25         byte [] buf = new byte[1024];
26         int len = -1;
27         while((len = inputStream.read(buf)) != -1)
28         {
29             outputStream.write(buf);
30         }
31
32         inputStream.close();
33         outputStream.close();
34     }
35
36 }

BufferedInputStream对外提供滑动读取的功能实现，通过预先读入一整段原始输入流数据至缓冲区中，而外界对BufferedInputStream的读取操作实际上是在缓冲区上进行，如果读取的数据超过了缓冲区的范围，那么BufferedInputStream负责重新从原始输入流中载入下一截数据填充缓冲区，然后外界继续通过缓冲区进行数据读取。这样的设计的好处是：避免了大量的磁盘IO，因为原始的InputStream类实现的read是即时读取的，即每一次读取都会是一次磁盘IO操作（哪怕只读取了1个字节的数据），可想而知，如果数据量巨大，这样的磁盘消耗非常可怕。而通过缓冲区的实现，读取可以读取缓冲区中的内容，当读取超过缓冲区的内容后再进行一次磁盘IO，载入一段数据填充缓冲，那么下一次读取一般情况下就直接可以从缓冲区读取，减少了磁盘IO。说白了buffered就是用来缓存的，可以用来提高读取的效率，之所以说FileInputStream是阻塞的方法是因为CUP的速度和磁盘的速度是不匹配的，如果每次要读取的时候都访问磁盘这样就造成了阻塞。通过以上的说明可以看出buffered则并不是阻塞的。所以我们读取文件的时候一般都在文件流上边套上一层buffer流。

1 package com.zaojiahua.iodemo;
2
3 import java.io.BufferedInputStream;
4 import java.io.BufferedOutputStream;
5 import java.io.File;
6 import java.io.FileInputStream;
7 import java.io.FileOutputStream;
8 import java.io.IOException;
9
10 public class Test {
11
12     public static void main(String[] args) throws IOException {
13
14         File file = new File("file.txt");
15         //使用buffer实现数据的拷贝
16         BufferedInputStream input = new BufferedInputStream(new FileInputStream(file));
17         BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream("1.txt"));
18
19         //或者使用如下的方法
20         byte [] buf = new byte[1024];
21         int len = -1;
22         while((len = input.read(buf)) != -1)
23         {
24             output.write(buf,0,len);
25             //将读取到的字节数据转化为字符串打印出来
26             String str = new String(buf,0,len);
27             System.out.println(str);
28         }
29
30         //关闭流
31         input.close();
32         output.close();
33     }
34
35 }

数据在硬盘上都是以字节的方式存储的，那么什么时候使用字符流，什么时候使用字节流呢？字符流是对字符操作的，也就是对文本文件或者其他字符文件操作。而对于图片，声音，视频这些文件则用字节流操作。接下来是对字符流的操作，字符流相当于是字节流+编码表。可以向文件中直接写入字符串。读取的时候注意是用字符数组接受，不是字节数组。

1 package com.zaojiahua.iodemo;
2
3 import java.io.File;
4 import java.io.FileReader;
5 import java.io.FileWriter;
6 import java.io.IOException;
7
8 public class Test {
9
10     public static void main(String[] args) throws IOException {
11
12         File file = new File("file.txt");
13
14         //使用字符流实现文本文件的复制
15         FileReader reader = new FileReader(file);
16         FileWriter writer = new FileWriter("2.txt");
17         int len;
18         //这里是字符数组，不是字节数组
19         char [] buf = new char[1024];
20         while((len = reader.read(buf)) != -1)
21         {
22             System.out.println(new String(buf,0,len));
23             writer.write(buf,0,len);
24         }
25         //可以将字符串直接写到文件中
26         writer.write("\r\n"+"end");
27
28         //关闭流
29         reader.close();
30         writer.close();
31     }
32
33 }

以下是缓冲的字符流。经过缓冲以后可以读取和写入一行的数据。

1 package com.zaojiahua.iodemo;
2
3 import java.io.BufferedReader;
4 import java.io.BufferedWriter;
5 import java.io.File;
6 import java.io.FileReader;
7 import java.io.FileWriter;
8 import java.io.IOException;
9
10 public class Test {
11
12     public static void main(String[] args) throws IOException {
13
14         File file = new File("file.txt");
15
16         //使用字符流实现文本文件的复制
17         BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
18         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("2.txt"));
19
20