IO流的大概应用之字节流

字节流

InputStream：

是字节输入流的超类，主要包括：
FileInputStream
BufferedInputStream
DataInputStream
ByteArrayInputStream
主要方法：

//从输出流读取数据的下一个字节
abstract int read()
//从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
int read(byte[] b)
//将输入流中最多len个数据字节读入byte数组
int read(byte[] b,int off,int len)
//关闭流资源
void close();

FileInputStream

文件字节输入流，主要用来读取文件信息
构造方法：

//通过打开一个实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的File对象file指定
FileInputStream(File file)
//通过使用文件描述符fbObj创建一个FileInputStream,该文件描述符表示到文件系统中某个市级文件的现有连接
FileInputStream(FileDescriptor fdObj)
//通过打开一个到实际文件的连接来创建一个FIleInputStream，该文件通过文件系统中的路径名name指定
FileInputStream(String name)

方法主要是继承自InputStream

public class TestFileInPutStream {

	public static void main(String[] args) throws IOException {
		File file = new File("E:\\test.txt");
		FileInputStream fis1 = new FileInputStream(file);
		FileInputStream fis2 = new FileInputStream("E:\\test.txt");
		int b=0;
		byte[] buffer = new byte[10];
		while((b = fis1.read(buffer)) != -1) {			
			System.out.println(new String(buffer,0,b));
		}
		fis1.close();
	}

OutputStream

是字节输出流的超类，主要包含：
FileOutputStream
BufferedOutputStream
DataOutputStream
ByteArrayOutputStream
主要方法：

//每次写入一个字节，将指定的字节写入此输出流
abstract void write(int b)
//将b.length个字节从指定的byte数组写入此输出流
void write(byte[] b)
//将指定byte数组中从偏移量off开始的len个字节写入此输出流
void write(byte[] b,int off,int len)
//关闭流资源
void close();

FileOutputStream

文件字节输出流，主要用来写入文件信息，是将数据写入到File或FIleDescriptor的输出流
构造方法：

//创建一个向指定File对象表示的文件写入数据的文件输出流
FileOutputStream(File file)
//创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name)
//创建一个向指定File对象对象表示的文件写入数据的文件输出流,append表示是否在文件最后追加信息
//true表示将信息追加到最后面，false表示将信息写到最前面
FileOutputStream(File file,boolean append)
//创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name,boolean append)

主要方法继承自OutputStream

public static void main(String[] args) throws IOException {
		File file = new File("abc.txt");
		FileOutputStream fos = new FileOutputStream(file,true);
		
		byte [] array = "hello world!".getBytes();
		fos.write(array);
		fos.write(array, 2, 7);

		byte[] arrays = "\n床前明月光，\n疑似地上霜。\n举头望明月，\n低头思故乡。".getBytes();
		
		fos.write(arrays);
		fos.close();
	}

运行结果：

hello world!llo wor
床前明月光，
疑似地上霜。
举头望明月，
低头思故乡。

复制文件

将aaa中的文件读出，然后将读出的内容写到bbb中
采用数组的方式读取和写入
这里面会出现异常，全部捕获了然后处理掉，不需要抛出

public static void main(String[] args)  {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("E:\\aaa.jpg");
			fos = new FileOutputStream("E:\\bbb.jpg");
			int b = 0;
			byte[] array = new byte[1024];
			try {
				while((b = fis.read(array)) != -1) {
					fos.write(array,0,b); 
					fos.flush();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		try {
			if(fos != null)
				fos.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			if(fis != null)
				fis.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

字节缓冲流

字节缓冲流分为两个：
字节缓冲输入流（BufferedInputStream）
字节缓冲输出流（BufferedOutputStream）
缓冲区对象本身不具备对文件进行读写的功能，需要依赖输出流和输入流

BufferedInputStream

构造方法：

//创建一个BufferedInputStream并保存其参数，即输入流in
BufferedInputStream(InputStream in)
//创建一个具有指定缓冲区大小的BufferedInputStream并保存其参数，即输入流in
BufferedInputStream(InputStream in,int size)

案例：

public static void main(String[] args) throws IOException {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("abc.txt"));
		byte[] arr = new byte[1024];
		int len = 0;
		while((len=bis.read(arr)) != -1) {
			String str = new String(arr,0,len);
			System.out.println(str);
		}
	}

运行结果：

hello world!llo wor
床前明月光，
疑似地上霜。
举头望明月，
低头思故乡。

缓冲区对象读写数据的速度比一般对象要快得多

BufferedOutputStream

构造方法：

//创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out)
//创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据数据写入指定的底层输出流
BufferedOutputStream(OutputStream out，int size)

案例：

public static void main(String[] args) throws IOException {
	//创建字节输出流缓冲区对象
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt"));
	bos.write("测试一下这个".getBytes());//这里是先将数据写入到缓冲区内置的数组
	bos.flush();//把存储在内置数组中的数据写到文件中
	bos.close();//在关闭字节输出流缓冲流对象时，先调用flush()方法
	}

新的方法：
void flush()刷新缓冲区

字节流缓冲流复制文件

案例
这里复制的是一个很大的视频文件，但复制速度还是很快

public static void main(String[] args) {
		
			long start = System.currentTimeMillis();
			BufferedInputStream bis = null;
			BufferedOutputStream bos = null;
			int b = 0;
			byte[] bytes = new byte[1024];
			try {
				bis = new BufferedInputStream( new FileInputStream("F:\\aaa.mp4"));
				bos = new BufferedOutputStream( new FileOutputStream("F:\\bbb.mp4"));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				while((b = bis.read(bytes)) != -1) {
					bos.write(bytes,0,b); 
					bos.flush();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				if(bos != null) {
					bos.flush();
					bos.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			try {
				if(bis != null)
					bis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			long end = System.currentTimeMillis();
			long past = end-start;
			System.out.println(past);
		}