Java IO学习笔记（字节流）

字节流是最基本的流，文件的操作、网络数据的传输等等都依赖于字节流。而字符流常常用于读取文本类型的数据或字符串流的操作等等。

关于字节流的API，没什么好说的，看看就知道了。这里挑几个关键点：

一、InputStream的API

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

2、public int read(byte[] b)
从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。此方法等同于read(b, 0, b.length)

3、public int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。如果由于已到达流末尾而不再有数据，则返回 -1。
参数：
b - 读入数据的缓冲区。
off - 在其处写入数据的数组 b 的初始偏移量。
len - 要读取的最大字节数。

二、OutputStream的API

1、public void write(int b)
将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

2、public void write(byte[] b)
将 b.length 个字节从指定的字节数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。

3、public void write(byte[] b,
                  int off,
                  int len)
将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。write(b, off, len) 的常规协定是：将数组 b 中的某些字节按顺序写入输出流；元素 b[off] 是此操作写入的第一个字节，b[off+len-1] 是此操作写入的最后一个字节。
参数：
b - 数据。
off - 数据中的初始偏移量。
len - 要写入的字节数。

4、public void flush()
刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。

三、几点原则

1、不管是输入还是输出流，使用完毕后要close()，如果是带有缓冲区的输出流，应在关闭前调用flush()。

2、应该尽可能使用缓冲区，来减少IO次数，以提高性能。

3、能用字符流处理的不用字节流。

四、例子

下面是一个操作字节流的例子：

要操作的文本文件x.txt

1 白日依山尽，黄河入海流。  
2 欲穷千里目，更上一层楼。
3 
4 —— 王之涣《登鹳雀楼》登 

1 import java.io.*;
  2 
  3 /**
  4 * Created by IntelliJ IDEA.
  5 *
  6 * @author leizhimin 2008-8-27 22:16:44
  7 */
  8 public class TestIOStream {
  9     public static void main(String[] args) {
 10         testStream();
 11         testBufferedStream();
 12         testSelectStream();
 13     }
 14 
 15     /**
 16      * 字节流测试
 17      */
 18     public static void testStream() {
 19         InputStream fis = null;
 20         OutputStream fos = null;
 21         try {
 22             fis = new FileInputStream("C:\\x.txt");
 23             fos = new FileOutputStream("C:\\xcopy.txt");
 24             long num = 0;    //读取字节计数
 25             int bt = 0;      //每次读入字节内容
 26             //当读入文件末尾时，读入数据的值为-1
 27             //每次读入一个字节，存放到变量bt中，直到读完整个文件
 28             while ((bt = fis.read()) != -1) {
 29 //                System.out.print(bt);   //以数字的形式逐个输出文件的每个字节
 30                 System.out.print((char) bt);   //以字母的形式逐个输出文件的每个字节
 31                 fos.write(bt);  //将字节写入输出流中，实现文件的copy功能
 32                 num++;
 33             }
 34             System.out.println("读取的字节数为" + num);
 35             fis.close();
 36             fos.close();
 37         } catch (FileNotFoundException e) {
 38             System.out.println("找不到指定的文件！");
 39             e.printStackTrace();
 40         } catch (IOException e) {
 41             System.out.println("文件读取时发生IO异常！");
 42             e.printStackTrace();
 43         }
 44     }
 45 
 46     /**
 47      * 缓冲的字节流测试
 48      */
 49     public static void testBufferedStream() {
 50         int buffer = 10; //缓冲大小
 51         try {
 52             BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\x.txt"));
 53             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\bf2.txt"));
 54             int bench = 0;
 55             byte bts[] = new byte[buffer];      //创建字节流缓存
 56             while ((bis.read(bts)) != -1) {
 57                 bos.write(bts);  //将字节写入输出流中，实现文件的copy功能
 58                 bench++;
 59             }
 60             System.out.println("bench=" + bench);
 61             //将输入流缓冲区中的数据全部写出（千万记住)
 62             bos.flush();
 63             bis.close();
 64             bos.close();
 65         } catch (FileNotFoundException e) {
 66             System.out.println("找不到指定的文件！");
 67             e.printStackTrace();
 68         } catch (IOException e) {
 69             System.out.println("文件读取时发生IO异常！");
 70             e.printStackTrace();
 71         }
 72     }
 73 
 74     /**
 75      * 字节流的选择读取测试
 76      */
 77     public static void testSelectStream() {
 78         OutputStream fos = null;
 79         int buffer = 25;
 80         try {
 81             BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\x.txt"));
 82             fos = new FileOutputStream("C:\\testSelectStream.txt");
 83 
 84             byte bts[] = new byte[buffer];      //创建缓存
 85             //从输入流的第5个字节开始，往后读取10个字节，存放到缓存bts中
 86             //这个方法有个陷阱，缓存buffer的大小最小为“偏移量+要读取字节数”，在次最小应该为15，否则抛IndexOutOfBoundsException异常
 87             bis.read(bts, 5, 10);
 88             //将字节写入输出流中，实现文件的copy功能
 89             fos.write(bts);
 90 
 91             bis.close();
 92             fos.close();
 93         } catch (FileNotFoundException e) {
 94             System.out.println("找不到指定的文件！");
 95             e.printStackTrace();
 96         } catch (IOException e) {
 97             System.out.println("文件读取时发生IO异常！");
 98             e.printStackTrace();
 99         }
100     } 
101 }
 

注意了：
1、缓冲的功能应该通过相应的缓冲流来包装原始流来实现，而不是自己连续多次数据，最后写到一个数组中，这是很愚昧的做法（但是还有很多人在用）。
2、read(byte[] b, int off, int len)这个方法要好好体会了，往往和你想象的不一样。
3、将读取的一个字节强制转换为char是不合适的，除非你想看看能输出什么。

评论

5 楼 busing 2010-07-01  

((bis.read(bts)) != -1

bis.read 到的值放进bts数组里面去

4 楼 liliugen 2010-07-01  

前面的数字都不会去掉么

3 楼 liliugen 2010-07-01  

楼主的Java代码太乱了，基本的整理都不知道么？ 。。。。。。

2 楼 busing 2010-03-02  

这个是缓冲用的，如果每读一个字节就往硬盘里写对硬盘上海较大，而且操作也太频繁了。所以就定义一个数组，比如1000个字节的， 每读一个字节存在这个变量里面，到一千的时候一次全部写到硬盘里去

1 楼 bborn 2010-03-01  

有个地方不明白

引用

1、缓冲的功能应该通过相应的缓冲流来包装原始流来实现，而不是自己连续多次数据，最后写到一个数组中，这是很愚昧的做法（但是还有很多人在用）。

在这里
# 46     /**
#  47      * 缓冲的字节流测试
#  48      */ 
。。。
#  54             int bench = 0; 
#  55             byte bts[] = new byte[buffer];      //创建字节流缓存 
#  56             while ((bis.read(bts)) != -1) { 
#  57                 bos.write(bts);  //将字节写入输出流中，实现文件的copy功能 
#  58                 bench++; 
#  59             } 

不是这么用的吗?

新手 不太明白？ 能讲一下吗