• java基础---缓冲流、数据流、打印流

    缓冲流

    缓冲流是套接在响应的节点流之上，对续写的数据提供缓冲的功能，提高读写的效率，同时增加了一些新方法
    以介质是硬盘为例，字节流和字符流的弊端：在每一次读写的时候，都会访问硬盘。 如果读写的频率比较高的时候，其性能表现不佳。为了解决以上弊端，采用缓存流。
    缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。 
    1. package com.yan3;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.FileReader;
    5. import java.io.Reader;
    6.  
    7. /*
    8.  * ### 缓冲流
    9.  * 缓冲流是套接在响应的节点流之上，对续写的数据提供缓冲的功能，提高读写的
    10.  * 效率，同时增加了一些新方法
    11.  * 
    12.  * 以介质是硬盘为例，字节流和字符流的弊端：在每一次读写的时候，都会访问硬
    13.  * 盘。 如果读写的频率比较高的时候，其性能表现不佳。为了解决以上弊端，采用
    14.  * 缓存流。
    15.  * 
    16.  * 缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都
    17.  * 是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。
    18.  */
    19. public class Test5 {
    20. 	public static void main(String[] args) {
    21. 		long start = System.currentTimeMillis();
    22. //		useReader();  //207ms
    23. 		useReader2(); // 152ms
    24. 		long end = System.currentTimeMillis();
    25. 		System.out.println(end - start + "ms");
    26. 	}
    27.  
    28. 	public static void useReader() {
    29. 		try (Reader r = new FileReader("data/calcCharNum.txt")) {
    30. 			while (true) {
    31. 				int kk = r.read();
    32. 				if (kk == -1) {
    33. 					break;
    34. 				}
    35. 				System.out.print((char) kk);
    36. 			}
    37. 		} catch (Exception e) {
    38. 			e.printStackTrace();
    39. 		}
    40. 	}
    41.  
    42. 	public static void useReader2() {
    43. 		try (Reader r = new BufferedReader(new FileReader("data/calcCharNum.txt"))) {
    44. 			while (true) {
    45. 				int kk = r.read();
    46. 				if (kk == -1) {
    47. 					break;
    48. 				}
    49. 				System.out.print((char) kk);
    50. 			}
    51. 		} catch (Exception e) {
    52. 			e.printStackTrace();
    53. 		}
    54. 	}
    55. }

    构造方法

    • BufferedReader(Reader)不定义缓存大小，默认8192
    • BufferedReader(Reader in, int size)size为自定义缓冲区的大小
    • BufferedWriter(Writer)
    • BufferedWriter(Writer out, int size)size为自定义缓冲区的大小
    • BufferedInputStream(InputStream)
    • BufferedInputStream(InputStream in, int size)size为自定义缓冲区的大小
    • BufferedOutputStream(OutputStream)
    • BufferedOutputStream(OuputStream out, int size)size为自定义缓冲区的大小

    缓冲输入流的方法

    BuffedReader 提供了一个方法 readLine():String ，但是 BufferedInputStream 中并没有这个
    • BufferedReader提供了readLine方法用于读取一行字符串，以\r或\n分割（换行符）
                    如果读取内容为null，则表示读取到了流的末尾
                    readLine方法会自动剔除本行内容末尾的换行符
    • BufferedWriter提供了newLine方法用于写入一个行分隔符
    对于输出的缓冲流，写入的数据会先在内存中缓存，使用 flush 方法会使内存中的数据立即写出

    键盘录入

    System.in:InputStream 用于指代系统默认的输入设备 — 键盘
    方法 read():int 可以实现代码执行到这里则会阻塞等待，只要输入数据为止 
    1. package com.yan3;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.InputStreamReader;
    5.  
    6. /*
    7.  * 缓冲输入流的方法
    8.  * 
    9.  *  BuffedReader提供了一个方法readLine():String，但是BufferedInputStream中并
    10.  * 没有这个
    11.  * 
    12.  * - BufferedReader提供了readLine方法用于读取一行字符串，以\r或\n分割（换行符）
    13.   	- 如果读取内容为null，则表示读取到了流的末尾
    14.   	- readLine方法会自动剔除本行内容末尾的换行符
    15.   	
    16.   - BufferedWriter提供了newLine方法用于写入一个行分隔符
    17.   对于输出的缓冲流，写入的数据会先在内存中缓存，使用flush方法会使内存中的
    18.   数据立即写出
    19.  */
    20. public class Test7 {
    21. 	public static void main(String[] args) throws Exception {
    22. 		// 要求用户输入一个合法的整型数
    23. 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    24. 		int age = 0;
    25. 		while (true) {
    26. 			String ss = br.readLine();// BufferedReader提供的特殊方法，用于实现整行读取
    27. 			try {
    28. 				age = Integer.parseInt(ss.trim());
    29. 				if (age >= 18 && age <= 65) {
    30. 					break;
    31. 				} else {
    32. 					System.out.println("年龄范围不合法！！！");
    33. 				}
    34. 			} catch (Exception e) {
    35. 				System.out.println("格式错误！");
    36. 			}
    37. 		}
    38. 		System.out.println("合法的年龄输入为 " + age);
    39. 	}
    40. }
    使用缓存流并没有添加什么额外方法，只是它能够在执行过程中自动引入缓存，从而提高执行效率
    过滤流使用必须有对应的节点流，因为过滤流是装饰节点流，不是有具体的操作目标
    new BufferedReader(new FileReader(..)) 或 new BufferedWriter(new FileWriter()) 实际上使用的还是Reader/Writer那些方法，这里从编码的角度上说，没有任何区别，但是从执行性能上说，比FileReader/Writer效率高，可以减少磁盘的读写次数
    执行 close 方法会自动关闭被装饰的对象，所以不需要再关闭 FileReader 和 FileWriter
    执行 flush 会自动刷新数据到节点流上，但是并没有执行关闭流。针对输出流关闭时会自动先 flush 缓存再执行关闭
    使用java的输入/输出流技术将一个文本文件的内容按行读出，每读出一行就顺序添加行号，并写入到另一个文件中。 
    1. package com.yan4;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.BufferedWriter;
    5. import java.io.FileReader;
    6. import java.io.FileWriter;
    7. /*
    8.  * 使用java的输入/输出流技术将一个文本文件的内容按行读出，每
    9.  * 读出一行就顺序添加行号，并写入到另一个文件中。
    10.  */
    11.  
    12. public class Exec01 {
    13. 	public static void main(String[] args) throws Exception {
    14. 		try (BufferedReader br = new BufferedReader(new FileReader("src/com/yan1/Test1.java"));
    15. 				BufferedWriter bw = new BufferedWriter(new FileWriter("data/out1.txt"))) {
    16. 			int cc = 0;
    17. 			while (true) {
    18. 				String ss = br.readLine();
    19. 				if (ss == null)
    20. 					break;
    21. 				bw.write(++cc + "\t");
    22. 				bw.write(ss);
    23. 				bw.newLine();
    24. 			}
    25. 		}
    26. 	}
    27. }

    数据流

    DataInputStream 和 DataOutputStream 两个类创建的对象分别被称为数据输入流和数据输出流。这是很有用的两个流，它们允许程序按与机器无关的风格读写Java 数据。所以比较适合于网络上的数据传输。这两个流也是过滤器流，常以其它流如InputStream 或 OutputStream 作为它们的输入或输出
    DataInputStram和 DataOutputStream 分别继承自 InputStream 和 OuputStream ，属于过滤流，需要分别套接在InputStream 和 OutputStream 类型的节点流上
    • 只有字节流，没有对应的字符流
    DataInputStream和DataOutputStream 提供了可以存取与机器无关的 Java 原始类型数据的方法
    DataInputSteram 和 DataOutputStream 构造方法为
    • DataInputStream(InputStream)
    • DataOutputStream(OutputStream)

    用数据输出流将斐波那契级数的前二十项存放在fei.dat文件中。

    1. package com.yan3;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.EOFException;
    6. import java.io.FileInputStream;
    7. import java.io.FileOutputStream;
    8.  
    9. /*
    10.  * 用数据输出流将斐波那契级数的前二十项存放在fei.dat文件中
    11.  */
    12. public class Test81 {
    13. 	public static void main(String[] args) throws Exception {
    14. 		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data/fei.dat"));
    15. 		for (int i = 0; i < 20; i++) {
    16. 			int num = fei(i);
    17. 			dos.writeInt(num);
    18. 		}
    19. 		dos.close();
    20.  
    21. 		DataInputStream dis = new DataInputStream(new FileInputStream("data/fei.dat"));
    22. 		try {
    23. 			while (true) {
    24. 				int kk = dis.readInt();
    25. 				System.out.print(kk + "\t");
    26. 			}
    27. 		} catch (EOFException e) {
    28. 			System.out.println("文件读取完毕");
    29. 		}
    30. 		dis.close();
    31. 	}
    32.  
    33. 	public static int fei(int pos) {
    34. 		if (pos == 0) {
    35. 			return 0;
    36. 		}
    37. 		if (pos == 1) {
    38. 			return 1;
    39. 		}
    40. 		return fei(pos - 1) + fei(pos - 2);
    41. 	}
    42. }

    从fei.dat文件中读出数列，显示输出，并计算累加和

    1. package com.yan3;
    2.  
    3. import java.io.ByteArrayInputStream;
    4. import java.io.ByteArrayOutputStream;
    5. import java.io.DataInputStream;
    6. import java.io.DataOutputStream;
    7. import java.io.EOFException;
    8.  
    9. /*
    10.  * 1、用数据输出流将菲波那契级数列的前二十项存放内存中。
    11.  * 2、从内存中读出数列，显示输出，并计算累加和。
    12.  */
    13. public class Test82 {
    14. 	public static void main(String[] args) throws Exception {
    15. 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
    16. 		DataOutputStream dos = new DataOutputStream(baos);
    17. 		for (int i = 0; i < 20; i++) {
    18. 			int num = fei(i);
    19. 			dos.writeInt(num);
    20. 		}
    21. 		byte[] data = baos.toByteArray();
    22. 		DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
    23. 		int sum = 0;
    24. 		while (true) {
    25. 			try {
    26. 				int kk = dis.readInt();
    27. 				sum += kk;
    28. 				System.out.println(kk);
    29. 			} catch (EOFException e) {
    30. 				System.out.println("读取完毕！");
    31. 				break;
    32. 			}
    33. 		}
    34. 		System.out.println("累加和为 " + sum);
    35. 	}
    36.  
    37. 	public static int fei(int n) {
    38. 		if (n < 0)
    39. 			throw new IllegalArgumentException();
    40. 		if (n == 0)
    41. 			return 0;
    42. 		if (n == 1)
    43. 			return 1;
    44. 		return fei(n - 1) + fei(n - 2);
    45. 	}
    46. }

    产生5000个1~9999之间的随机整数，将其存入二进制数据文件a.data中

    1. package com.yan4;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.FileInputStream;
    6. import java.io.FileOutputStream;
    7. import java.util.Random;
    8.  
    9. /*
    10.  * 作业题：
    11.  * 练习：编写一个程序实现以下功能：
    12.  * （1）产生5000个1～9999之间的随机整数，将其存入二进制数据文件a.data中。 
    13.  * （2）从文件中读取所有整数(文件中都是整数，但是个数未知)，并计算其最大值、最小值和平均值并输出结果。
    14.  */
    15. public class Exec02 {
    16. 	public static void main(String[] args) throws Exception {
    17.  
    18. 		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data/a.data"));
    19. 		Random r = new Random();
    20. 		for (int i = 0; i < 5000; i++) {
    21. 			dos.writeInt(r.nextInt(9999));
    22. 		}
    23. 		DataInputStream dis = new DataInputStream(new FileInputStream("data/a.data"));
    24. 		for (int i = 0; i < 5000; i++) {
    25. 			int kk = dis.readInt();
    26. 			System.out.print(kk + "\t");
    27. 		}
    28. 		dis.close();
    29. 	}
    30. }

    打印流

    PrintStream 和 PrintWriter 都属于输出流，分别针对字节和字符
    PrintWriter 和 PrintStream 都提供了重载的 print 和 println 方法用于输出多种类型数据
    print(Object):void
    • 输出引用类型，实际上是调用对象的toString方法转换为String进行输出

    println 表示输出后自动换行
    • PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息
    • PrintWriter和PrintStream有自动的flush功能 textOut.flushBuffer();
    PrintWriter(Writer)
    PrintWriter(Writer out, boolean autoFlush) 自动刷新 ----println 
    1. package com.yan3;
    2.  
    3. import java.io.FileWriter;
    4. import java.io.PrintWriter;
    5.  
    6. /*
    7.  * 打印流 println和print
    8.  * 
    9.  * PrintStream和PrintWriter都属于输出流，分别针对字节和字符
    10.  * 
    11.  * PrintWriter和PrintStream都提供了重载的print和println方法
    12.  * 用于输出多种类型数据
    13.  * 
    14.  * print(Object):void
    15. - 输出引用类型，实际上是调用对象的toString方法转换为String进行输出
    17.   ```java
    18.   public void println(Object x) {
    19.   	String s = String.valueOf(x);  //调用String类中的静态方法将object类型的数据转换为字符串
    20.       synchronized (this) {
    21.             print(s); 
    22.             newLine();  //print('\n')
    23.       }
    24.    }
    25.   //String中的valueOf方法的定义
    26.   public static String valueOf(Object obj) {
    27.   	return (obj == null) ? "null" : obj.toString();  //如果输出对象非空，则调用对象的toString方法
    28.   }
    29.   ```
    31. println表示输出后自动换行
    33. - PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息
    34. - PrintWriter和PrintStream有自动的flush功能`textOut.flushBuffer();`
    37. PrintWriter(Writer)
    38. PrintWriter(Writer out, boolean autoFlush)自动刷新----println
    39.  */
    40. public class Test9 {
    41. 	public static void main(String[] args) throws Exception {
    42. 		// 注意实际上允许直接new PrintWriter(System.out)
    43. 		PrintWriter pw = new PrintWriter(new FileWriter("data/out4.dat"));
    44. 		for (int i = 0; i < 10; i++) {
    45. 			pw.println(i);
    46. //			pw.print(i);
    47. 		}
    48. 		pw.close();
    49. 	}
    50. }
  • 相关阅读:
    MySQL运维5-Mycat配置
    【数据结构C/C++】根据前序中序和中序后续遍历结果生成二叉树
    人工神经网络用什么软件,神经网络能用来做什么
    java-net-php-python-net本科生毕业设计选导师系统演示录像2019计算机毕业设计程序
    RabbitMq 高级特性及整合SpringBoot学习总结
    vue使用elementUI的upload上传文件封装
    图的遍历应用之拯救007，python版本详细解析
    Python文件存读取
    RK3399平台开发系列讲解（I/O篇）Linux最大文件数的限制机制
    kafka日志文件详解及生产常见问题总结
  • 原文地址：https://blog.csdn.net/tiger_root/article/details/126191485