字节缓冲流

字节缓冲输入流
  public BufferedInputStream(InputStream in):默认缓冲区大小构造缓冲输入流对象
public BufferedInputStream(InputStream in,int size):指定缓冲区大小构造缓冲输入流对象
 
public int read()
public int read(byte[] b,int off,int len)
 
 在使用输入流的时候,

两种方式读取(一次读取一个字节/一次读取一个字节数组),只能用一种方式,否则,会出现错误!

public class BufferedInputStreamDemo {
	
	public static void main(String[] args) throws Exception {
		
		//构造一个字节缓冲输入流对象
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
		
		//读数据
		//一次读取一个字节
		/*int by = 0 ;
		while((by=bis.read())!=-1) {
			System.out.print((char)by);
		}*/
		
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=bis.read(bys))!=-1) {
			System.out.println(new String(bys, 0, len));
		}
		//释放资源
		bis.close(); 
	}
}//hello

把bos.txt文件中的内容输出在控制台上了。

字节缓冲输出流:
 构造方式:
(第一种开发中) public BufferedOutputStream(OutputStream out):采用的默认的缓冲区大小(足够大了) ,来构造一个字节缓冲输出流对象
   public BufferedOutputStream(OutputStream out,int size):size用来指定缓冲区大小构造缓冲输出流对象
   IllegalArgumentException - （异常）如果 size <= 0
 
  写数据的方式:
  一次写一个字节
  write(int by)
  一次写一个字节数组的一部分
   write(byte[] b, int off, int len) 
  
  方法:
   void flush() ;刷新缓冲区的流
 

public class BufferedOutputStreamDemo {
	
	public static void main(String[] args) throws Exception {
		//构造一个字节缓冲输出流对象
		//符合Java一种设计模式:装饰者设计模式(过滤器:Filter)
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt")) ;
		
		//写数据
		bos.write("hello".getBytes());
		
		//释放资源
		bos.close(); 
		
	}
}

该操作即在当前目录下的bos.txt文件内写了“hello”这个字符串。

这里有一个面试题，我们可以看一下

面试题:
   字节缓冲输出流它的构造方法为什么不能直接传递路径/文件?
缓冲输入流/缓冲输出流,它只是在底层内部提供一个缓冲区的数组,
  底层实现文件的复制/读取/写入这些操作都依赖于基本流对象来操作(InputStream/OutputStream/FileInputStream/FileOutputstream)

 存储文件
   IO流:永久存储(耗时)
数据库:永久存储
  
 基本的字节流
  文件字节输入流/文件字节输出流
 高效的字节流(缓冲流)

我们操作一个视频文件,来测试速度问题

StringBuffer:提供了一个字符串缓冲区 (可以在缓冲区中不断追加字符串)

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {

	
	public static void main(String[] args) throws Exception {
		long start = System.currentTimeMillis() ;
		
//		method1("e:\\abc.mp4","copy1.mp4") ;
//		method2("e:\\abc.mp4","copy2.mp4") ;
//		method3("e:\\abc.mp4","copy3.mp4") ;
		method4("e:\\abc.mp4","copy4.mp4") ;
		
		long end = System.currentTimeMillis() ;
		
		System.out.println("共耗时:"+(end-start)+"毫秒");
	}
	
	//高效的流一次读取一个字节数组
	private static void method4(String src, String dest) throws Exception {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src))  ;
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest)) ;
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ; 
		int len = 0 ;
		while((len=bis.read(bys))!=-1) {
			bos.write(bys, 0, len);
		}
		
		bis.close();
		bos.close();
	}

	//高效的字节流一次读取一个字节
	private static void method3(String src, String dest) throws Exception {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src))  ;
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest)) ;
		
		//一次读个字节
		int by = 0 ;
		while((by=bis.read())!=-1) {
			bos.write(by);
		}
		//释放资源
		bis.close();
		bos.close();
	}

	//基本的字节流一次读取一个字节数组
	private static void method2(String src, String dest) throws Exception {
		//封装文件
		FileInputStream fis = new FileInputStream(src) ;
		FileOutputStream fos = new FileOutputStream(dest) ;
		
		//读写操作
		byte[] bys = new byte[1024] ;//相当于一个缓冲区
		int len = 0 ;
		while((len=fis.read(bys))!=-1) {
			fos.write(bys, 0, len);
		}
		
		//释放资源
		fis.close();
		fos.close();
		
	}

	//基本的字节流一次读取一个字节
	private static void method1(String src, String dest) throws Exception {
		//封装源文件和目标文件
		FileInputStream fis = new FileInputStream(src) ;
		FileOutputStream fos = new FileOutputStream(dest) ;
		
		//读写操作
		int by = 0 ;
		while((by=fis.read())!=-1) {
			//写
			fos.write(by);
		}
		
		//释放资源
		fis.close();
		fos.close();
		
	}
}

基本的字节流一次读取一个字节 :耗时:85772毫秒
基本的字节流一次读取一个字节数组 :共耗时:216毫秒
  
 高效的字节流一次读取一个字节      :共耗时:682毫秒

 高效的字节流一次读取一个字节数组:共耗时:49毫秒

使用字节流一次读取一个字节的方式,会造成中文乱码的问题，为此Java提供了一个字符流(专门用来解决中文乱码问题)

public class FileInputStreamDemo {
	
	public static void main(String[] args) throws Exception {
		
		//封装文件
		//一次读取一个字节的方式
		FileInputStream fis = new FileInputStream("a.txt") ;
		
		//读数据
		int by = 0 ;
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		
		//释放资源
		fis.close();
		
	}
}//hello
//world
//javaee
在当前目录下新建一个文件a.txt，内容是hello world Javaee 把内容输出在控制台上，如果只是输出，不加char，则会输出一堆乱码，

编码和解码:前后的编码格式要一致!
 编码:

简单理解:

                将能看懂的东西 ----->看不懂的东西

  解码:
  看不懂的东西 ---->能看懂的东西

  举例: 谍战片

        今天老地方见
 编码:
今天老地方见---->字节---->二进制数据

 解码:    二进制数据-->十进制数据--->字节---->字符串------>今天老地方见
 
 编码: 将字符串变成一个字节数组
public byte[ ] getBytes() :平台默认编码集(默认的是Gbk)
    public byte[ ] getBytes(Charset charset) ;指定编码格式
 
 解码:        将字节数组--->字符串
  public String(byte[ ] bytes) :使用平台默认编码集(gbk)
public String(byte[ ] bytes,Charset charset):用指定的编码格式来解码

import java.util.Arrays;

public class StringDemo {
	public static void main(String[] args) {
		
		//定义一个字符串
		String str = "你好";
		
		//编码和解码必须前后一致
		byte[] bys = str.getBytes();
		System.out.println(Arrays.toString(bys));
		
		//解码
		String s = new String (bys);
		System.out.println(s);
	}
}//[-60, -29, -70, -61]
//你好

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo {
	public static void main(String[] args) throws IOException {
		
		//定义一个字符串
		String str = "你好";
		
		//编码和解码必须前后一致
		//byte[] bys = str.getBytes();
		byte[] bys = str.getBytes("utf-8");
		System.out.println(Arrays.toString(bys));
		
		//解码
		String s = new String (bys,"utf-8");
		System.out.println(s);
	}
}//[-28, -67, -96, -27, -91, -67]
//你好

编码和解码必须一致

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo {
	public static void main(String[] args) throws IOException {
		
		//定义一个字符串
		String str = "你好";
		
		//编码和解码必须前后一致
		//byte[] bys = str.getBytes();
		byte[] bys = str.getBytes("gbk");
		System.out.println(Arrays.toString(bys));
		
		//解码
		String s = new String (bys,"gbk");
		System.out.println(s);
	}
}//[-60, -29, -70, -61]
//你好