IO流三：字节流文件读写操作、拷贝图片、带缓冲区的字节流、read()原理、读取键盘录入

1  字节流文件读写操作

字符流：FileReader、BufferedReader

    FileWriter、BufferedWriter

字节流：InputStream ：读

        OutputStream ：写

字符流操作字符数据，多用于文本文件。字节流操作字节数据，例如图片文件等。

字符流读入字符数组char[]，字节流读入字节数组byte[]。

代码示例：

import java.io.*;

class FileStreamDemo {
	public static void main(String[] args) throws IOException{
		writeFile();
		readFile_1();
		readFile_2();
		readFile_3();
	}
	
	public static void writeFile() throws IOException{
		FileOutputStream fos = new FileOutputStream("fos.txt");//文件不存在则创建。
		
		//String类的getBytes()方法获取字节数组。
		fos.write("FileStream".getBytes()); 
		
	/* 	字节流的写入不需要刷新。字符流需要刷新是因为，先逐个字节的将数据从流对象写入到一个缓冲区，
	    再查表，有匹配的字符时，再刷新写入目的地。 */
		
		fos.close();
	}
	
	public static void readFile_1() throws IOException{
		FileInputStream fis = new FileInputStream("fos.txt");
		
		int ch = 0;
		
		while((ch=fis.read())!=-1){ //逐个字节读取
			System.out.println((char)ch);
		}
		fis.close();
	}
	
	public static void readFile_2() throws IOException{
		FileInputStream fis = new FileInputStream("fos.txt");
		
		byte[] buf = new byte[1024];
		int len = 0;
		
		while((len=fis.read(buf))!=-1){ //读取到buf数组中
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}
	
	public static void readFile_3() throws IOException {
		FileInputStream fis = new FileInputStream("fos.txt");
		
	  //int num = fis.available();
	  //available方法获取流对象中的字节数，回车符'\r'和换行符'\n'各占一个。
	  
	    byte[] buf = new byte[fis.available()]; //定义一个刚刚好的缓冲区，不用再循环了。
		                                    //但是如果这个数组长度过长，内存就溢出了。
		fis.read(buf);
		System.out.println(new String(buf));
		
		fis.close();
	}
}

2  拷贝图片

复制一个图片文件，用到的流对象：FileInputStream、FileOutputStream。

 

思路：

1，字节流读取对象InputStream和图片文件相关联。

2，用字节流输出对象OutputStream创建一个文件，用于存储读取到底的图片数据。

3，通过循环读写，完成数据的存储。

代码示例：

import java.io.*;

class CopyPictureDemo{
	public static void main(String[] args){
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try{
			fis = new FileInputStream("e:\\EVE.jpg"); //读
			fos = new FileOutputStream("e:\\EVE_副本.jpg"); //写
			
			byte[] buf = new byte[1024];
			int len = 0;
			
			while((len=fis.read(buf))!=-1){ //读取到数组中
				fos.write(buf,0,len);
			}
		}
		catch(IOException e){
			System.out.println(e.toString());
		}
		finally{
			try{
				if(fis!=null)
					fis.close();
			}
			catch(IOException e){
				System.out.println(e.toString());
			}
			try{
				if(fos!=null)
					fos.close();
			}
			catch(IOException e){
				System.out.println(e.toString());
			}
		}
	}
}

3  带缓冲区的字节流：复制MP3文件

通过复制MP3文件，演示带缓冲区的字节流：BufferedInputStream、BufferedOutputStream。

代码示例：

import java.io.*;

class CopyMp3Demo {
	public static void main(String[] args) throws IOException{
		long start = System.currentTimeMillis(); //获取时间
		copy_1();
		long end = System.currentTimeMillis(); //获取时间
		
		System.out.println((end-start)+"毫秒"); //执行时间
	}
	
	//通过字节流的缓冲区完成复制
	public static void copy_1() throws IOException{
		BufferedInputStream bufis =
			new BufferedInputStream(new FileInputStream("e:\\GetUp.mp3"));
			
		BufferedOutputStream bufos = 
			new BufferedOutputStream(new FileOutputStream("e:\\GetUp-副本.mp3"));
		
		byte[] bt = new byte[1024];
		int len = 0;
		
		while((len=bufis.read(bt))!=-1){
			bufos.write(bt,0,len);
		}
		bufis.close();
		bufos.close();
	}
	
	//MyBufferedInputStream 的演示。
	public static void copy_2() throws IOException{
		MyBufferedInputStream bufis = 
			new MyBufferedInputStream(new FileInputStream("e:\\GetUp.mp3"));
		BufferedOutputStream bufos = 
			new BufferedOutputStream(new FileOutputStream("e:\\GetUp-副本.mp3"));
				
		int by = 0;
		
		while((by=bufis.myRead())!=-1){
			bufos.write(by);
		}
		bufis.myClose();
		bufos.close();
	}
}

4  自定义带缓冲区的字节流和read()方法的原理

上一节代码CopyMp3Demo中copy_2的演示。

代码示例：

import java.io.*;

class MyBufferedInputStream {
	private InputStream in = null;
	private byte[] buf = new byte[1024];
	
	//pos指针从数组中取元素，count计数器存储数组中的元素个数。
	private int pos = 0, count = 0;
	
	MyBufferedInputStream(InputStream in){
		this.in = in;
	}
	
	//一次读一个字节，从缓冲区（字节数组）获取。
	public int myRead() throws IOException{
		
		//通过in对象读取硬盘上的数据，并存储到buf中。
		if(count==0){
			count = in.read(buf);
			if(count<0)
				return -1;
			pos = 0;
			byte b = buf[pos];
			
			count--;
			pos++;
			return b&255; //从byte类型提升到int类型
		}
		else if(count>0){
			byte b = buf[pos];
			
			count--;
			pos++;
			return b&255; //从byte类型提升到int类型
		}
		return -1;
	}
	public void myClose() throws IOException{
		in.close();
	}
}

-1的二进制表示：补码表示

0000 0001

1111 1110

1111 1111   -1       读到8个1，就返回了-1，所以没有执行read方法。

 

为什么read()返回是int类型，而不是byte类型？

因为返回byte类型的话，遇到连续8个1时，返回-1，误以为是结束标记，就不执行whlie循环。

提升到int类型后，32个1才表示“-1”，才是结束标记。

byte: -1 ----> int: -1     //一个int类型是32个二进制位，而一个字节8个二进制位，所以被提升了。

 11111111 11111111 11111111 11111111 -1   //提升时若要还是-1，应在前面补1。

---> 00000000 00000000 00000000 11111111    255  //但为了避免遇到8个1返回-1，被误以为是结束标记。

                                               //应该在前面补0。

 

11111111   --->提升了一个int类型，那不还是-1吗？是-1的原因是因为在8个1前面补的是1导致的。

那么我只要在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。

 

怎么补0呢？

  11111111 11111111 11111111 11111111

& 00000000 00000000 00000000 11111111     255    //和255做与运算，补0.

--------------------------------------------

  00000000 00000000 00000000 11111111

 

 

事实上，read方法返回int类型时，进行补0的操作，

而write方法先进行去0的操作，再把11111111写入目的地，最终写入的数据还是这一个字节11111111。

 

5  读取键盘录入

System.out：对应标准的输出设备，控制台。

System.in：对应标准的输入设备，键盘。

 

需求：

1，通过键盘读取录入。

2，当录入一行数据后，就将该行数据进行打印。

3，如果录入“over”的话，那么停止录入。

其实就是带缓冲区的IO流中readLine()的原理。

 

代码示例：

import java.io.*;

class ReadInDemo{
	public static void main(String[] args) throws IOException{
		InputStream in = System.in; //System.in对象，读取键盘录入。
		StringBuilder sb = new StringBuilder();
		
		while(true){
			int ch = in.read();
			if(ch=='\r')
				continue;
			if(ch=='\n'){ //读到换行符，就打印缓冲区中的数据
				String s = sb.toString();
				if(s.equals("over"))
					break;
				System.out.println(s);
				sb.delete(0,sb.length()); //清空缓冲区。
			}
			else 
				sb.append((char)ch);
		}
	}
}