devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JavaSe基础XX18——IO流_2_字符流缓冲区

作者：AllinToyou | 2024-03-16 04:26:15

赞

踩

xx18

*11-IO流(字符流-缓冲区-解释)

//创建一个临时容器，用于缓存读取到的字符。
char[] buf = new char[BUFFER_SIZE];//这就是缓冲区。 是自己new出来的。提高效率

Java就把这个缓冲区封装成一个对象，其实把缓冲区封装成对象，就是在一个类中封装一个数组。

对于读和写都封装成了对象。

IO包中：








*12-IO流(字符流-缓冲区-BufferedWriter)

之前缓冲区，是自己new出来的，

系统给了，bufferwriter，bufferreader、





缓冲区创建的时候，必须指定要缓存的对象，也就是Writer对象。


以前这样写：



提高效率，就要加缓冲区了：



注意：关掉buffer的时候也会把流给关掉。



  1. package cn.itcast.p2.io.charstream.buffer;
  2.  
  3. import java.io.BufferedWriter;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6.  
  7. public class BufferedWriterDemo {
  8.  
  9. 	private static final String LINE_SEPARATOR = System.getProperty("line.separator");
  10.  
  11. 	/**
  12. 	 * @param args
  13. 	 * @throws IOException 
  14. 	 */
  15. 	public static void main(String[] args) throws IOException {
  16.  
  17. 		FileWriter fw = new FileWriter("buf.txt");
  18. 		
  19. 		//为了提高写入的效率。使用了字符流的缓冲区。
  20. 		//创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联
  21. 		BufferedWriter bufw = new BufferedWriter(fw);
  22. 		
  23. 		//使用缓冲区的写入方法将数据先写入到缓冲区中。
  24. //		bufw.write("abcdefq"+LINE_SEPARATOR+"hahahha");      效果和bufw.newLine();一样，其实调用的也是system.
  25. //		bufw.write("xixiixii");
  26. //		bufw.newLine();
  27. //		bufw.write("heheheheh");
  28. 		
  29. 		for(int x=1; x<=4; x++){
  30. 			bufw.write("abcdef"+x);
  31. 			bufw.newLine();
  32. 			bufw.flush();
  33. 		}
  34. 		
  35. 		
  36. 		//使用缓冲区的刷新方法将数据刷目的地中。
  37. //		bufw.flush();
  38. 		
  39. 		
  40. 		//关闭缓冲区。其实关闭的就是被缓冲的流对象。
  41. 		bufw.close();
  42. 		
  43. //		fw.write("hehe");
  44. 		
  45. //		fw.close();
  46. 	}
  47.  
  48. }

*13-IO流(字符流-缓冲区-BufferedReader)

读怎么读？

以前的读法：

  1. 	public static void demo() throws FileNotFoundException, IOException {
  2. 		FileReader fr = new FileReader("buf.txt");
  3. 		
  4. 		char[] buf = new char[1024];
  5. 		
  6. 		int len = 0;
  7. 		while((len=fr.read(buf))!=-1){
  8. 			System.out.println(new String(buf,0,len));
  9. 		}
  10. 		
  11. 		fr.close();
  12. 	}


新的:





读文本：可以一个一个字符读，也可以读完放数组中，也可以一行一行读。



  1. public class BufferedReaderDemo {
  2.  
  3. 	/**
  4. 	 * @param args
  5. 	 * @throws IOException 
  6. 	 */
  7. 	public static void main(String[] args) throws IOException {
  8.  
  9. 		FileReader fr = new FileReader("buf.txt");
  10. 		
  11. 		BufferedReader bufr = new BufferedReader(fr);
  12. 		
  13. 		String line = null;
  14. 		
  15. 		while((line=bufr.readLine())!=null){
  16. 			System.out.println(line);
  17. 		}
  18. 		/*
  19. 		String line1 = bufr.readLine();
  20. 		System.out.println(line1);
  21. 		String line2 = bufr.readLine();
  22. 		System.out.println(line2);
  23. 		String line3 = bufr.readLine();
  24. 		System.out.println(line3);
  25. 		String line4 = bufr.readLine();
  26. 		System.out.println(line4);
  27. 		String line5 = bufr.readLine();
  28. 		System.out.println(line5);
  29. 		*/
  30. 		
  31. 		
  32. 		bufr.close();
  33. 		
  34. 		
  35. 	}


*14-IO流(字符流-缓冲区-BufferedReader-readLine方法原理)


read ,read()和read(char[])  ——硬盘里面读


bufferread 重写了父类的read()和read(char[]) ——缓冲区读，内存操作，快。


bufr.read()：一次只能读一个字符；

bufr.readLine()：一次读一行。








*15-IO流(字符流-缓冲区-复制文本文件)

一种方法：


第二种方法：读一行，写一行。




这样会只存在一行里面。



  1. package cn.itcast.p3.io.charstream.buffer.test;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.FileNotFoundException;
  6. import java.io.FileReader;
  7. import java.io.FileWriter;
  8. import java.io.IOException;
  9.  
  10. public class CopyTextByBufTest {
  11.  
  12. 	/**
  13. 	 * @param args
  14. 	 * @throws IOException 
  15. 	 */
  16. 	public static void main(String[] args) throws IOException {
  17.  
  18. 		FileReader fr = new FileReader("buf.txt");		
  19. 		BufferedReader bufr = new BufferedReader(fr);
  20. 		
  21. 		FileWriter fw = new FileWriter("buf_copy.txt");
  22. 		BufferedWriter bufw = new BufferedWriter(fw);
  23. 		
  24. 		
  25. 		String line = null;
  26. 		while((line=bufr.readLine())!=null){
  27. 			bufw.write(line);
  28. 			bufw.newLine();
  29. 			bufw.flush();
  30. 		}
  31. 		
  32. 		
  33. 		
  34. 		
  35. 		/*
  36. 		int ch = 0;
  37. 		
  38. 		while((ch=bufr.read())!=-1){
  39. 			
  40. 			bufw.write(ch);
  41. 		}
  42. 		*/
  43. 		bufw.close();
  44. 		bufr.close();
  45. 	}
  46.  
  47. }


*16-IO流(字符流-缓冲区-自定义MyBufferedReader-read方法)



1.read方法：


  1. /**
  2.  * 自定义的读取缓冲区。其实就是模拟一个BufferedReader.
  3.  * 
  4.  * 分析：
  5.  * 缓冲区中无非就是封装了一个数组，
  6.  * 并对外提供了更多的方法对数组进行访问。
  7.  * 其实这些方法最终操作的都是数组的角标。
  8.  * 
  9.  * 缓冲的原理：
  10.  * 其实就是从源中获取一批数据装进缓冲区中。
  11.  * 在从缓冲区中不断的取出一个一个数据。
  12.  * 
  13.  * 在此次取完后，在从源中继续取一批数据进缓冲区。
  14.  * 当源中的数据取光时，用-1作为结束标记。 
  15.  * 
  16.  * 
  17.  * @author Administrator
  18.  *
  19.  */
  20. public class MyBufferedReader extends Reader {
  21.  
  22. 	private Reader r;
  23. 	
  24. 	//定义一个数组作为缓冲区。
  25. 	private char[] buf = new char[1024];
  26. 	
  27. 	//定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针应该归零。	
  28. 	private int pos = 0;	
  29. 	
  30. 	
  31. 	//定义一个计数器用于记录缓冲区中的数据个数。 当该数据减到0，就从源中继续获取数据到缓冲区中。
  32. 	private int count = 0;
  33. 	
  34. 	
  35. 	MyBufferedReader(Reader r){
  36. 		this.r = r;
  37. 	}
  38. 	
  39. 	/**
  40. 	 * 该方法从缓冲区中一次取一个字符。 
  41. 	 * @return
  42. 	 * @throws IOException
  43. 	 */
  44. 	public int myRead() throws IOException{
  45. 		
  46. 		if(count==0){
  47. 			count = r.read(buf);
  48. 			pos = 0;
  49. 		}
  50. 		if(count<0)
  51. 			return -1;
  52. 		
  53. 		char ch = buf[pos++];
  54. 		
  55. 		count--;
  56. 		
  57. 		return ch;
  58. 		
  59. 		/*
  60. 		//1,从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。
  61. 		if(count==0){
  62. 			count = r.read(buf);
  63. 			
  64. 			if(count<0)
  65. 				return -1;
  66. 			
  67. 			//每次获取数据到缓冲区后，角标归零.
  68. 			pos = 0;
  69. 			char ch = buf[pos];
  70. 			
  71. 			pos++;
  72. 			count--;
  73. 			
  74. 			return ch;
  75. 			
  76. 		}else if(count>0){
  77. 			
  78. 			char ch = buf[pos];
  79. 			
  80. 			pos++;
  81. 			count--;
  82. 			
  83. 			return ch;
  84. 			
  85. 		}*/
  86. 		
  87. 	}




*17-IO流(字符流-缓冲区-自定义MyBufferedReader-readLine方法)

readLine()的实现。

  1. public String myReadLine() throws IOException{
  2. 		
  3. 		StringBuilder sb = new StringBuilder();
  4. 		
  5. 		int ch = 0;
  6. 		while((ch = myRead())!=-1){
  7. 			
  8. 			if(ch=='\r')
  9. 				continue;
  10. 			if(ch=='\n')
  11. 				return sb.toString();
  12. 			//将从缓冲区中读到的字符，存储到缓存行数据的缓冲区中。
  13. 			sb.append((char)ch);
  14. 			
  15. 		}		
  16. 		
  17. 		if(sb.length()!=0)
  18. 			return sb.toString();
  19. 		return null;
  20. 	}

MyBufferReaderDemo： 

  1. package cn.itcast.p4.io.charstream.mybuffer;
  2.  
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.util.Collections;
  6. import java.util.HashMap;
  7.  
  8. public class MyBufferedReaderDemo {
  9.  
  10. 	/**
  11. 	 * @param args
  12. 	 * @throws IOException 
  13. 	 */
  14. 	public static void main(String[] args) throws IOException {
  15.  
  16. 		FileReader fr = new FileReader("buf.txt");
  17. 		
  18. 		MyBufferedReader bufr = new MyBufferedReader(fr);
  19. 		
  20. 		String line = null;
  21. 		
  22. 		while((line=bufr.myReadLine())!=null){
  23. 			System.out.println(line);
  24. 		}
  25. 		
  26. 		bufr.myClose();
  27. 		
  28. 		
  29. 		Collections.reverseOrder();
  30. 		HashMap map = null;
  31. 		map.values();
  32. 		
  33. 		
  34. 	}
  35.  
  36. }

MyBufferReader： 

  1. package cn.itcast.p4.io.charstream.mybuffer;
  2.  
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.io.Reader;
  6.  
  7. /**
  8.  * 自定义的读取缓冲区。其实就是模拟一个BufferedReader.
  9.  * 
  10.  * 分析：
  11.  * 缓冲区中无非就是封装了一个数组，
  12.  * 并对外提供了更多的方法对数组进行访问。
  13.  * 其实这些方法最终操作的都是数组的角标。
  14.  * 
  15.  * 缓冲的原理：
  16.  * 其实就是从源中获取一批数据装进缓冲区中。
  17.  * 在从缓冲区中不断的取出一个一个数据。
  18.  * 
  19.  * 在此次取完后，在从源中继续取一批数据进缓冲区。
  20.  * 当源中的数据取光时，用-1作为结束标记。 
  21.  * 
  22.  * 
  23.  * @author Administrator
  24.  *
  25.  */
  26. public class MyBufferedReader extends Reader {
  27.  
  28. 	private Reader r;
  29. 	
  30. 	//定义一个数组作为缓冲区。
  31. 	private char[] buf = new char[1024];
  32. 	
  33. 	//定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针应该归零。	
  34. 	private int pos = 0;	
  35. 	
  36. 	
  37. 	//定义一个计数器用于记录缓冲区中的数据个数。 当该数据减到0，就从源中继续获取数据到缓冲区中。
  38. 	private int count = 0;
  39. 	
  40. 	
  41. 	MyBufferedReader(Reader r){
  42. 		this.r = r;
  43. 	}
  44. 	
  45. 	/**
  46. 	 * 该方法从缓冲区中一次取一个字符。 
  47. 	 * @return
  48. 	 * @throws IOException
  49. 	 */
  50. 	public int myRead() throws IOException{
  51. 		
  52. 		if(count==0){
  53. 			count = r.read(buf);
  54. 			pos = 0;
  55. 		}
  56. 		if(count<0)
  57. 			return -1;
  58. 		
  59. 		char ch = buf[pos++];
  60. 		
  61. 		count--;
  62. 		
  63. 		return ch;
  64. 		
  65. 		/*
  66. 		//1,从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。
  67. 		if(count==0){
  68. 			count = r.read(buf);
  69. 			
  70. 			if(count<0)
  71. 				return -1;
  72. 			
  73. 			//每次获取数据到缓冲区后，角标归零.
  74. 			pos = 0;
  75. 			char ch = buf[pos];
  76. 			
  77. 			pos++;
  78. 			count--;
  79. 			
  80. 			return ch;
  81. 			
  82. 		}else if(count>0){
  83. 			
  84. 			char ch = buf[pos];
  85. 			
  86. 			pos++;
  87. 			count--;
  88. 			
  89. 			return ch;
  90. 			
  91. 		}*/
  92. 		
  93. 	}
  94. 	
  95. 	public String myReadLine() throws IOException{
  96. 		
  97. 		StringBuilder sb = new StringBuilder();
  98. 		
  99. 		int ch = 0;
  100. 		while((ch = myRead())!=-1){
  101. 			
  102. 			if(ch=='\r')
  103. 				continue;
  104. 			if(ch=='\n')
  105. 				return sb.toString();
  106. 			//将从缓冲区中读到的字符，存储到缓存行数据的缓冲区中。
  107. 			sb.append((char)ch);
  108. 			
  109. 		}		
  110. 		
  111. 		if(sb.length()!=0)
  112. 			return sb.toString();
  113. 		return null;
  114. 	}
  115.  
  116. 	public void myClose() throws IOException {
  117. 		
  118. 		r.close();
  119. 	}
  120.  
  121. 	@Override
  122. 	public int read(char[] cbuf, int off, int len) throws IOException {
  123. 		
  124. 		return 0;
  125. 	}
  126.  
  127. 	@Override
  128. 	public void close() throws IOException {
  129. 	}
  130. }
  131.

*18-IO流(字符流-缓冲区-装饰设计模式)


装饰设计模式：
对一组对象的功能进行增强时，就可以使用该模式进行问题的解决。


  1. package cn.itcast.p5.wrapper;
  2.  
  3. public class PersonDemo {
  4.  
  5. 	/**
  6. 	 * @param args
  7. 	 */
  8. 	public static void main(String[] args) {
  9.  
  10. 		Person p = new Person();
  11. //		p.chifan();
  12. 		
  13. 		NewPerson p1 = new NewPerson(p);
  14. 		p1.chifan();
  15. 		
  16. 		NewPerson2 p2 = new NewPerson2();
  17. 		p2.chifan();
  18. 	}
  19.  
  20. }
  21.  
  22. class Person{
  23. 	void chifan(){
  24. 		System.out.println("吃饭");
  25. 	}
  26. }
  27. //这个类的出现是为了增强Person而出现的。
  28. class NewPerson{
  29. 	private Person p ;
  30. 	NewPerson(Person p){
  31. 		this.p = p;
  32. 	}
  33. 	
  34. 	public void chifan(){
  35. 		System.out.println("开胃酒");
  36. 		p.chifan();
  37. 		System.out.println("甜点");
  38. 		
  39. 	}
  40.  
  41. }
  42.  
  43. class NewPerson2 extends Person{
  44. 	public void chifan(){
  45. 		System.out.println("开胃酒");
  46. 		super.chifan();
  47. 		System.out.println("甜点");
  48. 	}
  49. }

装饰好呢？还是继承好呢？

装饰和继承都能实现一样的特点：进行功能的扩展增强。 


有什么区别呢？


*19-IO流(字符流-缓冲区-装饰设计模式和继承的区别)



有什么区别呢？


首先有一个继承体系。
Writer
|--TextWriter:用于操作文本
|--MediaWriter：用于操作媒体。

想要对操作的动作进行效率的提高。
按照面向对象，可以通过继承对具体的进行功能的扩展。 
效率提高需要加入缓冲技术。

Writer
|--TextWriter:用于操作文本
|--BufferTextWriter:加入了缓冲技术的操作文本的对象。
|--MediaWriter：用于操作媒体。
|--BufferMediaWriter:


到这里就哦了。但是这样做好像并不理想。
如果这个体系进行功能扩展，有多了流对象。
那么这个流要提高效率，是不是也要产生子类呢？是。这时就会发现只为提高功能，进行的继承，
导致继承体系越来越臃肿。不够灵活。 


重新思考这个问题？
既然加入的都是同一种技术--缓冲。
前一种是让缓冲和具体的对象相结合。 
可不可以将缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联。


class Buffer{
Buffer(TextWriter w)
{}

Buffer(MediaWirter w)
{

}
}
class BufferWriter extends Writer{
BufferWriter(Writer w)
{
}
}
Writer
|--TextWriter:用于操作文本
|--MediaWriter：用于操作媒体。
|--BufferWriter:用于提高效率。

装饰比继承灵活。


特点：装饰类和被装饰类都必须所属同一个接口或者父类。 


装饰设计模式。


*20-IO流(字符流-缓冲区-LineNumberReader)



















声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/247043
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号