转自：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操作

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

java中的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         String buf;
21         //使用buffer缓冲的时候可以读取和写入一行
22         while((buf = bufferedReader.readLine()) != null)
23         {
24             bufferedWriter.write(buf);
25             //写入一行
26             bufferedWriter.newLine();
27             System.out.println(buf);
28         }
29  
30         //关闭流
31         bufferedReader.close();
32         bufferedWriter.close();
33     }
34 }

最后解决的一个问题是字节流和字符流的转化，使用的是InputStreamReader和OutputStreamWriter，它们本身属于的是reader和writer字符流，我们之所以会用到这些转化流是因为系统有时候只给我们提供了字节流，为了方便操作，要用到字符流。比如说System.in标准输入流就是字节流。你想从那里得到用户在键盘上的输入，只能是以转换流将它转换为Reader以方便自己的程序读取输入。再比如说Socket里的getInputStream()很明显只给你提供字节流，你要想读取字符，就得给他套个InputStreamReader()用来读取。

查看源代码
打印 帮助
1 package com.zaojiahua.iodemo;
2  
3 import java.io.BufferedReader;
4 import java.io.BufferedWriter;
5 import java.io.FileInputStream;
6 import java.io.FileOutputStream;
7 import java.io.IOException;
8 import java.io.InputStreamReader;
9 import java.io.OutputStreamWriter;
10  
11 public class Test {
12  
13     public static void main(String[] args) throws IOException {
14  
15         //字节流和字符流的相互转化
16         FileInputStream fileInputStream = new FileInputStream("input.txt");
17         //inputSreamReader本来就是reader对象，创建的时候需要传入一个InputStream对象，将字节流转化为字符流
18         BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream));
19  
20         //将字符流转化为字节流
21         OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("output.txt"));
22         BufferedWriter writer = new BufferedWriter(outputStreamWriter);
23  
24         //实现拷贝文件的操作
25         String buf;
26         while((buf = reader.readLine()) != null)
27         {
28             writer.write(buf);
29             writer.newLine();
30             System.out.println(buf);
31         }
32  
33         //关闭流
34         reader.close();
35         writer.close();
36     }
37 }