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

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方法）。也就是你想回头不能走得太远呀，浪子回头不一定是岸了，跳过（获取）了太多字节，标记就不再等你啦。多次调用这个方法，前面的标记会被覆盖。

   
   如果我们在 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();  
                   }  
               }
       }