Java基础教程

文章36 |   阅读 18653 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

Java基础系列35-IO流

转x33g5p2x  于2021-12-18 转载在 其他  
字(31.7k)|赞(0)|评价(0)|浏览(496)

一.IO流概述

什么是IO流,其作用为?

  1. I ------ Input --> 输入 --> 读取
  2. O — Output --> 输出 --> 写出

常见应用:

  1. 文件复制
  2. 文件上传
  3. 文件下载

IO流的分类汇总:

  1. 字节流 (支持图片等格式的文件，直接用记事本打开文件是看不懂的乱码
  2. 字节缓冲区流 （字符缓冲输入流 b、c方式 可以读取中文，不会出现乱码）
  3. 转换流 （字符流） = 字节流 + 编码表
  4. 字符流 (字符流数据通过Windows自带的记事本软件打开是可以读懂里面内容的)
  5. 字符缓冲区流
  • 字节流 (支持图片等格式的文件，直接用记事本打开文件是看不懂的乱码)
     a1 InputStream 字节流输入超类
      a1.1 FileInputStream 不建议读取中文，中文一般2-4字节，此方式会从中间截断，导致乱码
      
  1. //指定输入流
  2. //FileInputStream fis = new FileInputStream(new File("fis.txt"));//效果同下行代码
  3. FileInputStream fis = new FileInputStream("fis.txt");
  5. //a.一次读取一个字符
  6.   int by;
  7. //如果fis.read不等于-1说明还有数据，则继续读文件
  8.   while ((by = fis.read()) != -1) {
  9.   	System.out.print((char) by);//打印结果
  10.   }
  12.   //b.一次读取一个字符数组
  13.   byte[] bys = new byte[1024];//每次读取最大bys长度个字节存入数组，长度建议1024或1024的整数倍
  14.   int len;//代表有效个数
  15.   //将数据读取到数组中, 并用len记录读取到的有效字节个数
  16.   //fis.read(bys)=>读取一次bys长度内容写入bys（每次覆盖之前内容），如果剩余文件内容不足以写满bys，（长度1024，剩余1000字节）则bys中最后字节（24字节）保持上一次写入的内容 => 所以每次要截取new String(bys,0,len),避免读到上一次剩余的内容
  17.   while ((len = fis.read(bys)) != -1) {
  18.   	System.out.print(new String(bys, 0, len));//打印结果
  19.   }
  21.   //释放资源
  22.   fis.close();

b1 字节缓冲区流  BufferedInputStream 字符缓冲输入流 b、c方式 可以读取中文，不会出现乱码

  1. //字节流一次读写一个数组的速度比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流
  2.   
  3.   //Q:为什么字节缓冲流的构造方法需要传入一个In/OutputStream
  4.   //A:字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还得需要基本的流对象进行操作。
  5.       
  6.   //指定输入流
  7.   BufferedInputStream bis = new BufferedInputStream(new FileInputStream("name.txt"));
  8.   
  9.   //a.一次读取一个字符(不能读取中文，中文一般2-4字节，一个一个字节读会乱码)
  10.   int by;
  11.   while ((by = bis.read()) != -1) {
  12.       System.out.print((char) by);
  13.   }
  14.   
  15.   //b.一次读取一个字符数组
  16.   byte[] bys = new byte[1024];
  17.   int len;
  18.   while ((len = bis.read(bys)) != -1) {
  19.       System.out.print(new String(bys, 0, len));
  20.   }
  21.   
  22.   //释放资源
  23.   bis.close();

a2 OutPutStream 字节流输出超类
  a2.1 FileOutputStream 不建议读取中文，中文一般2-4字节，此方式会从中间截断，导致乱码

  1. //指定输出流
  2. //FileOutputStream fos = new FileOutputStream(new File("fos.txt"));//效果同下行代码
  3. //FileOutputStream fos = new FileOutputStream("fos.txt" , false);//false表示不追加文件->每次写入覆盖之前的内容
  4. FileOutputStream fos = new FileOutputStream("fos.txt");
  6. FileInputStream fis = new FileInputStream("fis.txt");
  8. //a.一次写入一个字符(不能读取中文，中文一般2-4字节，一个一个字节读会乱码)
  9. int by;
  10. while ((by = fis.read()) != -1) {
  11. 	System.out.print((char) by);//打印结果
  12. }
  14. //b.一次写入一个字符数组
  15. byte[] bytes = new byte[1024];
  16. int len;
  17. while ((len = fis.read(bytes)) != -1) {
  18. 	fos.write(bytes, 0, len);
  19. }
  21. //释放资源
  22. fos.close();
  23. fis.close();

b2 字节缓冲区流  BufferedOutputStream 字节缓冲输出流 可以读取中文，不会出现乱码

  1. //字节流一次读写一个数组的速度比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流
  3. //Q:为什么字节缓冲流的构造方法需要传入一个In/OutputStream
  4. //A:字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还得需要基本的流对象进行操作。
  6. //指定输入流
  7. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
  8. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
  10. //a.一次读取一个字符
  11. int by;
  12. while ((by = bis.read()) != -1) {
  13.     bos.write(by);//写入字符串
  14.     bos.flush();//刷新该流的缓冲，写入文件
  15. }
  17. //b.一次读取一个字符数组
  18. byte[] bytes = new byte[1024];
  19. int len;
  20. while ((len = bis.read(bytes)) != -1) {
  21.     System.out.println(new String(bytes,0,len));
  22.     bos.write(bytes,0,len);//写入字符串
  23.     bos.flush();//刷新该流的缓冲，写入文件
  24. }
  26. //释放资源
  27. bis.close();
  28. bos.close();
  • c 转换流 （字符流） = 字节流 + 编码表
  1. //指定编码为UTF-8的字符输出流
  2. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("source.txt"),"UTF-8");
  4. //指定编码为UTF-8的字符输入流
  5. InputStreamReader isr = new InputStreamReader(new FileInputStream("target.txt"),"UTF-8");
  7. /* 
  8. 常见的编码表:
  9. 		ASCII : 美国标准信息交换码, 用一个字节的7位表示数据
  10. 		ISO-8859-1 : 欧洲码表, 用一个字节的8位表示数据, 兼容ASCII
  11. 		GB2312 : 中文码表的升级版, 融合了更多的中文文字符号, 兼容ASCII
  12. 		UTF-8 : 是一种可变长度的字符编码, 用1-3个字节表示数据, 又称为万国码, 兼容ASCII用在网页上可以
  13. 				统一页面中的中文简体繁体和其他语言的显示.
  14. */
  • d字符流 (字符流数据通过Windows自带的记事本软件打开是可以读懂里面内容的)
      d1 Reader 字符流输入超类
      d1.1 InputStreamReader 用 默认/指定 编码读数据
  1. //指定输入流 目标文件和字符集 ,如果不指定字符集则按照默认编码表 (java7=GBK,java8=UTF-8)
  2. InputStreamReader isr = new InputStreamReader(new FileInputStream(""),"GBK");

d1.1.1 FileReader ↓作为BufferedReader构造器的参数使用↓

  1. //转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化我们的书写，转换流InputStreamReader提供了对应的子类InputStreamReader
  2. /*
  3.   （子类）FileWriter：用来写入字符文件的便捷类
  4.   （父类）OutputStreamWriter: FileWriter + 默认编码表(java7=GBK,java8=UTF-8)
  5.  
  6.   （子类）FileReader：用来读取字符文件的便捷类
  7.   （父类）InputStreamReader: FileReader + 默认编码表(java7=GBK,java8=UTF-8)
  8. */
  10. //封装数据源
  11. FileReader fr = new FileReader("source.txt");
  12. //封装目的地
  13. FileWriter fw = new FileWriter("target.txt");

e1 字符缓冲区流  BufferedReader 最常用

  1. //指定输入流
  2. BufferedReader br = new BufferedReader(new FileReader("source.txt"));
  3. //指定输出流
  4. BufferedWriter bw = new BufferedWriter(new FileWriter("target.txt"));
  6. //a.一次读取一个字符
  7. int ch;
  8. while ((ch = br.read()) != -1) {
  9.     //对应Unicode编码10进制的值 查询工具 => 
  10.     //http://www.mytju.com/classcode/tools/encode_gb2312.asp
  11. 	System.out.println(ch);
  12. }
  14. //b.一次读取多个字符【注意 换行符也算字符】
  15. char[] bytes = new char[1024];//一次取出1024个字符
  16. int len;//代表有效个数
  17. while((len = br.read(bytes)) != -1)
  18. {
  19.     System.out.print(new String(chars, 0, len));//注意是print不是println
  20. }
  22. //c.读取一整行字符串【注意 不包括换行符，需要手动newLine()换行】
  23. //String line = br.readLine();
  24. String line;//代表一整行字符串
  25. //按行读取整篇文章的内容
  26. while((line = br.readLine()) != null)
  27. {
  28.     System.out.println(line);
  29. }
  31. //释放资源
  32. br.close();
  33. bw.close();

d2 Writer 字符流输出超类
   d2.1 PrintWriter
   d2.2 OutputStreamWriter 用 默认/指定 编码写数据

  1. //指定输出流 目标文件和字符集,如果不指定字符集则按照默认编码表 (java7=GBK,java8=UTF-8)
  2. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("target.txt"),"GBK");

d2.2.1 FileWriter ↓作为BufferedWriter构造器的参数使用↓

  1. //转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化我们的书写，转换流OutputStreamWriter提供了对应的子类FileWriter
  2. /*
  3.   （子类）FileWriter：用来写入字符文件的便捷类
  4.   （父类）OutputStreamWriter: FileWriter + 默认编码表(java7=GBK,java8=UTF-8)
  5.  
  6.   （子类）FileReader：用来读取字符文件的便捷类
  7.   （父类）InputStreamReader: FileReader + 默认编码表(java7=GBK,java8=UTF-8)
  8. */
  10. //封装数据源
  11. FileReader fr = new FileReader("source.txt");
  12. //封装目的地
  13. FileWriter fw = new FileWriter("target.txt");

e2 字符缓冲区流 BufferedWriter 最常用

  1. //指定输入流
  2. BufferedReader br = new BufferedReader(new FileReader("br.txt"));
  3. //指定输出流
  4. BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
  6. //a.一次读取一个字符
  7. int ch;
  8. while ((ch = br.read()) != -1) {
  9. 	bw.write(ch);//写入字符串
  10. 	bw.flush();//刷新该流的缓冲，写入文件
  11. }
  13. //b.一次读取多个字符【注意 换行符也算字符】
  14. char[] bytes = new char[1024];//一次取出1024个字符
  15. int len;//代表有效个数
  16. while((len = br.read(bytes)) != -1)
  17. {
  18.     bw.write(new String(bytes, 0 , len));//写入字符串
  19.     bw.newLine();
  20.     bw.flush();//刷新该流的缓冲，写入文件
  21. }
  23. //c.读取一整行字符串【注意 不包括换行符，需要手动newLine()换行】
  24. //String line = br.readLine();
  25. String line;//代表一整行字符串
  26. //按行读取整篇文章的内容
  27. while((line = br.readLine()) != null)
  28. {
  29.     bw.write(line);//写入字符串
  30.     bw.newLine();
  31.     bw.flush();//刷新该流的缓冲，写入文件
  32. }
  34. //释放资源
  35. br.close();
  36. bw.close();

二. 字节流

a.字节流 (支持图片等格式的文件，直接用记事本打开文件是看不懂的乱码)
 InputStream 字节流输入超类
 FileInputStream 不建议读取中文，中文一般2-4字节，此方式会从中间截断，导致乱码
  b. 字节缓冲区流  BufferedInputStream 字符缓冲输入流 b、c方式 可以读取中文，不会出现乱码
 OutPutStream 字节流输出超类
  FileOutputStream 不建议读取中文，中文一般2-4字节，此方式会从中间截断，导致乱码
   b 字节缓冲区流  BufferedOutputStream 字节缓冲输出流 可以读取中文，不会出现乱码

2.1 FOS与FIS

简写说明:

  • FIS = FileInPutStream
  • FOS = FileOutPutStream

字节流写数据:

  • OutputStream:此抽象类是表示输出字节流的所有类的超类
  • FileOutputStream:文件输出流是用于将数据写入 File

字符流读数据:

  • OutputStream:此抽象类是表示输出字节流的所有类的超类
  • FileOutputStream:文件输出流是用于将数据写入 File

构造方法:

  1. //创建一个向具有指定名称的文件中写入数据的输出文件流。
  2. FileOutputStream(String name)

字节流写数据的步骤：

  1. 创建字节输出流对象
  2. 调用写数据的方法 write(int);
  3. 释放资源 close()

代码:

  1. package Java_study;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  6. /**
  7.  * 
  8.  * @author  只是甲
  9.  * @date    2021-07-19
  10.  * @remark  字节流FileOutputStream写出数据
  11.  *
  12.  */
  14. public class io1 {
  15. 	public static void main(String[] args) throws IOException {
  16. 		//创建直接输出流对象  throws FileNotFoundException
  17. 		FileOutputStream fos = new FileOutputStream("a.txt");
  18. 		
  19. 		//throws IOException (包含FileNotFoundException)
  20. 		System.out.println("fos.write");
  21. 		
  22. 		fos.write(65);//A
  23. 		fos.write(66);//B
  24. 		System.out.println("写入结束");
  25. 		//关闭IO流，回收系统资源
  26. 		fos.close();
  27. 	}
  29. }

2.2 FOS写数据的三种方式

方法摘要：

  1. //a.写出数据的三个方法
  2.   //一次写一个字节
  3.   public void write(int b)
  4.   
  5.   //一次写一个字节数组
  6.   public void write(byte[] b)
  7.   
  8.   //一次写一个字节数组的一部分
  9.   public void write(byte[] b,int off,int len)
  10.   
  11.   //b.String类中的方法
  12.   //将字符串转换为字节数组
  13.   byte[] getBytes()

代码:

  1. package Java_study;
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**
  8.  * 
  9.  * @author 只是甲
  10.  * @date   2021-07-19
  11.  * @remark 字节流FileOutputStream写数据的三种方式
  12.  * A.构造方法的三种方式：
  13.  *      1. FileOutputStream(String name)
  14.  *      2. FileOutPutStream(File file)
  15.  *      3. FileOutPutStream(new File(xxx))
  16.  *      4. FileOutputStream(xxx,true) //true=追加数据，默认为false，清空后重新写入数据
  17.  *
  18.  * B.写数据的三种方式： throws IOException
  19.  *      1. FileOutputStream.write(int b)：一次写一个字节
  20.  *      2. FileOutputStream.write(byte[] b)：一次写一个字节数组
  21.  *      3. FileOutputStream.write(byte[] b,inf off,int len)：一次写一个字节数组的一部分
  22.  *
  23.  * 字节流写数据的步骤：
  24.  *      a: 创建字节输出流对象 new FileOutPutStream(String name)
  25.  *      b: 调用写数据的方法
  26.  *      c: 释放资源 fos.close()
  27.  *
  28.  */
  30. public class io2 {
  31. 	public static void main(String[] args) throws IOException{
  32. 		//A1. FileOutputStream构造方式1 FileOutputStream(String name)
  33. 		FileOutputStream fos1 = new FileOutputStream("b.txt");
  34. 		
  35. 		//A2. FileOutputStream构造方式2 FileOutPutStream(File file)
  36. 		File f2 = new File("c.txt");
  37. 		FileOutputStream fos2 = new FileOutputStream(f2);
  38. 		
  39. 		//A3. FileOutPutStream构造方式3 FileOutPutStream(new File(xxx))
  40. 		FileOutputStream fos3 = new FileOutputStream(new File("d.txt"));
  41. 		
  42. 		//B1. 写入数据方式1 FileOutputStream.write(int b)：一次写一个字节
  43.         //throws IOException
  44. 		fos1.write(65);
  45. 		
  46. 		//B2. 写入数据方式2 FileOutputStream.write(byte[] b)：一次写一个字节数组
  47. 		byte[] bys = {65, 66, 67, 68, 69};
  48. 		fos2.write(bys);
  49. 		
  50. 		//B3. 写入数据方式3 FileOutputStream.write(byte[] b,inf off,int len)：一次写一个字节数组的一部分
  51. 		fos3.write("ABCDE".getBytes(), 0, 3);
  52. 		
  53. 		File path = new File("");
  54. 		System.out.println("文件路径:" + path.getAbsolutePath());
  55. 		
  56. 		//释放资源
  57. 		fos1.close();
  58. 		fos2.close();
  59. 		fos3.close();
  60. 	}
  62. }

2.3 FOS如何实现换行和追加写数据

FIS = FileInPutStream

不同的操作系统，针对换行的符号识别是不一样的:

  • windows:\r\n
  • linux:\n
  • mac:\r

如何实现数据的追加写入?

  • 用构造方法带第二个参数是true的情况即可

代码:

  1. package Java_study;
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**
  8.  * 
  9.  * @author 只是甲
  10.  * @date   2021-07-19
  11.  * @remark 字节流FileOutputStream写数据换行、追加
  12.  * 
  13.  */
  15. public class io3 {
  16. 	public static void main(String[] args) throws IOException{
  17. 		//先清空文件
  18. 		FileOutputStream clear = new FileOutputStream("b.txt");
  19. 		clear.write("".getBytes());
  20. 		
  21. 		//如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处(默认为false)
  22. 		FileOutputStream fos = new FileOutputStream("b.txt", true);
  23. 		
  24. 		//玄幻写入三次hello和换行
  25. 		for (int i = 0; i < 3; i++) {
  26. 			fos.write("hello".getBytes());
  27. 			fos.write("\r\n".getBytes());
  28. 		}
  29. 		
  30. 		System.out.println("文件路径为:" + new File("").getAbsolutePath());
  31. 		
  32. 		//释放资源
  33. 		fos.close();
  34. 	}
  36. }

2.4 FOS写数据加入异常处理

FIS = FileInPutStream

try…catch.finally

  1. //格式
  2.   try{
  3.   	可能发生问题的代码
  4.   }catch(){
  5.   	处理异常代码
  6.   }finally{
  7.   	一定会被执行的代码.   // 通常用于释放资源, 做善后的动作
  8.   }

代码:

  1. package Java_study;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  6. /**
  7.  * 
  8.  * @author 只是甲
  9.  * @date   2021-07-19
  10.  * @remark 字节流FileOutputStream写数据加入异常处理
  11.  * 
  12.  */
  14. public class io4 {
  15. 	public static void main(String[] args) {
  16. 		//fos放在外面是为了在finally中可以关闭
  17. 		FileOutputStream fos = null;
  18. 		
  19. 		try {
  20. 			fos = new FileOutputStream("d.txt");
  21. 			fos.write("hello".getBytes());
  22. 		} catch (IOException e) {
  23. 			e.printStackTrace();
  24. 		} finally {
  25. 			if (fos != null) {
  26. 				//释放资源
  27. 				try {
  28. 					fos.close();
  29. 				} catch (IOException e) {
  30. 					System.out.println("fos关闭失败");
  31. 				}
  32. 			}
  33. 		}
  34. 	}
  36. }

2.5 FIS读数据方式1一次读取一个字节

FIS = FileInPutStream

字节流读数据的步骤:

  • A : 创建字节输入流对象
  • B : 调用读数据的方法
  • C : 释放资源

代码:

  1. package Java_study;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  6. /**
  7.  * 
  8.  * @author 只是甲
  9.  * @remark 字节流FileInputStream读数据方式1
  10.  * 
  11.  */
  13. public class io5 {
  14. 	public static void main(String[] args) throws IOException {
  15. 		System.out.println("读取数据方式1: 一次读取一个字节");
  16. 		//创建字节输入流对象
  17. 		FileInputStream fis1 = new FileInputStream("b.txt");//刚才在b.txt写入了3行hello
  18. 		
  19. 		for (int i = 0; i < 20; i++) {
  20. 			System.out.println(fis1.read());
  21. 		}
  22. 		
  23. 		System.out.println("改进为循环方式打印");
  24. 		FileInputStream fis2 = new FileInputStream("b.txt");//刚才在b.txt写入了3行helloWorld
  25. 		int by;
  26. 		//如果fis.read不等于-1说明还有数据,则继续读文件
  27. 		while ((by = fis2.read()) != -1) {
  28. 			System.out.println((char) by);
  29. 		}
  30. 	}
  32. }

测试记录:

  1. 读取数据方式1: 一次读取一个字节
  2. 104
  3. 101
  4. 108
  5. 108
  6. 111
  7. 13
  8. 10
  9. 104
  10. 101
  11. 108
  12. 108
  13. 111
  14. 13
  15. 10
  16. 104
  17. 101
  18. 108
  19. 108
  20. 111
  21. 13
  22. 改进为循环方式打印
  23. h
  24. e
  25. l
  26. l
  27. o
  31. h
  32. e
  33. l
  34. l
  35. o
  39. h
  40. e
  41. l
  42. l
  43. o

2.6 FIS读数据方式2一次读取一个字节数组

方法摘要:

  1. /*从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
  2.   返回值是读入缓冲区的字节总数，也就是实际的读取个数
  3.   如果因为已经到达文件末尾而没有更多的数据，则返回 -1。*/
  4.   public int read(byte[] b):

代码:

  1. package Java_study;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  6. /**
  7.  * 
  8.  * @author 只是甲
  9.  * @remark FileInputStream读数据方式2
  10.  * 
  11.  */
  13. public class io6 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		System.out.println("----读取数据方式2: 一次读取一个直接数组-----");
  16. 		FileInputStream fis1 = new FileInputStream("b.txt");//刚才在b.txt写入了3行hello
  17. 		//标准代码字符缓冲区bys1长度应为1024或1024的整数倍，这里先用8演示读取的原理
  18. 		byte[] bys1 = new byte[8];
  19. 		//第一次读取
  20. 		int len1 = fis1.read(bys1);
  21. 		System.out.println(len1);//8
  22. 		
  23. 		System.out.println("第一次读取: " + new String(bys1));
  24. 		//第二次读取
  25. 		len1 = fis1.read(bys1);
  26. 		System.out.println(len1);//8
  27. 		/*
  28.         第二次读取: ello
  29.         he
  30.         */
  31. 		System.out.println("第二次读取: " + new String(bys1));
  32. 		// 第三次读取
  33. 		len1 = fis1.read(bys1);
  34. 		System.out.println(len1);//5 => 只读取了5个字符，就返回了5
  35. 		
  36. 		/*
  37.         第三次读取: llo
  39.         he
  40.         */
  41.         /* 解析：
  42.           文件内容为
  43.           hello\r\n
  44.           hello\r\n
  45.           hello\r\n
  47.           第一次读取8个字节为 [h] [e] [l] [l] [o] [\r][\n] [h]
  48.           第二次读取8个字节为 [e] [l] [l] [o] [\r][\n] [h] [e]
  49.           第三次读取8个字节为 [l] [l] [o] [\r][\n]
  50.           但数组写入方式是每次覆盖前一次的，所以第二次写入的还保留着
  51.           bys[5] = \r
  52.           bys[6] = h
  53.           bys[7] = e
  54.           所以第三次数组内容为  [l] [l] [o] [\r][\n][\n] [h] [e]
  55.           所以才会打印出以上内容
  56.          */
  57. 		System.out.println("第三次读取: " + new String(bys1));
  58. 		//第四次读取
  59. 		len1 = fis1.read(bys1);
  60. 		System.out.println(len1);//-1 => 表示没有数据了
  61. 		
  62. 		
  63. 		
  64. 		System.out.println("-----改进为循环读取文件-----");
  65. 		//创建字节流输入对象
  66. 		FileInputStream fis2 = new FileInputStream("b.txt");
  67. 		byte[] bys2 = new byte[1024];//1024或者1024的整数倍
  68. 		
  69. 		int len2;
  70. 		//将数据读取到数组中, 并用len记录读取到的有效字节个数
  71. 		while ((len2 = fis2.read(bys2)) != -1 ) {
  72. 			//只读取到len的长度，否则会出现
  73. 			System.out.print(new String(bys2, 0, len2));
  74. 		}
  75. 		System.out.println("\r\n读取结束");
  76. 		fis2.close();
  78. 	}
  80. }

测试记录:

  1. ----读取数据方式2: 一次读取一个直接数组-----
  2. 8
  3. 第一次读取: hello
  4. h
  5. 8
  6. 第二次读取: ello
  7. he
  8. 5
  9. 第三次读取: llo
  11. he
  12. -1
  13. -----改进为循环读取文件-----
  14. hello
  15. hello
  16. hello
  18. 读取结束

2.7 字节流练习之复制文本文件

需求：

  • 拷贝文本文件

分析:

  • 第一步: 创建输入输出流对象关联数据源和数据目的
  • 第二步: 定义字节数组,为了提高效率
  • 第三步: 将数据通过while循环不断读取到字节数组中
  • 第四步: 将数据从字节数组中取出并写出
  • 第五步: 释放资源

待拷贝的文本文件（d:\窗里窗外.txt）：

  1. 《窗里窗外》是林青霞近5年所写的46篇散文的结集，虽是旧作，但该书记录她19岁以《窗外》成名后多方面的人生经历，字字真实深刻。《窗里窗外》共分为六个章节：“戏”里说的是她的出道故事、拍戏的甘苦、对于作品的内心话；“亲”谈她的家人亲情；“友”则书写她与挚友的交往，细谈她与三毛、黄霑、张国荣、龙应台、琼瑶、徐克等人的往来互动；“趣”是她的生活记趣，有旅行见闻，也有她与影迷的邂逅；“缘”则书写她一生难忘的相遇，像是和记者的友谊，和季羡林的会面之缘；“悟”里记录了她对人生的体悟和感动，以及她向圣严法师求道的故事。此外，书中还完整收录了林青霞一些未公开的照片。
  2. 第1节：人生小语(1)…

代码:

  1. package Java_study;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /**
  9.  * 
  10.  * @author 只是甲
  11.  * @remark 直接流复习之复制文本文件
  12.  * 
  13.  */
  15. public class io7 {
  16. 	public static void main(String[] args) throws IOException{
  17. 		//封装数据源
  18. 		FileInputStream fis = new FileInputStream("d:" + File.separator + "窗里窗外.txt");
  19. 		//封装目的地(目标文件，追加true清空重写false)
  20. 		FileOutputStream fos = new FileOutputStream("d:" + File.separator + "杜兰特.txt", false);
  21. 		
  22. 		//a.一次写入一个字符
  23. 		int by;
  24. 		while ((by = fis.read()) != -1 ) {
  25. 			fos.write(by);
  26. 		}
  27. 		
  28. 		//b.一次写入一个字符数组
  29. 		byte[] bys = new byte[1024];
  30. 		int len;
  31. 		while ((len = fis.read(bys)) != -1 ) {
  32. 			fos.write(bys, 0, len);
  33. 		}
  34. 		
  35. 		//释放资源
  36. 		fos.close();
  37. 		fis.close();
  38. 	}
  40. }

2.8 字节流练习之复制图片

思路：

  • 同理2.7案例

代码:

  1. package Java_study;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /**
  9.  * 
  10.  * @author  只是甲
  11.  * @date    2021-07-20
  12.  * @remark  直接流复习之复制文本文件
  13.  * 
  14.  */
  16. public class io8 {
  17. 	public static void main(String[] args) throws IOException{
  18. 		//封装数据源
  19. 		FileInputStream fis1 = new FileInputStream("d:" + File.separator + "字节流.bmp");
  20. 		FileInputStream fis2 = new FileInputStream("d:" + File.separator + "字节流.bmp");
  21. 	    //封装目的地
  22. 		FileOutputStream fos1 = new FileOutputStream("d:" + File.separator + "copy1.bmp");
  23. 		FileOutputStream fos2 = new FileOutputStream("d:" + File.separator + "copy2.bmp");
  24. 		
  25. 		//读取数据
  26. 		int by;
  27. 		//方式1: 一次读取一个直接
  28. 		//如果fis.read不等于-1说明还有数据，则继续读文件
  29. 		while ((by = fis1.read()) != -1 ) {
  30. 			fos1.write(by);
  31. 		}
  32. 		
  33. 		//方式2: 一次读取一个字节数组
  34. 		byte[] bys = new byte[1024];
  35. 		int len;
  36. 		while ((len = fis2.read(bys)) != -1) {
  37. 			fos2.write(bys, 0, len);
  38. 		}
  39. 		
  40. 		//释放资源
  41. 		fis1.close();
  42. 		fis2.close();
  43. 		fos1.close();
  44. 		fos2.close();
  45. 	}
  47. }

三. 字节缓冲区流

a.字节流 (支持图片等格式的文件，直接用记事本打开文件是看不懂的乱码)

  • InputStream 字节流输入超类
  • FileInputStream 不建议读取中文，中文一般2-4字节，此方式会从中间截断，导致乱码
      b. 字节缓冲区流  BufferedInputStream 字符缓冲输入流 b、c方式 可以读取中文，不会出现乱码
  • OutPutStream 字节流输出超类
      FileOutputStream 不建议读取中文，中文一般2-4字节，此方式会从中间截断，导致乱码
        b 字节缓冲区流  BufferedOutputStream 字节缓冲输出流 可以读取中文，不会出现乱码

3.1 概述

作用:

  • 字节流一次读写一个数组的速度比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果
  • java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流

字节缓冲流：

  • BufferedOutputStream : 字节缓冲输出流
  • BufferedInputStream : 字节缓冲输入流

为什么字节缓冲流的构造方法需要传入一个OutputStream:

  • 字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还得需要基本的流对象进行操作

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-20
  9.  * @remark  字节缓冲流
  10.  * 
  11.  */
  13. public class io9 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		//指定字符缓冲输出流
  17.         // FileOutputStream fos = new FileOutputStream("a.txt");
  18.         // BufferedOutputStream bos = new BufferedOutputStream(fos);
  19.         // 上面的两句等价于下面的这一句
  20. 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
  21. 		
  22. 		byte[] bytes = "hello".getBytes();
  23. 		bos.write(bytes);
  24. 		bos.close();
  25. 		
  26. 		//指定字符缓冲输入流
  27. 		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
  28. 		//方式1：  一次读取一个字节
  29. 		int by;
  30. 		while ((by = bis.read()) != -1) {
  31. 			System.out.println((char) (by));
  32. 		}
  33. 		
  34. 		//方式2: 一次读取一个直接数组
  35. 		byte[] bys = new byte[1024];
  36. 		int len;
  37. 		while ((len = bis.read(bys)) != -1) {
  38. 			System.out.println(new String(bys, 0, len));
  39. 		}
  40. 		
  41. 		//释放资源
  42. 		bos.close();
  43. 		bis.close();
  44. 	}
  45. }

3.2 四种方式复制图片效率测试

方法摘要：

  1. //返回以毫秒为单位的当前时间。
  2. public static long currentTimeMillis()

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * @author GroupiesM
  7.  * @date 2021/04/27
  8.  * @introduction 字节流&字节缓冲区流四种方式复制AVI并测试效率 
  9.  *
  10.  * 源文件: d:\\复制视频.avi
  11.  * 大小: 34904KB
  12.  *
  13.  * method1: 基本字节流，一次读取一个字节    => method1.avi => 198001毫秒
  14.  * method2: 基本字节流，一次读写一个字节数组 => method2.avi => 278毫秒
  15.  * method3: 缓冲字节流，一次读取一个字节    => method3.avi => 384毫秒
  16.  * method4: 缓冲字节流，一次读写一个字节数组 => method4.avi => 190毫秒
  17.  *
  18.  * 结论: method4 > method2 > method3 > method1
  19.  */
  20. public class io10 {
  21.     public static void main(String[] args) throws IOException {
  22.         //记录method1时间
  23.         long start1 = System.currentTimeMillis();
  24.         method1();//method1共耗时198001毫秒
  25.         long end1 = System.currentTimeMillis();
  26.         System.out.println("method1共耗时" + (end1 - start1) + "毫秒");
  28.         //记录method2时间
  29.         long start2 = System.currentTimeMillis();
  30.         method2();//method2共耗时278毫秒
  31.         long end2 = System.currentTimeMillis();
  32.         System.out.println("method2共耗时" + (end2 - start2) + "毫秒");
  34.         //记录method3时间
  35.         long start3 = System.currentTimeMillis();
  36.         method3();//method3共耗时384毫秒
  37.         long end3 = System.currentTimeMillis();
  38.         System.out.println("method3共耗时" + (end3 - start3) + "毫秒");
  40.         //记录method4时间
  41.         long start4 = System.currentTimeMillis();
  42.         method4();//method4共耗时190毫秒
  43.         long end4 = System.currentTimeMillis();
  44.         System.out.println("method4共耗时" + (end4 - start4) + "毫秒");
  45.     }
  47.     //method1: 基本字节流，一次读取一个字节    => method1.avi
  48.     private static void method1() throws IOException {
  49.         //封装数据源
  50.         FileInputStream fis = new FileInputStream("d:\\复制视频.avi");
  51.         //封装目的地
  52.         FileOutputStream fos = new FileOutputStream("d:\\method1.avi");
  54.         int by;
  55.         while ((by = fis.read()) != -1) {
  56.             fos.write(by);
  57.         }
  58.         //释放资源
  59.         fis.close();
  60.         fos.close();
  61.     }
  63.     //method2: 基本字节流，一次读写一个字节数组 => method2.avi
  64.     private static void method2() throws IOException {
  65.         //封装数据源
  66.         FileInputStream fis = new FileInputStream("d:\\复制视频.avi");
  67.         //封装目的地
  68.         FileOutputStream fos = new FileOutputStream("d:\\method2.avi");
  70.         byte[] bys = new byte[1024];
  71.         int len;
  72.         while ((len = fis.read(bys)) != -1) {
  73.             fos.write(bys, 0, len);
  74.         }
  75.         //释放资源
  76.         fis.close();
  77.         fos.close();
  78.     }
  80.     //method3: 缓冲字节流，一次读取一个字节    => method3.avi
  81.     private static void method3() throws IOException {
  82.         //封装数据源
  83.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制视频.avi"));
  84.         //封装目的地
  85.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\method3.avi"));
  87.         int by;
  88.         while ((by = bis.read()) != -1) {
  89.             bos.write(by);
  90.         }
  91.         //释放资源
  92.         bis.close();
  93.         bos.close();
  94.     }
  96.     //method4: 缓冲字节流，一次读写一个字节数组 => method4.avi
  97.     private static void method4() throws IOException {
  98.         //封装数据源
  99.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制视频.avi"));
  100.         //封装目的地
  101.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\method4.avi"));
  103.         byte[] bys = new byte[1024];
  104.         int len;
  105.         while ((len = bis.read(bys)) != -1) {
  106.             bos.write(bys, 0, len);
  107.         }
  108.         //释放资源
  109.         bis.close();
  110.         bos.close();
  111.     }
  112. }

四. 转换流

c. 转换流 （字符流） = 字节流 + 编码表

转换流出现的原因:

  • 由于字节流操作中文不是特别方便，所以，java就提供了转换流
  • 转换流 = 字节流 + 编码表

字节流读数据可能出现问题:

  • 字节流一次读取一个字节的方式读取带有汉字的文件是有问题的，因为你读取到一个字节后就转为字符在控制台输出了，而汉字是由2个字节组成的，所以这里会出问题。
  • 文件复制的时候，字节流读取一个字节，写入一个字节，这个没有出现问题，是因为最终底层会根据字节做拼接，得到汉字。
  • 汉字存储的规则
      左边的字节数据肯定是负数，右边的字节数据可能是负数，也可能是正数，大部分情况下是负数。

代码:

  1. package Java_study;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.util.Arrays;
  7. /**
  8.  * @author 只是甲
  9.  * @date   2021-07-20
  10.  * @remark 转换流出现的原因
  11.  *
  12.  */
  14. public class io11 {
  15. 	public static void main(String[] args) throws IOException{
  16. 		//基本字节流一次读取一个字节
  17. 		FileInputStream fis = new FileInputStream("a.txt");
  18. 		
  19. 		int by;
  20. 		while ((by = fis.read()) != -1 ) {
  21. 			System.out.print((char) by);
  22. 		}
  23. 		//释放资源,刷新缓冲区
  24. 		fis.close();
  25. 		
  26. 		System.out.println("");
  27. 		String s = "你";
  28. 		byte[] bys = s.getBytes("GBK");
  29. 		/*常见的编码表测试 中文"你"转换为字节数组
  30.         UTF-8          => [-28, -67, -96]  => JDK8中不指定编码则默认为 UTF-8
  31.         GBK/GB2312     => [-60, -29]       => JDK7中不指定编码则默认为 GBK/GB2312
  32.         ISO-8859-1     => [63]
  33.         ASCII          => [63]
  34.         UNICODE/UTF-16 => [-2, -1, 79, 96] => UNICODE 默认使用的是UTF-16的实现方式
  35.      */
  36. 		
  37. 		System.out.println(Arrays.toString(bys));
  38. 	}
  40. }

测试记录：

  1. hi
  2. ????
  3. [-60, -29]

4.1 什么是编码表

编码表

  • 由字符及其对应的数据组成的一张表
  1. ASCII
  2. 	‘a’	97
  3. 	‘A’	65
  4. 	‘0’	48

常见的编码表:

  • ASCII : 美国标准信息交换码, 用一个字节的7位表示数据；(ASCII 0-126)
  • ISO-8859-1 : 欧洲码表, 用一个字节的8位表示数据, 兼容ASCII；
  • GB2312/GBK : 中文码表的升级版, 融合了更多的中文文字符号, 兼容ASCII；
  • UTF-8 : 使用一到四个字节来编码一个码点。, 兼容ASCII；用在网页上可以统一页面中的中文简体繁体和其他语言的显示；
  • UNICODE : 为世界上所有字符都分配了一个唯一的数字编号，又称万国码；有多种实现方案（UTF-32 、UTF-16 、UTF-8）。

乱码问题:

  • 针对同一个数据, 采用的编码和解码不一致导致

代码:

  1. package Java_study;
  3. /**
  4.  * 
  5.  * @author  只是甲
  6.  * @date    2021-07-21
  7.  * @remark  遍历编码表_int转char
  8.  *
  9.  */
  11. public class io12 {
  12. 	public static void main(String[] args) {
  13. 		int count = 0;
  14. 		for (int i = 8; i < 127; i++) {
  15. 			//每打印5个就换行一次
  16. 			if (count == 5) {
  17. 				System.out.println("");
  18. 				count = 0;
  19. 			}
  20. 			//13换行一次，否则CR归位键会回到行最左侧位置，导致控制台打印的10-12被吞掉
  21. 			if (i == 13) {
  22. 				System.out.println("");
  23. 			}
  24. 			char ch = (char) i;
  25. 			System.out.print("[" + ch + " = " + i + "]\t");
  26. 			count++;
  27. 		}
  28. 	}
  30. }

测试记录:

  1. [ = 8]	[	 = 9]	[
  2.  = 10]	[ = 11]	[ = 12]	
  4. [
  5.  = 13]	[ = 14]	[ = 15]	[ = 16]	[ = 17]	
  6. [ = 18]	[ = 19]	[ = 20]	[ = 21]	[ = 22]	
  7. [ = 23]	[ = 24]	[ = 25]	[ = 26]	[ = 27]	
  8. [ = 28]	[ = 29]	[ = 30]	[ = 31]	[  = 32]	
  9. [! = 33]	[" = 34]	[# = 35]	[$ = 36]	[% = 37]	
  10. [& = 38]	[' = 39]	[( = 40]	[) = 41]	[* = 42]	
  11. [+ = 43]	[, = 44]	[- = 45]	[. = 46]	[/ = 47]	
  12. [0 = 48]	[1 = 49]	[2 = 50]	[3 = 51]	[4 = 52]	
  13. [5 = 53]	[6 = 54]	[7 = 55]	[8 = 56]	[9 = 57]	
  14. [: = 58]	[; = 59]	[< = 60]	[= = 61]	[> = 62]	
  15. [? = 63]	[@ = 64]	[A = 65]	[B = 66]	[C = 67]	
  16. [D = 68]	[E = 69]	[F = 70]	[G = 71]	[H = 72]	
  17. [I = 73]	[J = 74]	[K = 75]	[L = 76]	[M = 77]	
  18. [N = 78]	[O = 79]	[P = 80]	[Q = 81]	[R = 82]	
  19. [S = 83]	[T = 84]	[U = 85]	[V = 86]	[W = 87]	
  20. [X = 88]	[Y = 89]	[Z = 90]	[[ = 91]	[\ = 92]	
  21. [] = 93]	[^ = 94]	[_ = 95]	[` = 96]	[a = 97]	
  22. [b = 98]	[c = 99]	[d = 100]	[e = 101]	[f = 102]	
  23. [g = 103]	[h = 104]	[i = 105]	[j = 106]	[k = 107]	
  24. [l = 108]	[m = 109]	[n = 110]	[o = 111]	[p = 112]	
  25. [q = 113]	[r = 114]	[s = 115]	[t = 116]	[u = 117]	
  26. [v = 118]	[w = 119]	[x = 120]	[y = 121]	[z = 122]	
  27. [{ = 123]	[| = 124]	[} = 125]	[~ = 126]

4.2 String类的编解码

方法摘要:
编码 : 把看得懂的变成看不懂的

  1. //使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 
  2. public byte[] getBytes(String charsetName) throws UnsupportedEncodingException

解码 : 把看不懂的变成看得懂的

  1. //通过使用指定的 charset解码指定的 byte 数组，构造一个新的 String。
  2. public String(byte[] bytes, String charsetName)

重点强调: 编码和解码的方式需要一致

常见的编码表测试 中文"你"转换为字节数组
UTF-8 => [-28, -67, -96] => JDK8中不指定编码则默认为 UTF-8
GBK/GB2312 => [-60, -29] => JDK7中不指定编码则默认为 GBK/GB2312
ISO-8859-1 => [63]
ASCII => [63]
UNICODE/UTF-16 => [-2, -1, 79, 96] => UNICODE 默认使用的是UTF-16的实现方式

代码:

  1. package Java_study;
  3. import java.io.UnsupportedEncodingException;
  4. import java.util.Arrays;
  6. /**
  7.  * 
  8.  * @author  只是甲
  9.  * @date    2021-07-21
  10.  * @remark  String 类的编解码
  11.  *
  12.  */
  14. public class io13 {
  15. 	public static void main(String[] args) throws UnsupportedEncodingException {
  16. 		//定义一个字符串
  17. 		String s = "你好";
  18. 		
  19. 		//a.编码 getBytes => throws UnsupportedEncodingException 不支持的编码异常
  20. 		byte[] encodeGBK = s.getBytes();
  21. 		System.out.println(Arrays.toString(encodeGBK));//[-60, -29, -70, -61]
  22. 		
  23. 		byte[] encodeUTF = s.getBytes("UTF-8");
  24. 		System.out.println(Arrays.toString(encodeUTF));//[-28, -67, -96, -27, -91, -67]
  25. 		
  26. 		//b.解码
  27. 		byte[] bytesGBK = {-60, -29, -70, -61};
  28. 		String decodeGBK = new String(bytesGBK);
  29. 		//Java8默认编解码字符集为UTF8 用UTF8解码 GBK编码的字节码文件就会出现乱码
  30. 		System.out.println(decodeGBK);
  31. 		String decodeGBKAgain = new String(bytesGBK, "GBK");
  32. 		//指定用GBK解码
  33. 		System.out.println(decodeGBKAgain);//你好
  34. 		
  35. 		byte[] bytesUTF = {-28, -67, -96, -27, -91, -67};
  36. 		//不指定解码字符集，Java8环境默认使用UTF8字符集进行编解码，刚好和字节数组匹配
  37. 		String decodeUTF = new String(bytesUTF);
  38. 		System.out.println(decodeUTF);//你好
  39. 	}
  41. }

测试记录:

  1. [-60, -29, -70, -61]
  2. [-28, -67, -96, -27, -91, -67]
  3. 你好
  4. 你好
  5. 浣犲ソ

4.3 字符流Stream的编解码(写入文件)

OutputStreamWriter 字符输出流

  1. //根据【默认编码】把字节流的数据转换为字符流
  2.  public OutputStreamWriter(OutputStream out)
  4.  //根据【指定编码】把字节流数据转换为字符流
  5.  public OutputStreamWriter(OutputStream out,String charsetName)

InputStreamReader 字符输入流

  1. //用【默认编码】读数据 
  2.  public InputStreamReader(InputStream in)
  4.  //用【指定编码】读数据
  5.  public InputStreamReader(InputStream in,String charsetName)

IDEA设置文件编码

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  String 类的编解码
  10.  *
  11.  */
  13. public class io14 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		//指定输出流 目标文件和字符集
  16. 		OutputStreamWriter oswGBK = new OutputStreamWriter(new FileOutputStream("osw.txt"), "GBK");
  17. 		//指定输入流 目标文件和字符集
  18. 		InputStreamReader isrGBK = new InputStreamReader(new FileInputStream("osw.txt"), "GBK");
  19. 		InputStreamReader isrUTF = new InputStreamReader(new FileInputStream("osw.txt"), "utf-8");
  20. 		
  21. 		//调用写数据的方法
  22. 		oswGBK.write("你好");
  23. 		oswGBK.flush();//刷新缓冲流（执行一次写入）
  24. 		
  25. 		//用GBK解码GBK文本
  26. 		int byGBK;
  27. 		while ((byGBK = isrGBK.read()) != -1) {
  28. 			System.out.print((char) byGBK);//你好
  29. 		}
  30. 		
  31. 		System.out.println("");
  32. 		
  33. 		//用UTF-解码GBK文本
  34. 		int byUTF;
  35. 		while ((byUTF = isrUTF.read()) != -1) {
  36. 			System.out.print((char) byUTF);//乱码
  37. 		}
  38. 		
  39. 		//释放资源
  40. 		oswGBK.close();
  41. 		isrGBK.close();
  42. 		isrUTF.close();
  43. 	}
  45. }

测试记录:

  1. 你好
  2. ???

五. 字符流

5.1 复制Java文件

需求:
把项目目录下的io1.java内容复制到项目目录下的Copy.java中

三种方式:

  • InputStreamReader & OutputStreamWriter (字符流方式 见5.1) 379毫秒
  • FileReader & FileWriter (字符流方式 见5.1) 297毫秒
  • BufferedReader & BufferedWriter (字符缓冲区流方式 见6.2) 533毫秒

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  字符流 复制Java文件
  10.  *
  11.  */
  13. public class io15 {
  14. 	public static void main(String[] args) throws IOException {
  15. 		long start1 = System.currentTimeMillis();
  16. 		for (int i = 0; i <  1000; i++) {
  17. 			method1("io1.java", "Copy.java");//method1共耗时2153毫秒
  18. 		}
  19. 		long end1 = System.currentTimeMillis();
  20. 		System.out.println("method1共耗时"+ (end1 - start1) + "毫秒");
  21. 		
  22. 		long start2 = System.currentTimeMillis();
  23. 		for (int i = 0; i < 1000; i++) {
  24. 			method1("io1.java", "Copy.java");
  25. 		}
  26. 		long end2 = System.currentTimeMillis();
  27. 		System.out.println("method1共耗时"+ (end2 - start2) + "毫秒");
  28. 	}
  29. 	
  30. 	public static void method1(String source, String target) throws IOException {
  31. 		//封装数据源
  32. 		InputStreamReader isr = new InputStreamReader(new FileInputStream(source));
  33. 		//封装目的地
  34. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(target));
  35. 		
  36. 		char[] chArr = new char[1024];
  37. 		int len;
  38. 		while ((len = isr.read(chArr)) != -1) {
  39. 			osw.write(chArr, 0, len);
  40. 		}
  41. 		
  42. 		//释放资源
  43. 		osw.close();
  44. 		isr.close();
  45. 	}
  46. 	
  47. 	public static void method2(String source, String target) throws IOException{
  48. 		//封装数据源
  49. 		FileReader fr = new FileReader(source);
  50. 		//封装目的地
  51. 		FileWriter fw = new FileWriter(target);
  52. 		
  53. 		char[] chArr = new char[1024];
  54. 		int len;
  55. 		while ((len = fr.read(chArr)) != -1) {
  56. 			fw.write(chArr,0,len);
  57. 		}
  58. 		
  59. 		//释放资源
  60. 		fw.close();
  61. 		fr.close();
  62. 	}
  64. }

测试记录:

  1. method1共耗时379毫秒
  2. method1共耗时297毫秒

5.2 OutputStreamWriter写数据的6种方式

方法摘要：

  1. /* @introduction 写一个字符
  2.  * @param c 要写入的字符
  3.  */
  4. public void write(char c)
  5.     
  6. /* @introduction 写一个字符
  7.  * @param c 要写入的字符对应码表中int值
  8.  */
  9. public void write(int c)
  11. /* @introduction 写一个字符数组
  12.  * @param cbuf 要写入的字符数组
  13.  */
  14. public void write(char[] cbuf)
  16. /* @introduction 写一个字符数组的一部分
  17.  * @param cbuf 要写入的字符数组
  18.  * @param off 起始索引
  19.  * @param len 从起始索引起，写入字符数组长度
  20.  */    
  21. public void write(char[] cbuf,int off,int len)
  22.     
  23. /* @introduction 写一个字符串
  24.  * @param str 要写入的字符串
  25.  */    
  26. public void write(String str)
  27.     
  28. /* @introduction 写一个字符串的一部分
  29.  * @param str 要写入的字符串
  30.  * @param off 起始索引
  31.  * @param len 从起始索引起，写入字符串长度
  32.  */    
  33. public void write(String str,int off,int len)

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  OutputStreamWriter写数据的6种方式
  10.  *
  11.  */
  13. public class io16 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		//创建字符输出流对象 (同时创建文件)
  16. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("target.txt"));
  17. 		
  18. 		//a. public void write(char c); 写一个字符
  19. 		methodA(osw);//写入一个字符a
  20. 		osw.write('\r');//换行
  21. 		
  22. 		//b. public void write(int c); 写一个字符
  23.         methodB(osw);//写入一个字符b
  24.         osw.write('\r');//换行
  26.         //c. public void write(char[] cbuf); 写一个字符数组
  27.         methodC(osw);//写入abcde
  28.         osw.write('\r');//换行
  30.         //d. public void write(char[] cbuf,int off,int len); 写一个字符数组的一部分
  31.         methodD(osw);//写入c
  32.         osw.write('\r');//换行
  34.         //e. public void write(String str); 写一个字符串
  35.         methodE(osw);//写入hello
  36.         osw.write('\r');//换行
  38.         //f. public void write(String str,int off,int len); 写一个字符串的一部分
  39.         methodF(osw);//写入lo
  40.         osw.write('\r');//换行
  42.         //释放资源
  43.         osw.close();//关闭此流，关闭前将缓冲区(内存)字符刷新(flush=>写入硬盘)
  44.         
  45.         
  46. 	}
  47. 	
  48. 	public static void methodA(OutputStreamWriter osw) throws IOException {
  49. 		osw.write('a');
  50. 	}
  51. 	
  52. 	public static void methodB(OutputStreamWriter osw) throws IOException {
  53. 		osw.write(98);
  54. 	}
  55. 	
  56. 	public static void methodC(OutputStreamWriter osw) throws IOException {
  57. 		char[] chs = {'a', 'b', 'c', 'd', 'e'};
  58. 		osw.write(chs);//写入 abcde
  59. 	}
  60. 	
  61. 	
  62. 	public static void methodD(OutputStreamWriter osw) throws IOException {
  63. 		char[] chs = {'a', 'b', 'c', 'd', 'e' };
  64. 		 osw.write(chs, 2, 1);//写入bcd
  65. 	}
  66. 	
  67. 	public static void methodE(OutputStreamWriter osw) throws IOException {
  68.         String s = "hello";
  69.         //e. public void write(String str); 写一个字符串
  70.         osw.write(s);//写入hello
  71.         //void flush():刷新该流的缓冲
  72.         //osw.flush();
  73.     }
  74. 	
  75. 	public static void methodF(OutputStreamWriter osw) throws IOException {
  76.         String s = "hello";
  77.         //f. public void write(String str,int off,int len); 写一个字符串的一部分
  78.         osw.write(s, 3, 2);
  79.         //void flush():刷新该流的缓冲
  80.         //osw.flush();
  81.     }
  82. 	
  84. }

5.3 InputStreamReader读数据的2种方式

方法摘要

  1. //一次读取一个字符    
  2. public int read()
  4. //一次读取一个字符数组
  5. public int read(char[] cbuf)

代码:

  1. package Java_study;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  7. /**
  8.  * 
  9.  * @author  只是甲
  10.  * @date    2021-07-21
  11.  * @remark  InputStreamReader读数据的2种方式
  12.  *
  13.  */
  15. public class io17 {
  16. 	public static void main(String[] args) throws IOException{
  17. 		//创建字符流输入对象
  18. 		InputStreamReader isrA = new InputStreamReader(new FileInputStream("a.txt"));
  19. 		InputStreamReader isrB = new InputStreamReader(new FileInputStream("a.txt"));
  20. 		//a. public int read(); 一次读取一个字符
  21. 		methodA(isrA);
  22. 		System.out.println("\r\n==========================");
  23. 		//b. public int read(char[] cbuf); 一次读取一个字符数组
  24. 		methodB(isrB);
  25. 		
  26. 		//释放资源
  27. 		isrA.close();
  28. 		isrB.close();
  29. 	}
  30. 	
  31. 	
  32. 	public static void methodA(InputStreamReader isr) throws IOException{
  33. 		int ch;
  34. 		while ((ch = isr.read()) != -1) {
  35. 			System.out.print((char) ch);
  36. 		}
  37. 	}
  38. 	
  39. 	public static void methodB(InputStreamReader isr) throws IOException{
  40. 		char[] chs = new char[1024];
  41. 		int len;
  42. 		while ((len = isr.read(chs)) != -1) {
  43. 			System.out.println(new String(chs, 0, len));
  44. 		}
  45. 	}
  47. }

六. 字符缓冲区流

6.1 概述

BufferedWriter

  • 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
  • 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
  • 构造方法
  1. BufferedWriter(Writer out)

BufferedReader

  • 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
  • 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
  • 构造方法
  1. BufferedReader(Reader in)

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  字符缓冲区流概述
  10.  *
  11.  */
  13. public class io18 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		//创建字符缓冲输出流对象
  16. 		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
  17. 		//调用写数据的方法
  18. 		bw.write("hello");
  19. 		//释放资源
  20. 		bw.close();
  21. 		
  22. 		//创建字符缓冲输入流对象
  23. 		BufferedReader br1 = new BufferedReader(new FileReader("io1.java"));
  24. 		BufferedReader br2 = new BufferedReader(new FileReader("io1.java"));
  25. 		
  26. 		//方式1：一次读取一个字符
  27. 		method1(br1);
  28. 		//方式2：一次读取一个字符数组
  29. 		method2(br2);
  30. 		
  31. 		//释放资源
  32. 		br1.close();
  33. 		br2.close();
  34.    }
  35. 	
  36. 	public static void method1(BufferedReader br) throws IOException{
  37. 		int ch;
  38. 		while((ch=br.read()) != -1) {
  39. 			System.out.print((char)ch);
  40. 		}
  41. 	}
  42. 	
  43. 	public static void method2(BufferedReader br) throws IOException{
  44. 		char[] chs = new char[1024];
  45. 		int len;
  46. 		while ((len = br.read(chs)) != -1) {
  47. 			System.out.print(new String(chs, 0, len));
  48. 		}
  49. 	}
  51. }

6.2 复制文本文件

需求:

  • 把项目目录下的a.txt内容复制到项目目录下的b.txt中
  • 数据源
     a.txt—读数据—字符流—InputStreamReader—FileReader—BufferedReader
  • 目的地
     b.txt—写数据—字符流—OutputStreamWriter—FileWriter—BufferedWriter

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  字符缓冲区流 复制文本文件
  10.  *
  11.  */
  13. public class Io19 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		//封装数据源
  16. 		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
  17. 		//封装目的地
  18. 		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
  19. 		
  20. 		//读写数据
  21. 		char[] chs = new char[1024];
  22. 		int len;
  23. 		while ((len = br.read(chs)) != -1 ) bw.write(chs, 0, len);
  24. 		
  25. 		//释放资源
  26. 		bw.close();
  27. 		br.close();
  28. 	}
  30. }

6.3 复制Java文件

需求:
把项目目录下的io1.java内容复制到项目目录下的Copy.java中

三种方式:

  • InputStreamReader & OutputStreamWriter (字符流方式 见5.1) 379毫秒
  • FileReader & FileWriter (字符流方式 见5.1) 297毫秒
  • BufferedReader & BufferedWriter (字符缓冲区流方式 见6.2) 533毫秒

代码：

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  字符缓冲区流 字符缓冲区流复制Java文件
  10.  *
  11.  */
  13. public class Io20 {
  14. 	public static void main(String[] args) throws IOException {
  15. 		long start3 = System.currentTimeMillis();
  16. 		for (int i = 0; i < 1000; i++) {
  17. 			method3("io1.java", "Copy.java");
  18. 		}
  19. 		long end3 = System.currentTimeMillis();
  20. 		System.out.println("method3共耗时"+ (end3 - start3) + "毫秒");
  21. 	}
  22. 	
  23. 	public static void method3(String source,String target) throws IOException {
  24. 		//封装数据源
  25. 		BufferedReader br = new BufferedReader(new FileReader(source));
  26. 		//封装目的地
  27. 		BufferedWriter bw = new BufferedWriter(new FileWriter(target));
  28. 		//读写数据
  29. 		String line;
  30. 		while ((line = br.readLine()) != null) {
  31. 			bw.write(line);
  32. 			bw.newLine();
  33. 			bw.flush();
  34. 		}
  35. 		
  36. 		//释放资源
  37. 		bw.close();
  38. 	}
  40. }

6.4 字符缓冲区流的特殊功能

BufferedWriter

  1. //写入一个行分隔符,这个行分隔符是由系统决定的
  2. void newLine()

BufferedReader

  1. //包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
  2. String readLine()

代码:

  1. package Java_study;
  3. import java.io.*;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-21
  9.  * @remark  字符缓冲区流 字符缓冲区流复制Java文件
  10.  *
  11.  */
  13. public class Io21 {
  14. 	public static void main(String[] args) throws IOException{
  15. 		//创建字符缓冲输出流对象
  16. 		BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
  17. 		//写数据
  18. 		for (int x = 0; x < 3; x++) {
  19. 			bw.write("hello");
  20. 			bw.newLine();
  21. 			bw.flush();
  22. 		}
  23. 		
  24. 		//释放资源
  25. 		bw.close();
  26. 		
  27. 		//创建字符缓冲输入流对象
  28. 		BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  29. 		
  30. 		//创建line对象接收每一行数据
  31. 		String line;
  32. 		//b. String readLine():包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
  33. 		while ((line = br.readLine()) != null) {
  34. 			System.out.println(line);
  35. 		}
  36. 		
  37. 		//释放资源
  38. 		br.close();
  39. 	}
  41. }

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/116603510

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/120325312

内容来源于网络，如有侵权，请联系作者删除！

上一篇：file类别
Javaio流字符流

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com