• 输入输出流及其16个类（一）

    目录

    输入输出流

    流

    File类

     InputStream类

    FileInputStream类

    OutputStream类 

     FileOutputStream类

    Reader类

    InputStreamReader类 

    FileReader类

    BufferedReader类 

     Writer类

    OutputStreamWriter类

    FileWriter类

    BufferedWriter类

    输入输出流

    程序在运行期间，可能需要从外部的存储媒介或其他程序中读入所需要的数据，这就需要使用输入流。输入流的指向称为它的源，程序通过输入流读取源中的数据。

    输入流示意图：

    另一方面，程序在处理数据后，可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序，这就需要使用输出流。输出流的指向称为它的目的地，程序通过输出流把数据传送到目的地。虽然I/O流经常与磁盘文件存取有关，但是源和目的地也可以是键盘、内存或显示器窗口。

    输出流示意图：

    java.io包(I/O 流库)提供大量的流类，所有输入流都是抽象类InputStream (字节输入流)或抽象类Reader (字符输入流)的子类，而所有输出流都是抽象类OutputStream (字节输出流)或抽象类Writer (字符输出流)的子类。

    流

    Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。

    通过流来读写文件

            流是一组有序的数据序列

            以先进先出方式发送信息的通道

    Java流的分类

     

    File类

    Java程序想要访问文件属性需要使用java.io.File 类

    操作：

            1.创建File类对象指向需要访问的文件

            2.调用File类对象访问文件属性

    File类的常用方法

    方法名称

    说明

    boolean exists( )

    判断文件或目录是否存在

    boolean isFile( )

    判断是否是文件

    boolean isDirectory( )

    判断是否是目录

    String getPath( )

    返回此对象表示的文件的相对路径名

    String getAbsolutePath( )

    返回此对象表示的文件的绝对路径名

    String getName( )

    返回此对象表示的文件或目录的名称

    boolean delete( )

    删除此对象指定的文件或目录

    boolean createNewFile( )

    创建名称的空文件，不创建文件夹

    long  length()

    返回文件的长度，单位为字节, 如果文件不存在，则返回 0L

    1. package demo01;
    2. import java.io.File;
    3. import java.io.IOException;
    4.  
    5.  
    6. public class FileDemo01 {
    7.  
    8. 	public static void main(String[] args) {
    9. 		//获取一个File类对象，这个对象指向计算机F盘中的demo.txt文件
    10. 		File file1 = new File("F:\\demo.txt");
    11. 		File file2 = new File("F:/test");
    12. 		
    13. 		//boolean exists():判断File类对象指向的文件或者目录是否存在，如果存在返回true,否则返回false
    14. 		System.out.println(file1.exists());
    15. 		System.out.println(file1.exists());
    16. 		
    17. 		//boolean isFile():判断File类对象指向的是不是一个文件，如果是返回true,否则返回false
    18. 		System.out.println(file1.isFile());
    19. 		System.out.println(file2.isFile());
    20. 		
    21. 		//boolean isDirectory():判断File类对象指向的是不是一个目录，如果是返回true,否则返回false
    22. 		System.out.println(file1.isDirectory());
    23. 		System.out.println(file2.isDirectory());
    24. 		
    25. 		File file3 = new File("F:/a.txt");
    26. 		File file4 = new File("F:/a/b/c/d.txt");
    27. 		//boolean createNewFile():创建名称的空文件，不创建文件夹，也就是说File类指向的文件，其所在的文件夹应该存在
    28. 		
    29.  
    30. 	
    31. //			file3.createNewFile();
    32. //
    33. //			file4.createNewFile();
    34. 		
    35. 		System.out.println("文件创建成功");
    36. 		//String getPath():返回此对象表示的文件的相对路径名
    37. 		//String getAbsolutePath():返回此对象表示的文件的绝对路径名
    38. 		//String getName():返回此对象表示的文件或目录的名称
    39. 		
    40. 		File file5 = new File("qqqq.txt");
    41. 		
    42. 		try {
    43. 			file5.createNewFile();
    44. 			System.out.println("file5创建成功");
    45. 		} catch (IOException e) {
    46. 			e.printStackTrace();
    47. 		}
    48. 		
    49. 		System.out.println(file5.getPath());//qqqq.txt
    50. 		System.out.println(file5.getAbsolutePath());//E:\MyEclipseWorkspaces02\Day026输入输出流\qqqq.txt
    51. 		//boolean delete():删除File类对象指向的文件或目录
    52. //		file1.delete();
    53. 		
    54. 		file2.delete();
    55. 		//long length():返回File类对象指向的文件的长度，单位为字节，如果文件不存在，返回0L
    56. 		
    57. 		System.out.println(file1.length());//0
    58. 		
    59. 		File file6 = new File("F:/a");
    60. 		File file7 = new File("F:/aa/bb/cc/dd");
    61. 		//mkdir():创建此抽象路径名
    62. 		file6.mkdir();
    63. //		file7.mkdir();
    64. 		
    65. 		//mkdirs():创建此抽象路径名指定的目录，包括所有必需但不存在的父目录
    66. 		file7.mkdirs();
    67. 			
    68.  
    69. 	}
    70.  
    71. }

     InputStream类

            抽象类，直接子类比较经常使用的是FileInputStream类

            此抽象类是表示字节输入流的所有类的超类。

    FileInputStream类

    如果对文件读取需求比较简单，那么可以使用FileInputStream 类(文件字节输入流),该类是InputStream类的子类(以字节为单位读取文件)，该类的实例方法都是从InputStream类继承来的。

    使用FileInputStream 读文本文件

    1.导包

    2.创建对象指向文件

    3.使用方法读取文件

    4.关闭流

    1. package demo01;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.IOException;
    6.  
    7. public class FileInputStreamDemo01 {
    8.  
    9. 	public static void main(String[] args) throws IOException {
    10. 		//字节输入流InputStream基类  为抽象类  FileInputStream类是其子类
    11. 		// 创建File类对象
    12. 		File file = new File("F:/a.txt");
    13. 		//创建FileInputStream类对象
    14. 		FileInputStream fis = new FileInputStream(file);
    15. 		
    16. 		//读取数据
    17. //		int num = fis.read();
    18. //		System.out.println((char)num);
    19. //		int num2 = fis.read();
    20. //		System.out.println((char)num2);
    21. //		int num3 = fis.read();
    22. //		System.out.println((char)num3);
    23. //		
    24. //		while(fis.read()!=-1){
    25. //			int num = fis.read();
    26. //			System.out.println((char)num);
    27. //			
    28. //		}
    29. 		
    30. 		int num;
    31. 		while((num=fis.read())!=-1){
    32. 			System.out.println((char)num);
    33. 		}
    34. 		
    35. 		System.out.println("数据读取完毕");
    36. 		
    37. 		//数据读取完毕之后，关闭流
    38. 		fis.close();
    39. 	
    40. 		
    41. 		
    42. 	}
    43.  
    44. }
    1. package demo01;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.IOException;
    5.  
    6. public class FileInputStreamDemo02 {
    7.  
    8. 	public static void main(String[] args) throws IOException {
    9. 		// 创建FileInputStream类对象
    10. 		FileInputStream fis = new FileInputStream("F:/a.txt");
    11. 		//读取数据
    12. 		byte[] bytes = new byte[1024];
    13. 		//从流中读取数据，将读取的数据存储在你声明的数组中，该方法返回的结果表示从流中读取到的字节数目
    14. 		int num = fis.read(bytes);
    15. 		System.out.println(num);
    16. 				
    17. 		//遍历数组，获取读取到的数据
    18. 		for (int i = 0; i < num; i++) {
    19. 			System.out.print((char)bytes[i]);
    20. 			
    21. 		}
    22. 		fis.close();
    23. 	}
    24.  
    25. }

    OutputStream类 

    此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

     FileOutputStream类

    如果对文件写入需求比较简单，那么可以使用FileOutputStream类(文件字节输出流),它是OutputStream 类的子类(以字节为单位向文件写入内容)，该类的实例方法都是从OutputStream类继承来的。

     使用FileOutputStream 写文本文件

    1.导包

    2.创建对象指向文件

    3.使用方法写入文件

    4.关闭流

    1. package demo02;
    2.  
    3. import java.io.File;
    4. import java.io.FileNotFoundException;
    5. import java.io.FileOutputStream;
    6. import java.io.IOException;
    7.  
    8. public class FileOutputStreamDEmo01 {
    9.  
    10. 	public static void main(String[] args) {
    11. 		//字节输出流OutputStream基类 是抽象类 其子类是FileOutputSream类
    12. 		//创建File类对象
    13. 		File file = new File("F:/a.txt");
    14. 		
    15. 		// 创建FileOutputStream类对象
    16. 		FileOutputStream fos =null;
    17. 		try {
    18. 			//构造方法FileOutputStream(File file)和FileOutputStream(String path):通过这两个构造方法创建的输出流对象在对外数据输出的时候，会覆盖文件中原来的数据
    19. //			FileOutputStream fos = new FileOutputStream(file);
    20. 			//FileOutputStream(File file,boolean append)和FileOutputStream(String path,boolean append):使用这两个构造方法创建输出流对象的时候，将第二个参数赋值为true，则在对外进行输出数据的时候，不会覆盖文件中原来的数据
    21.  
    22. 			 fos =new FileOutputStream(file,true);
    23. 			 //调用写的方法，将数据写入到文件中
    24. 			 fos.write(65);
    25. 			 System.out.println("数据写入完毕");
    26. 			 
    27. 		} catch (FileNotFoundException e) {
    28. 			e.printStackTrace();
    29. 		} catch (IOException e) {
    30. 			e.printStackTrace();
    31. 		}finally{
    32. 			//关闭流
    33. 			try{
    34. 				if(fos!=null){
    35. 					fos.close();
    36. 				}
    37. 			}catch(IOException e){
    38. 				e.printStackTrace();
    39. 			}
    40. 		}
    41.  
    42. 	}
    43.  
    44. }

    Reader类

    用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

    InputStreamReader类 

    InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

    每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。

    1. package demo04;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.IOException;
    7. import java.io.InputStream;
    8. import java.io.InputStreamReader;
    9.  
    10. public class InputStreamReaderDemo01 {
    11.  
    12. 	public static void main(String[] args) {
    13. 		// 创建File类对象
    14. 		File file = new File("F:/a.txt");
    15.  
    16. 		// 创建InputStream类的引用（InputStream是一个抽象类，无法实例化，可以创建其子类对象）
    17. 		InputStream is = null;
    18. 		// 创建InputStreamReader类对象
    19. 		InputStreamReader isr = null;
    20. 		try {
    21. 			// 向上转型：父类引用指向子类的实例
    22. 			is = new FileInputStream(file);
    23. 			// 创建InputStreamReader类对象
    24. 			isr = new InputStreamReader(is);
    25. 			
    26. 			//读取数据
    27. 			int num;
    28. 			while((num=isr.read())!=-1){
    29. 				System.out.println((char)num);
    30. 			}
    31. 		} catch (FileNotFoundException e) {
    32. 			e.printStackTrace();
    33. 		} catch (IOException e) {
    34. 			e.printStackTrace();
    35. 		}finally{
    36. 			try{
    37. 				isr.close();
    38. 				is.close();
    39. 				
    40. 			}catch (IOException e) {
    41. 				e.printStackTrace();
    42. 			}
    43. 		}
    44.  
    45. 	}
    46.  
    47. }

    FileReader类

    InputStreamReader类 的直接子类

    用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

    1. package demo05;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileReader;
    5. import java.io.IOException;
    6.  
    7. public class FileReaderDemo01 {
    8.  
    9. 	public static void main(String[] args) {
    10. 		// 创建FileReader类对象，FileReader类对象只能按照本地平台的编码格式读取文件，如果文件编码和本地平台编码格式不一样，会出现乱码的现象
    11. 		FileReader fr =null;
    12. 		try {
    13. 			fr = new FileReader("F:/a.txt");
    14. 			char[] chs = new char[1024];
    15. 			//读取数据
    16. 			int num = fr.read(chs);
    17. 			for (int i = 0; i < num; i++) {
    18. 				System.out.print(chs[i]);
    19. 				
    20. 			}
    21. 		} catch (FileNotFoundException e) {
    22. 			e.printStackTrace();
    23. 		} catch (IOException e) {
    24. 			e.printStackTrace();
    25. 		}
    26. 		
    27.  
    28. 	}
    29.  
    30. }

    BufferedReader类 

    BufferedReader类是Reader类的子类

    从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

    BufferedReader类带有缓冲区 按行读取内容的readLine()方法

            BufferedReader常用的构造方法

                    BufferedReader(Reader in)

            子类BufferedReader特有的方法  

                    readLine()

    1. package demo06;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.IOException;
    7. import java.io.InputStream;
    8. import java.io.InputStreamReader;
    9. import java.io.Reader;
    10.  
    11. public class BufferedReaderDemo01 {
    12.  
    13. 	public static void main(String[] args) {
    14. 		//创建InputStream类对象，但是InputStream类是一个抽象类，不能创建对象，可以将其引用指向子类
    15. 		InputStream is =null;
    16. 		//创建Reader类对象，但是Reader类是一个抽象类，不能创建对象，可以将其引用指向子类（包含孙子类）的实例
    17. 		Reader reader =null;
    18. 		//创建BufferedReader类对象
    19. 		BufferedReader br = null;
    20. 		try {
    21. 			is = new FileInputStream("F:/demo.txt");
    22. 			reader =  new InputStreamReader(is);
    23. 			br = new BufferedReader(reader);
    24. 			
    25. 			//读取文件
    26. //			String str = br.readLine();
    27. //			System.out.println(str);
    28. //			String str2 = br.readLine();
    29. //			System.out.println(str2);
    30. 			String str;
    31. 			while((str=br.readLine())!=null){
    32. 				System.out.println(str);
    33. 			}
    34.  
    35. 		} catch (FileNotFoundException e) {
    36. 			e.printStackTrace();
    37. 		} catch (IOException e) {
    38. 			e.printStackTrace();
    39. 		}finally{
    40. 			try{
    41. 				br.close();
    42. 				reader.close();
    43. 				is.close();
    44. 			}catch(IOException e){
    45. 				e.printStackTrace();
    46. 			}
    47. 		}
    48. 		
    49.  
    50. 	}
    51.  
    52. }

     Writer类

    写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 

    OutputStreamWriter类

    OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

    1. package demo07;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import java.io.OutputStream;
    7. import java.io.OutputStreamWriter;
    8.  
    9. public class OutputStreamWriterDemo01 {
    10.  
    11. 	public static void main(String[] args) {
    12. 		// 创建OutputStream类对象，该类是一个抽象类，不能直接创建对象，可以创建一个引用指向其子类对象
    13. 		OutputStream os = null;
    14. 		// 创建OutputStreamWriter类对象
    15. 		OutputStreamWriter osw = null;
    16. 		try {
    17. 			os = new FileOutputStream("F:/demo.txt", true);
    18. 			osw = new OutputStreamWriter(os);
    19.  
    20. 			osw.write("asdfghjkl");
    21. 			System.out.println("数据写入完毕");
    22. 		} catch (FileNotFoundException e) {
    23. 			// TODO Auto-generated catch block
    24. 			e.printStackTrace();
    25. 		} catch (IOException e) {
    26. 			// TODO Auto-generated catch block
    27. 			e.printStackTrace();
    28. 		} finally {
    29. 			try {
    30. 				osw.close();
    31. 				os.close();
    32. 			} catch (IOException e) {
    33. 				e.printStackTrace();
    34. 			}
    35. 		}
    36.  
    37. 	}
    38.  
    39. }

    FileWriter类

    用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

    1. package demo08;
    2.  
    3. import java.io.FileWriter;
    4. import java.io.IOException;
    5.  
    6. public class FileWriterDemo01 {
    7.  
    8. 	public static void main(String[] args) {
    9. 		//创建FileWriter类对象
    10. 		FileWriter fw = null;
    11. 		try {
    12. 			fw = new FileWriter("F:/demo.txt", false);
    13. 			fw.write("hello java");
    14. 			System.out.println("文件写入完毕");
    15. 		} catch (IOException e) {
    16. 			e.printStackTrace();
    17. 		}finally{
    18. 			try {
    19. 				fw.close();
    20. 			} catch (IOException e) {
    21. 				e.printStackTrace();
    22. 			}
    23. 		}
    24.  
    25. 	}
    26.  
    27. }

    BufferedWriter类

    BufferedWriter类是Writer类的子类

    将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

    BufferedWriter类带有缓冲区

            BufferedWriter常用的构造方法  

                    BufferedWriter(Writer out)

    1. package demo08;
    2.  
    3. import java.io.BufferedWriter;
    4. import java.io.FileWriter;
    5. import java.io.IOException;
    6. import java.io.Writer;
    7.  
    8. public class BufferedWriterDemo01 {
    9.  
    10. 	public static void main(String[] args) {
    11. 		//创建Writer类对象，但是Writer类是一个抽象类，不能直接创建对象，但是可以创建引用指向其子类对象
    12. 		Writer writer = null;
    13. 		//创建BufferedWriter类对象
    14. 		BufferedWriter bw  =null;
    15. 		try {
    16. 			writer = new FileWriter("F:/demo.txt", true);
    17. 			bw  = new BufferedWriter(writer);
    18. 			//先向文件中插入一个换行
    19. 			bw.newLine();
    20. 			bw.write("hello html");
    21. 			bw.newLine();
    22. 			bw.write("hello css");
    23. 			System.out.println("数据写入完毕");
    24. 		} catch (IOException e) {
    25. 			e.printStackTrace();
    26. 		}finally{
    27. 			try {
    28. 				bw.close();
    29. 				writer.close();
    30. 			} catch (IOException e) {
    31. 				// TODO Auto-generated catch block
    32. 				e.printStackTrace();
    33. 			}
    34. 		}
    35.  
    36. 	}
    37.  
    38. }

    BufferedReader和BufferedWriter 类创建的对象称为缓冲输入、输出流，二者增强了读写文件的能力。

    BufferedReader 流和BufferedWriter流，二者的源和目的地必须是字符输入流和字符输出流。

    因此，如果把文件字符输入流作为BufferedReader流的源，把文件字符输出流作为BufferedWriter 流的目的地，那么，BufferedReader 和BufferedWriter 类创建的流将比字符输入流和字符输出流有更强的读写能力，比如，BufferedReader流就可以按行读取文件。

  • 相关阅读:
    【Vue】vuex mapState和mapGetters
    (十三)VBA常用基础知识：编程时各种常用操作之设值，取值，活动窗口设定
    React-配置别名@
    1236288-25-7,DSPE-PEG-FA,Folic acid PEG DSPE,磷脂-聚乙二醇-叶酸脂质体形成材料
    【升职加薪秘籍】我在服务监控方面的实践(5)-应用监控
    基于java+SpringBoot+HTML+Mysql音乐网站
    windows服务器通过nginx配置https
    视频监控汇聚平台LntonCVS国标GB28181协议实现语音对讲功能
    前端项目开发流程
    《计算机病毒技术及其防御》 第一章 课后练习详解
  • 原文地址：https://blog.csdn.net/qq_51810428/article/details/126411936