IO流下：字节流、流操作规律(java基础)

一、字节流

1.概述：

1、字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。

2、字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）

3、读写字节流：InputStream   输入流（读）和OutputStream  输出流（写）

4、字节流操作可以不用刷新流操作。

5、InputStream特有方法：

        int available();//返回文件中的字节个数

注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

练习：

需求：复制一张图片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

import java.io.*;


class CopyPic {
	public static void main(String[] args){
		copyBmp();
		System.out.println("复制完成");
	}

	public static void copyBmp() {

		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp");				//写入流关联文件
			fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp");			//读取流关联文件
			byte[] copy = new byte[1024];
			int len = 0;
			while((len=fis.read(copy))!=-1) {
			fos.write(copy,0,len);
			}
		}
		catch (IOException e) {
			e.printStackTrace();
			throw new RuntimeException("复制文件异常");
		}
		finally {
			try {
				if(fis!=null) fis.close();
			}
			catch (IOException e) {
				e.printStackTrace();
				throw new RuntimeException("读取流");
			}
		}
		
	}

}

2. 字节流缓冲区

* 字节流缓冲区跟字符流缓冲区一样，也是为了提高效率。

注意事项：

1. read()：会将字节byte()提升为int型值

2. write()：会将int类型转换为byte()类型，保留最后的8位。

练习：

1.复制MP3文件   1.MP3 -->  2.MP3

2.自己写一个MyBufferedInputStream缓冲类，提升复制速度

代码：

import java.io.*;


//自己的BufferedInputStream
class MyBufferedInputStream  {
	private InputStream in;							//定义一个流对象
	private byte [] buf = new byte[1024*4];
	private int count = 0,pos = 0;
	public MyBufferedInputStream(InputStream in){
		this.in = in;
	}

	public  int MyRead() throws IOException{
		if(count==0) {				//当数组里的数据为空时候，读入数据
			count = in.read(buf);
			pos = 0;
			byte b = buf[pos];
			count--;
			pos++;
			return b&255;       //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111
		}
		else if(count > 0) {
			byte b = buf[pos];
			pos++;
			count--;
			return b&0xff;		//提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111
		}
		return -1;
	}

	public void myClose() throws IOException{
		in.close();
	}

}




class BufferedCopyDemo {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		copy();
		long end = System.currentTimeMillis();
		System.out.println("时间:"+(end-start)+"ms");


		start = System.currentTimeMillis();
		copy1();
		end = System.currentTimeMillis();
		System.out.println("时间:"+(end-start)+"ms");
	} 

public static void copy1() {                //    应用自己的缓冲区缓冲数据

        MyBufferedInputStream bis = null;
        BufferedOutputStream  bos = null;
        try {
            bis = new MyBufferedInputStream(new FileInputStream("马旭东-入戏太深.mp3"));//匿名类，传入一个InputStream流对象
            bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));
            int buf = 0;
            while((buf=bis.MyRead())!=-1) {
                bos.write(buf);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("复制失败");
        }
        finally {
            try {
                if(bis!=null)  {
                    bis.myClose();
                    bos.close();
                }
            }
            catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
} 

二、流操作规律

1. 键盘读取，控制台打印。

System.out: 对应的标准输出设备：控制台  //它是PrintStream对象，（PrintStream：打印流。OutputStream的子类）

System.in: 对应的标准输入设备：键盘     //它是InputStream对象

示例：

/*================从键盘录入流，打印到控制台上================*/
	public static void InOutDemo(){
		//键盘的最常见的写法
		BufferedReader bufr = null;
		BufferedWriter bufw = null;
		try {
			
			/*InputStream ips = System.in;        //从键盘读入输入字节流
			InputStreamReader fr = new InputStreamReader(ips);			   //将字节流转成字符流
			bufr = new BufferedReader(fr);	*/				   //将字符流加强，提升效率

			
			bufr = new BufferedReader(new InputStreamReader(System.in));			//匿名类。InputSteamReader:读取字节并将其解码为字符
			bufw = new BufferedWriter(new OutputStreamWriter(System.out));		//OutputStreamWriter:要写入流中的字符编码成字节
			String line = null;
			while((line = bufr.readLine())!=null){
				if("over".equals(line)) break;
				bufw.write(line.toUpperCase());						//打印
				bufw.newLine();										//为了兼容，使用newLine()写入换行符
				bufw.flush();										//必须要刷新。不然不会显示
			}
			if(bufw!=null) {
				bufr.close();
				bufw.close();
			}
		}
		catch (IOException e) {
			e.printStackTrace();
		}
			
		
	}
}

2. 整行录入

1.从键盘录入数据，并存储到文件中。

2. 我们在键盘录入的是时候，read()方法是一个一个录入的，能不能整行的录入呢？这时候我们想到了BufferedReader中ReadLine()方法。

3. 转换流

为了让字节流可以使用字符流中的方法，我们需要转换流。

 1. InputStreamReader:字节流转向字符流；

  a 、获取键盘录入对象。

              InputStream in=System.in;

  b、将字节流对象转成字符流对象，使用转换流。

              InputStreamReaderisr=new InputStreamReader(in);

  c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

//键盘录入最常见写法

              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字符流通向字节流

示例：

/*================把键盘录入的数据存到一个文件中==============*/
	public static void inToFile() {
			//键盘的最常见的写法
		BufferedReader bufr = null;
		BufferedWriter bufw = null;
		try {
			
			/*InputStream ips = System.in;        //从键盘读入输入字节流
			InputStreamReader fr = new InputStreamReader(ips);			   //将字节流转成字符流
			bufr = new BufferedReader(fr);	*/				   //将字符流加强，提升效率

			
			bufr = new BufferedReader(new InputStreamReader(System.in));			//匿名类。InputSteamReader:读取字节并将其解码为字符
			bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));		//OutputStreamWriter:要写入流中的字符编码成字节
			String line = null;
			while((line = bufr.readLine())!=null){
				if("over".equals(line)) break;
				bufw.write(line.toUpperCase());						//打印
				bufw.newLine();										//为了兼容，使用newLine()写入换行符
				bufw.flush();										//必须要刷新。不然不会显示
			}
			if(bufw!=null) {
				bufr.close();
				bufw.close();
			}
		}
		catch (IOException e) {
			e.printStackTrace();
		}
			

	}

4. 流操作基本规律

为了控制格式我将其写入了java代码段中，如下：

示例1：文本 ~ 文本

/*
流操作的基本规律。
一、两个明确：(明确体系)
1. 明确源和目的
	源：输入流  InputStream  Reader
	目的：输出流  OutputStream Writer

2. 操作的数据是否是纯文本
	是： 字符流
	否： 字节流
二、明确体系后要明确具体使用的对象
	通过设备区分：内存，硬盘，键盘
	目的设备：内存，硬盘，控制台


示例1：将一个文本文件中的数据存储到另一个文件中: 复制文件
	一、明确体系
		源：文件-->读取流-->(InputStream和Reader)
		是否是文本：是-->Reader
		
		
		目的：文件-->写入流-->(OutputStream Writer)
		是否纯文本：是-->Writer
	
	二、 明确设备
		源：Reader
			设备：硬盘上一个文本文件 --> 子类对象为：FileReader
				FileReader fr = new FileReader("Goods.txt");
			
			是否提高效率：是-->加入Reader中的缓冲区：BufferedReader
				BufferedReader bufr = new BufferedReader(fr);
				
		目的：Writer
			设备：键盘上一个文本文件 --> 子类对象：FileWriter
				FileWriter fw = new FileWriter("goods1.txt");
			是否提高效率：是-->加入Writer的缓冲区：BufferedWriter
				BufferedWriter bufw = new BufferedWriter(fw);
			
			
			
示例2：将一个图片文件数据复制到另一个文件中：复制文件
	一、明确体系
		源：文件-->读取流-->(InputStream和Reader)
		是否是文本：否-->InputStream
		
		
		目的：文件-->写入流-->(OutputStream Writer)
		是否纯文本：否-->OutputStream
	
	二、 明确设备
		源：InputStream
			设备：硬盘上一个媒体文件 --> 子类对象为：FileInputStream
				FileInputStream fis = new FileInputStream("Goods.txt");
			
			是否提高效率：是-->加入InputStream中的缓冲区：BufferedInputStream
				BufferedInputStream bufi = new BufferedInputStream(fis);
				
		目的：OutputStream
			设备：键盘上一个媒体文件 --> 子类对象：FileOutputStream
				FileOutputStream fos = new FileOutputStream("goods1.txt");
			是否提高效率：是-->加入OutputStream的缓冲区：BufferedOutputStream
				BufferedOutputStream bufo = new BufferedOutputStream(fw);

示例3：将键盘录入的数据保存到一个文本文件中
	一、明确体系
		源：键盘-->读取流-->(InputStream和Reader)
		是否是文本：是-->Reader
		
		
		目的：文件-->写入流-->(OutputStream Writer)
		是否纯文本：是-->Writer
	
	二、 明确设备
		源：InputStream
			设备：键盘 --> 对用对象为：System.in --> InputStream
				为了操作方便，转成字符流Reader --> 使用Reader中的转换流：InputStreamReader
				InputStreamReader isr = new InputStreamReader(System.in);
			
			是否提高效率：是-->加入Reader中的缓冲区：BufferedReader
				BufferedReader bufr = new BufferedReader(isr);
				
		目的：Writer
			设备：键盘上一个文本文件 --> 子类对象：FileWriter
				FileWriter fw = new FileWriter("goods1.txt");
			是否提高效率：是-->加入Writer的缓冲区：BufferedWriter
				BufferedWriter bufw = new BufferedWriter(fw);

5.指定编码表(转换流可以指定编码表)

要求：用UTF-8编码存储一个文本文件

import java.io.*;
public class IOStreamLaw {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
				//键盘的最常见写法
				BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
				BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));
				String line = null;
				while((line=bufr.readLine())!=null){
					if("over".equals(line)) break;
					bufw.write(line.toUpperCase());
					bufw.newLine();
					bufw.flush();
				}
				bufr.close();
	}


}