[转]慎用InputStream的read()方法

InputStream 此抽象类是表示字节输入流的所有类的超类。

          我们从输入流中读取数据最常用的方法基本上就是如下 3 个 read() 方法了：

         1 、 read () 方法，这个方法 从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1 。

         2 、 read (byte[] b,int off,int len) 方法， 将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。

         3 、 read (byte[] b) 方法， 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。

         第一个方法典型的确定就是处理效率低，不是某些特殊情况，很少使用它，下面说说第 2 个方法跟第 3 个方法，第 3 个方法的本本质其实就是第 2 个方法的特殊情况， 效果等同于：

          read(b, 0, b.length)

所以这里把他们放着一起讨论。

         从第 2 个方法的 API 文档说明来看：“ 将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。”，最多读取 len 个字节，这究竟是何意？ API 文档并没有详细说明。是不是就意味着有可能（注意这里是有可能而不是一定，）读取不到 len 个字节呢？答案是“是的”。虽然造成这种情况的原因是什么个人并不知道，但是我们可以通过例子来发现这种情况，下面是源代码（由于只是简单的示例，所以代码也就随便写了）：

ServerSocket 端：

package myspider;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 *
 * @author mark
 */
public class MyServerSocket {

    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(8888);
        System.out.println("runing");
        while (true) {
            byte[] b = new byte[22480];
            int readBytes = 0;
            Socket s = ss.accept();
            InputStream is = s.getInputStream();
            while (readBytes < 22480) {
                int read = is.read(b, readBytes, 22480 - readBytes);
                System.out.println(read);
                if (read == -1) {
                    break;
                }
                readBytes += read;
            }
            File f = new File("F:\project\bocln_nacec\xml\ey.xml");
            if (!f.exists()) {
                f.createNewFile();
                System.out.println("creat " + f.toString());
            }
            FileOutputStream fos = new FileOutputStream(f);
            fos.write(b, 0, readBytes);
            fos.flush();
            fos.close();
            System.out.println("complete");
            is.close();
            s.close();
        }
    }
}

Socket 端：

package myspider;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 *
 * @author mark
 */
public class MySocket {

    public static void main(String[] args) throws UnknownHostException, IOException {
        Socket s = new Socket("127.0.0.1", 8888);
        OutputStream os = s.getOutputStream();
        File f = new File("F:\project\bocln_nacec\xml\ye.xml");
        InputStream is = new FileInputStream(f);
        byte[] b = new byte[22480];
        int i = is.read(b);
        is.close();
        os.write(b, 0, i);
        os.flush();
        os.close();
        s.close();
    }
}

先运行 MyServerSocket ，让后多次运行 MySocket ，这是控制台的输出结果（ ye.xml 文件长度为 20389 ）：

runing
20389
-1
creat F:projectocln_nacecxmley.xml
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
8760
11629
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
3760
620
16009
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
8760
11629
-1
complete
20389
-1
complete
20389
-1
complete
8760
11629
-1
complete
20389
-1
complete
20389
-1
complete
8760
11629
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete
20389
-1
complete

         通过观察发现，在大多数情况下，我们能够用 is.read(b, readBytes, 22480 - readBytes) 一次性就读完整个文件，但是还是有极少数情况，我们需要两次(如36、37两行)甚至两次以上（如58、59、60）调用 is.read(b, readBytes, 22480 - readBytes) 方法才能把整个文件读取完。这里由于文件最长只有 20389 ，所以我们能读到的最大字节数也就是 20389 而不会是 22480 了。

         那么我们怎样写代码才能保证在数据流没有到达末尾的情况下读取到自己想要的长度的字节数据呢？我们可以这样写：   

int readBytes=0;

Byte[] b=new byte[1024]//1024可改成任何需要的值

int len=b.length;

while (readBytes < len) {

                int read = is.read(b, readBytes, len - readBytes);

               //判断是不是读到了数据流的末尾 ，防止出现死循环。

                if (read == -1) {

                    break;

                }

                readBytes += read;

            }