day18 IO流

一.

1.文件的字节输入流
   使用字节流流读数据
   public FileInputStream(String name)
  
 开发步骤:
   1):创建字节文件输入流对象
   2)读数据
  3)释放资源

  读数据的两种方式:
  
   1)public int read():一次读取一个字节
   2)public int read(byte[] b):一次读取一个字节数组

一次读取一个字节的例子：

public class FileInputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//1)创建文件输入流对象
//		FileInputStream fis = new FileInputStream("fis.txt") ;
		FileInputStream fis = new FileInputStream("FileInputStreamDemo2.java") ;
		
		//2)读数据
		//public int read():一次读取一个字节
		//第一次读:
		/*int by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第二次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第三次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第四次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第五次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);
		
		//第六次读取
		by = fis.read() ;
		System.out.println(by);
		System.out.println((char)by);*/
		
		
		//第七次读取
//		by = fis.read() ;
//		System.out.println(by);
//		System.out.println((char)by);
		
		/**
		 * 上面代码重复非常高,采用循环,由于文件如果内容很多,不知道循环的次数,所以采用
		 * while循环,该循环应该有一个结束条件?
		 * 通过观察,当该文件读取完毕了 ,返回-1就是结束条件
		 */
		
		//优化改进
	/*	int by = fis.read() ;
		while(by!=-1){
			System.out.println((char)by);
			//继续读
			by = fis.read() ;
		}*/
		
		//最终版代码:
		//读取,赋值,判断
		//一次读取一个字节的模板代码
		int by = 0 ;
		while((by=fis.read())!=-1){
			//a--->97
			System.out.print((char)by);
		}
		
		//释放资源
		fis.close() ;
		
	}
}

一次读取一个字节数组的例子：

public class FileInputStreamDemo2 {
		
	public static void main(String[] args) throws IOException {
		
		//1)创建文件字节输入流对象
		FileInputStream fis = new FileInputStream("fis2.txt") ;
//		FileInputStream fis = new FileInputStream("FileInputStreamDemo.java") ;
		
		//2)读数据
		//public int read(byte[] b):一次读取一个字节数组
		//定义一个字节数组
/*		byte[] bys = new byte[5] ;//1)10KB
		
		//指定的字节数组的长度是1024或者是1024的倍数
		
		//第一次读取
		int len = fis.read(bys) ;
		System.out.println(new String(bys,0,len));
		
//		//第二次读取
		len = fis.read(bys) ;
		System.out.println(len);
//		System.out.println(new String(bys));
//		
//		//第三次读取
		len = fis.read(bys) ;
//		System.out.println(new String(bys));
//		
//		//第四次读取
		len = fis.read(bys) ;
//		System.out.println(new String(bys));
//		
		len = fis.read(bys) ;
//		System.out.println(new String(bys));
		System.out.println(len);*/
		
		
		/**
		 * 上述代码重复度高,使用while循环来进行优化改进
		 */
		
		//如果使用模板带去去读取数据:一次读取一个字节数组
		
		//定义缓冲区大小:指定长度为1024
		byte[] bys = new byte[1024] ;
		int len = 0 ; //读取字节数的实际长度
		while((len=fis.read(bys))!=-1){
//			System.out.println(new String(bys));//hello,world,java 
			//从指定的索引开始(指定0),读取的是实际长度
			System.out.println(new String(bys,0,len));//推荐使用这种格式读取数据:从0开始,读取实际长度
		}
		
	}
}

2.复制文件(同一个项目下的文件复制)

  需求:在当前项目下有一个:a.txt文件
   将a.txt文件的内容复制到b.txt文件中
  
  分析:
  1)数据源:a.txt------->FileInputStream:输入流------->读数据
  2)目的地:b.txt------->FileOutputStream:输出流------>写数据

例子：

public class CopyFileDemo {
	
	public static void main(String[] args) throws IOException {
		
		//封装数据源:
		//创建一个文件字节输入流对象
		FileInputStream fis = new FileInputStream("a.txt") ;
		//封装目的地
		//创建文件输出流对象
		FileOutputStream fos = new FileOutputStream("b.txt") ;
		
		//一次读取一个字节:模板代码
		int by = 0 ;
		while((by=fis.read())!=-1){
			//一次读一个字节,使用输出流给b.txt文件写一个字节
			fos.write(by) ;
		}
		
		//释放资源
		fos.close() ;
		fis.close() ;
	}
}

3.复制文件（不同项目下的文件复制）

需求:c盘下有一个a.txt文件内容,复制到d盘下的b.txt文件中,使用字节流读写操作
  @author Apple
  
 分析:数据源:C:\\a.txt文件---->FileInputStream----->读数据
     目的地:d:\\b.txt文件------>FileOutputStream---->写数据

代码：

public class CopyFileDemo2 {
	
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("c:\\a.txt") ;
		//封装目的地
		FileOutputStream fos = new FileOutputStream("d:\\b.txt") ;
		
		
		//一次读取一个字节
		int by = 0 ;
		while((by=fis.read()) !=-1){
			//写数据
			fos.write(by) ;
		}
		
		//释放资源:谁先后谁后无所谓
		fis.close() ;
		fos.close() ;
	}
}

4.复制图片

E盘下有一个高圆圆.jpg文件,将它图片内容复制到当前项目下的mm.jpg

 分析:数据源:----->e:\\高圆圆.jpg----->FileInputStream
     目的地-------->mm.jpg------->FileOutputStream 

代码：

使用字节流复制：

public class CopyImageDemo3 {
	
	public static void main(String[] args) throws IOException {
		
		//封装数据源
		FileInputStream fis = new FileInputStream("e:\\高圆圆.jpg") ;
		
		//封装目的地
		FileOutputStream fos = new FileOutputStream("mm.jpg") ;
		
		//读写操作
		int by = 0 ;
		while((by= fis.read())!=-1){
			//写数据
			fos.write(by) ;
		}
		
		//释放资源
		fis.close() ;
		fos.close() ;
 	}
}

使用字节数组复制：

public class CopyImageDemo {
	
	public static void main(String[] args) throws IOException {
		
		//封装数据源和目的地
		FileInputStream fis = new FileInputStream("E:\\高圆圆.jpg") ;
		FileOutputStream fos = new FileOutputStream("mm.jpg") ;
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=fis.read(bys))!=-1){
			//写数据的
			fos.write(bys, 0, len) ;
		}
		
		//释放资源
		fis.close() ;
		fos.close() ;
	}
}

5.复制视频文件

使用字节输入流一次读取一个字节数组

public class CopyMP4Demo {
	
	public static void main(String[] args) throws IOException {
		
		//封装数据源和目的地
		FileInputStream fis = new FileInputStream("e:\\abc.mp4") ;
		FileOutputStream fos = new FileOutputStream("Copy.mp4") ;
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=fis.read(bys))!=-1){
			fos.write(bys, 0, len) ;
		}
		
		//释放资源
		fis.close() ;
		fos.close() ;
	}
}

使用字节输入流一次读取一个字节

public class CopyMp4Demo {
	
	public static void main(String[] args) throws IOException {
		
		//封装数据源
		FileInputStream fis = new FileInputStream("E:\\abc.mp4") ;
		
		//封装目的地
		FileOutputStream fos = new FileOutputStream("Copy.mp4") ;
		
		//一次读取一个字节
		int by =  0; 
		while((by=fis.read())!=-1){
			fos.write(by) ;
		}
		
		//释放资源
		fis.close() ;
		fos.close() ;
	}
}

6.

补充：计算机是如何识别中文的?
   1)每个中文左边对应的字节一定是负数
   2)GBK格式:右边的字节可以中正数,可以是0,可以是负数
代码：

public class StringDemo {
	
	public static void main(String[] args) {
		
		//定义一个字符串
//		String s = "abcde" ;
		//[97, 98, 99, 100, 101]
		
		String s = "我爱你中国" ;
		//当前平台默认的编码集:GBK:一个中文对应两个字节
		//[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
		
		//将当前字符串转换成字节数组
		byte[] bys = s.getBytes() ;
//		System.out.println(bys);
		System.out.println(Arrays.toString(bys));
	}
}

二.缓冲流

1.由于字节数组比一次读取一个字节更快,从而引出类更高效的一种流:字节缓冲流
   字节缓冲输入流:BufferedInputStream
   字节缓冲输出流:BufferedOutputStream
    构造方式:
    public BufferedOutputStream(OutputStream out):默认缓冲区大小(默认缓冲大小已经足够大了)
   
   为什么字节缓冲流不能直接针对文件进行操作呢?
    缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件操作
   
   
   flush()和close()方法的区别?
    flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
    close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!

例子：

public class BufferedOutputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建字节缓冲输出流对象
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("bos.txt"));//Java的一种设计模式:装饰者设计模式:Scanner sc = new Scanner(System.in) ;
		
		//写数据
		bos.write(97) ;
		//刷新该缓冲区的流
		bos.flush() ;//迫使将这写字节强制输出流中
		bos.write(98) ;
		
		
		//释放资源
		bos.close() ;
		bos.flush() ;
//		bos.write(99) ;
	}
}

2.字节缓冲输入流:BufferedInputStream
  构造方法:
  BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象


缓冲输入流:一次读取一个字节:
一次读取一个字节数组
两种方式的读取任选一种:

例子：

public class BufferedInputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建一个字节缓冲输入流对象
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt")) ;
		
		//一次读取一个字节数组或者一次读取一个字节都可以
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=bis.read(bys))!=-1){
			System.out.println(new String(bys,0,len));
		}
		
		//释放资源
		bis.close() ;
	}
}

3.对于图片文件,音频文件,视频文件,优先采用字节缓冲输入流(高效流)一次读取一个字节数组!
 
  
 字节流复制文件:
  基本字节流(FileInputStream)一次读取一个字节:共耗时:253820毫秒
  基本字节流一次读取一个字节数组:共耗时:396毫秒
  高效字节流(字节缓冲输入流)一次读取一个字节:共耗时:98020毫秒


  高效字节流(字节缓冲输入流)一次读取一个字节数组:共耗时:317毫秒
  
  复制e:\\abc.mp4文件---->当前项目下的Copy.mp4文件

例子：

public class CopyFileDemo {
	
	public static void main(String[] args) throws IOException {
		long startTime = System.currentTimeMillis() ;
		
//		method1("E:\\abc.mp4","Copy.mp4") ;
//		method2("E:\\abc.mp4","Copy.mp4") ;
//		method3("E:\\abc.mp4","Copy.mp4") ;
		method4("E:\\abc.mp4","Copy.mp4") ;
		long endTime = System.currentTimeMillis() ;
		
		System.out.println("共耗时:"+(endTime-startTime)+"毫秒");
	}
	
	//高效字节流一次读取一个字节数组
	private static void method4(String SrcString, String destString) throws IOException{
		
		//封装数据源和目的地
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SrcString)) ;
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString)) ;
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=bis.read(bys))!=-1){
			bos.write(bys, 0, len) ;
			bos.flush() ;//刷新缓冲区的流
		}
		
		//释放资源
		bis.close() ;
		bos.close() ;
	}

	//字节缓冲输入流一次读取一个字节
	private static void method3(String SrcString, String destString) throws IOException {
		
		//创建字节缓冲输入对象
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SrcString)) ;
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString)) ;
		
		//一次读取一个字节
		int by = 0 ;
		while((by=bis.read())!=-1){
			bos.write(by)  ;
			bos.flush() ;
		}
		
		//释放资源
		bis.close() ;
		bos.close() ;
	}

	//基本的字节流一次读取一个字节数组
	private static void method2(String SrcString, String destString) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream(SrcString) ;
		//封装目的地
		FileOutputStream fos = new FileOutputStream(destString) ;
		
		//一次读取一个字节数组
		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 StrString, String destString) throws IOException {
		
		//封装数据源
		FileInputStream fis = new FileInputStream(StrString) ;
		//封装目的地
		FileOutputStream fos = new FileOutputStream(destString) ;
		
		//一次读取一个字节
		//并且一次写一个字节
		int by = 0 ;
		while((by=fis.read())!=-1){
			//写数据
			fos.write(by) ;
		}
		
		
		//释放资源
		fis.close() ;
		fos.close() ;
		
	}
}

4.编码:就是能看懂的字符串转换成看不懂的字节数组
   public byte[] getBytes(Charset charset):将字符串转换成字节数组,指定编码格式(字符集)
  解码:就是将看不懂的字节数组----->能看懂的:将字节数组--->字符串
   public String(byte[] bytes, Charset charset)通过使用指定的 编码格式 解码指定的 byte 数组，构造一个新的 String
  
  举例:谍战片
   老地方见...
  
  编码
  "老"----->字节数组----->二进制数据---->
  解码:二进制数据----->十进制数据----->字节数组----->构造方式:字符串
 例子：

public class StringDemo {

	public static void main(String[] args) throws IOException {
		
		String s = "爱你" ;
		
		//编码
//		byte[] bys = s.getBytes("utf-8")	;//:GBK[-80, -82, -60, -29]
											//utf-8:[-25, -120, -79, -28, -67, -96]
		
		//如果不写编码格式:默认GBK
		byte[] bys = s.getBytes() ;//[-80, -82, -60, -29]
//		System.out.println(bys);
		System.out.println(Arrays.toString(bys));
		
		//解码
		//public String(byte[] bytes, Charset charset)
//		String str = new String(bys, "GBK") ;
		String str = new String(bys) ;//默认GBK
		System.out.println(str);//爱你
	}
}

5.字节流一次读取一个字节,出现了中文乱码:
  原因是:给字节进行强制类型转换,代码代码的注释中有中文,并且平台默认编码:GBK格式:一个中文对应的两个字节
  使用字符流来进行操作:
   字符流就必须指定编码格式

例子：

public class FileInputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("FileInputStreamDemo2.java") ;
		
		//一次读取一个字节
		int by = 0 ;
		while((by=fis.read())!=-1){
			System.out.print((char)by);
		}
		
		//释放资源
		fis.close() ;
	}
}

三.字符输出\输入流

  1.字符输出流:Writer:是一个抽象类
   使用的是该抽象类的子类:OutputStreamWriter------>字符转换流:可以将字节输出流转换字符流
   public OutputStreamWriter(OutputStream out,Charset cs):创建一字符输出转换流对象,指定编码格式
   字节输出流+编码格式---->字符输出流
  
   编码格式:使用平台的默认编辑集进行编码:GBK
   public OutputStreamWriter(OutputStream out) ;
 例子：

public class OutputStreamWriterDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建一个字符输出流对象
		//public OutputStreamWriter(OutputStream out,Charset cs)
//		Writer w = new OutputStreamWriter(new FileOutputStream("w.txt"), "GBK") ;//抽象类多态
//		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
//				"osw.txt"), "GBK");
		
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
				"osw.txt"));//默认GBK
		
		
		//写数据
		osw.write("中国") ;
		
		//释放资源
		osw.close() ;
		
		
	}
}

2.字符输入流:字节输入流+编码格式(默认GBK)
  public InputStreamReader(InputStream in,charset sc) ;

例子：

public class InputStreamReaderDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建字符输入流对象
		/*InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"osw.txt"), "GBK");*/
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"osw.txt"));//以GBK格式读数据
		
		//读数据:一次读取一个字符
		/*int ch = 0 ;
		while((ch=isr.read())!=-1){
			System.out.print((char)ch);
		}*/
		
		char[] chs = new char[1024] ;
		int len = 0;
		while((len=isr.read(chs))!=-1){
			System.out.println(new String(chs, 0, len));
		}
		
		//释放资源
		isr.close() ;
	}
}

3.关于字符输出流写数据的方法:
   public void write(int c):写单个字符
public void write(char[] cbuf):写一个字符数组
   public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
   public void write(String str):写字符串
   public void write(String str, int off,int len):写字符串的一部分

例子：

public class OutputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建字符输出流对象
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
				"osw2.txt"));
		
		//写数据
		//public void write(int c):写单个字符
//		osw.write(97) ;
//		osw.write('a') ;
		
		//public void write(char[] cbuf):写一个字符数组
		//定义一个字符数组:静态初始化
//		char[] chs = {'a','b','c','d','e'}	 ;
		osw.write(chs) ;
//		
//		//public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
//		osw.write(chs, 1, 3) ;
		
		//public void write(String str):写字符串
		String str = "我爱高圆圆" ;
		osw.write(str) ;
		
		//public void write(String str, int off,int len):写字符串的一部分
		osw.write(str, 1, 3) ;
		
		
		//void flush()刷新该流
		osw.flush() ;
		
		
		//关闭流对象
		osw.close() ;
//		osw.write('b') ;//字符输出流:如果流已经关闭,那么写数据会报异常!
	}
}

4.字符输入流读数据的方式:
   public int read():一次读取一个字符
  public int read(char[] chs):一次读取一个字符数组

例子：

public class InputStreamReaderDemo {
	
	public static void main(String[] args) throws IOException {
		
		//1)创建字符输入流对象
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"FileInputStreamDemo2.java"));
		
		//2)方式1:一次读取一个字符
		/*int ch = 0 ;
		while((ch=isr.read())!=-1){
			System.out.print((char)ch);
		}*/
		
		//2)方式2:一次读取一个字符数组
		char[] chs = new char[1024] ;
		int len = 0 ;
		while((len=isr.read(chs))!=-1){
			System.out.println(new String(chs, 0, len));
		}
		
		
		//释放资源
		isr.close() ;
	}
	
}

5.复制

（1）需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作
  
  分析
  数据源:a.txt---->Reader---->InputStreamReader(InputStream in):字符转换输入流
  目的地:b.txt---->Writer---->OutputStreamWriter(Outputstream out):字符转换输出流

例子：

public class CopyFileTest {
	
	public static void main(String[] args) throws IOException {
		
		//1)创建字符转换输入流对象
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"a.txt"));
		
		//2)封装目的地
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
				"b.txt"));
		
		//一次读取一个字符数组
		char[] chs = new char[1024] ;
		int len = 0;
		while((len=isr.read(chs))!=-1){
			//写数据:
			osw.write(chs, 0, len) ;
			//刷新流
			osw.flush() ;
		}
		
		//释放资源
		isr.close() ;
		osw.close() ;
	}
}

（2）使用字符转换流进行操作数据的时候:字节流+编码格式
  并且在书写代码名称非常长,Java提供了以中更简单的类:便捷类:
   字符转换输入流:InputStreamReader----->FileReader
   FileReder(String fileName) 
   字符转换输出流:OutputStreamWriter---->FileWriter
   FileWriter(String fileName) 
 
  需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作
  
  分析:
   数据源:a.txt---->字符流读数据:InputStreamReader------>便捷类:FileReader
   目的地:b.txt---->字符流写数据:OutputStreamWriter----->便捷类:FileWriter

例子：

public class FileReaderDemo {
	
	public static void main(String[] args) throws IOException {
		
		
		//1)封装数据源和目的地
		FileReader fr = new FileReader("a.txt") ;
		FileWriter fw = new FileWriter("b.txt") ;
		
		//一次读取一个字符数组
		char[] chs = new char[1024] ;
		int len = 0 ;
		while((len=fr.read(chs))!=-1){
			fw.write(chs, 0, len) ;
			fw.flush() ;
		}
		
		//关闭资源
		fw.close() ;
		fr.close() ;
	}
}

6.字符流为了提高读写速度,Java就提供了一个字符缓冲流的类:
   BufferedReader:字符缓冲输入流
   BufferedWriter:字符缓冲输出流
   将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 
   可以指定缓冲区的大小，或者接受默认的大小
  
   构造方式:
  public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流

public class BufferedWriterDemo {
	
	public static void main(String[] args) throws IOException {
		
		//创建字符缓冲输出流对象
		//public BufferedWriter(Writer out)
		/*BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				new FileOutputStream("bw.txt")));*/
		BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;
		
		//写数据
		bw.write("javaee") ;
		bw.write("hello") ;
		bw.write("world") ;
		bw.write("java") ;
		
		
		
		
		//刷新流
		bw.flush() ;
		
		//关闭资源
		bw.close() ;
	}
}

7.字符缓冲输入流
  BufferedReader
   BufferedReader(Reader in) :创建默认缓冲大小

例子：

public class BufferedReaderDemo {

	public static void main(String[] args) throws IOException {
		
		//1)创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader(new FileReader("bw.txt")) ;
		
		//方式1:一次读取一个字符
//		int ch = 0 ;
//		while((ch=br.read())!=-1){
//			System.out.print((char)ch);
//		}
		
		//方式2:一次读取一个字符数组
		char[] chs = new char[1024] ;
		int len = 0 ;
		while((len = br.read(chs))!=-1){
			System.out.println(new String(chs, 0, len));
		}
		
//		关闭资源
		br.close() ;
	}
}

8.关于字符缓冲输入流的特有功能:
  BufferedWriter:
   public void newLine():写入一个换行符号
  BufferReader:
   public String readLine():一次读取一行

例子：

public class BufferedDemo {
	
	public static void main(String[] args) throws IOException {
		
		write();
		
		read();
	}

	private static void read() throws FileNotFoundException, IOException {
		//读数据
		//创建一个字符缓冲输入流对象
		BufferedReader br = new BufferedReader(new FileReader("bw2.txt")) ;
		
		//读数据
		//public String readLine():一次读取一行
		/*String line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);
		
		line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);
	 line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);
		 line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);
		 line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);
		
		 line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);
		 line = br.readLine() ;
		System.out.println(line);
		
		//第二次读取
		line = br.readLine() ;
		System.out.println(line);*/
		
		//这种方式读数据:一次读取一行数据,什么时候结束?
		//当数据读取完毕,如果返回值是null,说明已经读完了
		
		//代码重复度高,使用循环改进
		String line = null ;
		while((line=br.readLine())!=null){
			System.out.println(line);
		}
		//释放资源
		br.close() ;
	}

	private static void write() throws IOException {
		//写数据
		//创建一个字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt")) ;
		
		//写数据
		for(int x = 0 ; x <10 ; x ++){
			bw.write("hello"+x) ;
			//没有使用这个方法之前:使用写入换行符号
//			bw.write("\r\n") ;
			//使用特有功能
			bw.newLine() ;
						
			//刷新该流
			bw.flush() ;
		}
		
		//释放资源
		bw.close() ;
	}
}

9.键盘录入的另一种方法：

public class Demo {
	
	public static void main(String[] args) throws IOException {
		
		//1)创建键盘录入对象
		/*Scanner sc = new Scanner(System.in);//InputStream is = System.in;
		
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		System.out.println(line);*/
		
		//使用IO流的形式读数据
		//BufferedReadr进行包装
	/*	InputStream is = System.in ;//标准输入流
	 * 
	 * 	
		
		//使用is对象能不能一次读取一个数据呢?
		//不能使用它进行读取数据,BufferedReader可以
		
		//BufferedReader br = new BufferedReader(is) ;//字符缓冲输入流只能针对字符输入流进行操作,不能针对字节流进行操作
		
		//需要将标准输入流转换成字符输入流:InputStreamReader(InputStream in)
		//创建字符转换输入流对象
		InputStreamReader isr = new InputStreamReader(is) ;
		
		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader(isr) ;*/
		//一步走
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
		
		System.out.println("请输入一个整数:");
		String str = br.readLine() ;//返回值是一个字符串
		
		int number = Integer.parseInt(str) ;
		System.out.println("您输入的整数是:"+number);
		
		//标准输出流
//		PrintStream out = System.out ;
		//PrintWriter
		
	}
}