java 字节输入流、字节输出流、字节缓冲流

一时失言乱红尘 2022-06-10 06:27 266阅读 0赞

**1. 字节输入流:**

1.1 InputStream类的常用方法  
  
1. available() 方法，获取与之关联的文件剩余可读的字节数。  
2. int read() 方法，读取输入流。读取输入流的下一个字节，返回一个0-255之间的int类型整数。如果到达流的末端，返回-1。  
3. int read(byte\[\] b) 方法，读取输入流。读取多个字节，存入字节数组b，返回实际读入的字节数。如果到达流的末端，返回-1。  
4. int read (byte\[\] b, int off, int len); 方法，读取输入流。每次读取len个字节，存入字节数组b，从off下标开始存储。如果到达流的末端，返回-1。  
5. close() 方法，关闭当前流，释放与该流相关的资源，防止资源泄露。在带资源的try语句中将被自动调用。关闭流之后还试图读取字节，会出现IOException异常。  
1.2 InputStream类的子类:文件输入流FileInputStream  
FileInputStream 用于读取本地文件中的字节数据，继承自InputStream类  
  
1.2.1 FileInputStream构造方法和常用方法  
  
1.2.1.1构造方法  
  
1. FileInputStream(File file); 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的 File 对象 file 指定。  
2. FileInputStream(String name); 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径名 name 指定。  
  
1.2.1.2 常用方法  
  
1. read() 方法，读取输入流。读取输入流的下一个字节，返回一个0-255之间的int类型整数。如果到达流的末端，返回-1。

is = new FileInputStream("test.txt");  
           int i; 
           while ((i = is.read()) != -1) {
               System.out.println("out: " + (char)i);  
           }

2. read(byte\[\] b) 方法，读取输入流。读取多个字节，存入字节数组b，返回实际读入的字节数。

InputStream is = null;  
           byte[] buffer = new byte[4];//每次读取4个字节
           try {
               is = new FileInputStream("test.txt");  
               is.read(buffer);  
               System.out.println("available: " + is.available());//观察在读取的过程中，available 值。
               for (byte b : buffer) {  
                   System.out.println((char)b);  
               }
           }...

3. read (byte\[\] b, int off, int len); 方法，读取输入流。每次读取len个字节，存入字节数组b，从off下标开始存储。  
4. close() 方法，关闭当前流，释放与该流相关的资源，防止资源泄露。在带资源的try语句中将被自动调用。关闭流之后还试图读取字节，会出现IOException异常。

5. skip(long n) 方法，跳过(放弃)当前流的n个字节，返回实际跳过的字节数。

示例代码：

File file = new File("a.txt");
    		if (file.exists()) {
    
    			try (FileInputStream is = new FileInputStream(file)) {
    				// 第一种方法
    				byte[] b = new byte[10];
    				while (true) {
    					int read2 = is.read(b, 0, 10);// 等价于 is.read(b);
    					if(read2==-1){
    						break;
    					}
    					String string = new String(b, 0, read2); 
    					System.out.print(string);
    				}
    
    				// 第二种方法
    //				byte[] b = new byte[10];
    //				int read = -1;
    //				while ((read = is.read(b, 0, 10)) != -1) {
    //					String string = new String(b, 0, read); // is.read(b);
    //					System.out.print(string);
    //				}
    
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}

**2 字节输出流:**  
  
**2.1 OutputStream类的常用方法**  
  
1. write (int b); 将指定的字节写入此输出流。  
2. write(byte\[\] byte); 将 b.length 个字节从指定的 byte 数组写入此输出流。  
3. write(byte\[\] byte, int off, int len); 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。  
4. flush(); 用于清空缓存里的数据，并通知底层去进行实际的写操作。(强制把缓存区里面的数据写入到文件)  
5. close();关闭当前流，释放与该流相关的资源。  
  
**2.2 OuputStream类的子类:文件输出类FileOutputStream**  
  
提供了文件的基本写入能力，继承自 OuputStream类  
  
注意：  
  
1. 如果进行写操作的文件不存在，则自动创建该文件。  
2. 如果文件所在的路径也不存在则报错。  
  
2.2.1 FileOutputStream构造方法和常用方法  
  
2.2.1.1 构造方法  
  
  
1. public FileOutputStream(String name); 通过打开一个到实际文件的连接来创建一个FileOutputStream，该文件通过文件系统中的路径名 name 指定。  
2. public FileOutputStream(String name,boolean append);通过打开一个到实际文件的连接来创建一个FileOutputStream，该文件通过文件系统中的路径名 name 指定。如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。  
3. public FileOutputStream(File file)：通过打开一个到实际文件的连接来创建一个FileOutputStream，该文件通过文件系统中的 File 对象 file 指定。   
4. public FileOutputStream(File file,boolean append);通过打开一个到实际文件的连接来创建一个FileOutputStream，该文件通过文件系统中的 File 对象 file 指定。如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。  
  
2.2.1.2 常用方法  
  
1. write (int b); 将指定的字节写入此输出流。

try {
           	File file = new File("test.txt");
           	OutputStream fos = new FileOutputStream(file);
           	byte b = 'a';
           	fos.write(b);
           	fos.flush();
           	fos.close();
           }...

2. write(byte\[\] byte); 将 b.length 个字节从指定的 byte 数组写入此输出流。

try {
           	File file = new File("test.txt");
           	OutputStream fos = new FileOutputStream(file);
           	byte b[]= "abcdefg".getBytes();
           	fos.write(b);
           	fos.flush();
           	fos.close();
           }...

3. write(byte\[\] byte, int off, int len); 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

try {
           	File file = new File("test.txt");
           	OutputStream fos = new FileOutputStream(file);
           	byte b[]= "abcdefg".getBytes();
           	fos.write(b,1,3);
           	fos.flush();
           	fos.close();
           }...

4. flush(); 用于清空缓存里的数据，并通知底层去进行实际的写操作。(强制把缓存区里面的数据写入到文件)  
5. close();关闭当前流，释放与该流相关的资源。  
示例代码：

File file = new File("Test.txt");
    		try {
    			// 如果该file不存在，在 输出流会自动创建该(空)文件
    //			OutputStream os = new FileOutputStream(file);//覆盖源文件内容，写入
    			OutputStream os = new FileOutputStream(file, true);//在源文件的末尾追加写入
    			os.write(66);// 写一个字节
    			os.close();
    			System.out.println("写入完毕...");
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}

**3 字节缓冲流**  
  
BufferedInputStream与BufferedOutputStream分别是FilterInputStream类和FilterOutputStream类的子类，实现了装饰设计模式。提高了读写性能。  
  
**3.1字节输入缓冲流 BufferedInputStream**  
  
BufferedInputStream是带缓冲区的输入流，默认缓冲区大小是8Kb，能够减少访问磁盘的次数，提高文件读取性能；  
  
使用方式：

try {
        	File file = new File("test.txt");
        	InputStream fos = new FileInputStream(file);
        	BufferedInputStream bis = new BufferedInputStream(fos,2*1024);//2*1024设置需要的缓冲区大小
        	byte b[] =new byte[1024];
        	while (bis.read(b)!=-1) {
        		for (byte c : b) {
        			System.out.println((char)c);
        		}
        	}
        	bis.close();
        }

**3.2 字节输出缓冲流 BufferedOutputStream**  
  
BufferedOutputStream是带缓冲区的输出流，能够提高文件的写入效率。  
  
使用方式：

try {
        	File file = new File("test.txt");
        	OutputStream fos = new FileOutputStream(file);
        	BufferedOutputStream bos =new BufferedOutputStream(fos,2*1024);//2*1024设置需要的缓冲区大小
        	byte b = "a";
        	bos.write(b);
        	bos.flush();//带有缓冲区，所以必须刷新。
        	bos.close();
        }...

3.3 字节缓冲输入流特有的方法

1. mark(int readlimit) 方法(只有BufferedInputStream才支持)，在流的当前位置做个标记，参数readLimit指定这个标记的“有效期”，如果从标记处开始往后，已经获取或者跳过了readLimit个字节，那么这个标记失效，不允许再重新回到这个位置（通过reset方法）。也就是你想回头不能走得太远呀，浪子回头不一定是岸了，跳过（获取）了太多字节，标记就不再等你啦。多次调用这个方法，前面的标记会被覆盖。

![Center][]  
 如果我们在 M 处做标记，readLimit为绿色部分，当流的指针在 A 处的时候，这个标记依然有效，可是一旦指针跑到 B 处，标记就失效了。  
2. reset() 方法(只有BufferedInputStream才支持)，用于重定位到最近的标记。如果在这之前mark方法从来没被调用，或者标记已经无效，会抛出IOException。如果没有抛出这个异常，将当前位置重新定位到最近的标记位置。

InputStream is = null;  
                   try {
                       is = new BufferedInputStream(new FileInputStream("test.txt"));  
                       is.mark(4);  
                       is.skip(2);  
                       is.reset();  
                       System.out.println((char)is.read());  
                   } finally {  
                       if (is != null) {  
                           is.close();  
                       }  
                   }
           }

[Center]: /images/20220610/0091095980ee4d2d8199d71da0b77b33.png