JAVA自学教程之IO流（一）：文件的读写



JAVA自学教程之IO流（一）：文件的读写。

输入流和输出流相对于内存

将外部设备的数据读取到内存中：输入

将内存中的数据写入外部设备中：输出

IO流常用基类

字节流的抽象基类：InputStream，OutputStream

字符的抽象基类：Reader，Writer

PS:由这四个流派生出的子类都是以父类名作为后缀名

如：InputStream的派生类FileInputStream，Reader的派生类FileReader

PS:如果是文字形式的数据应该优先考虑字符流，且将数据从内存写到硬盘上应该是Writer

FileWriter类

演示：将文字储存到硬盘上（FileWriter）

 

  1. import java.io.FileWriter;
  2. import java.io.IOException;
  4. public class Main
  5. {
  6.     public static void main(String[] args) throws IOException{
  7. //如果文件不存在，会自动创建，存在，会覆盖
  8.         FileWriter fw = new FileWriter(“Demo.txt”);//抛异常
  10. //调用Writer中的write方法，写入数据，但实际上数据写入的是临时储存缓冲区中
  11.         fw.write(“你好”);
  13. //用flush方法刷新该流的缓冲。如果该流已保存缓冲区中各种 write() 方法的所有字符，则立即将它们写入预期目标。
  14.         fw.flush();//可以用多次
  15. //关闭资源
  16. //关闭流，关闭资源，在关闭前会先调用flush刷新缓冲中的数据到目的地
  17. //API文档：关闭此流，但要先刷新它。
  18. //在关闭该流之后，再调用 write() 或 flush() 将导致抛出 IOException。关闭以前关闭的流无效。
  19.         fw.close();//只能用一次
  20.     }
  21. }

PS:FileWriter的构造函数 FileWriter(“damo.txt”,true);续写数据，不写，默认是false，会覆盖原有数据

 


细节

 

 

  1. import java.io.FileWriter;
  2. import java.io.IOException;
  4. public class Main
  5. {
  6.     private static final String LINE_SEPARATOR = System.getProperty(“line.separator”);
  7.     public static void main(String[] args) throws IOException{
  9.         FileWriter fw = new FileWriter(“Demo.txt”,true);
  10.         //构造函数，中加个true可以实现对文件的续写
  12.         fw.write(“你好”+LINE_SEPARATOR+”世界”);//Windows下换行是\r\n,Linus下是\n
  13.         fw.write(LINE_SEPARATOR+”ads”);
  14.         fw.flush();
  15.         fw.close();
  16.     }
  17. }

关于流异常的基本处理

 

在try的外面创建引用，在里面创建对象，关闭时要判断是是否是空指针

 

  1. import java.io.FileWriter;
  2. import java.io.IOException;
  4. public class Main
  5. {
  6.     private static final String LINE_SEPARATOR = System.getProperty(“line.separator”);
  7.     public static void main(String[] args){
  9.         FileWriter fw = null;
  10.         try {
  11.             fw = new FileWriter(“z:\\Demo.txt”,true);//如果传入一个找不到的地址会抛出两个异常
  12.                         //找不到文件异常、空指针异常，所以finally部分，加一句判断是否是空指针
  13.         fw.write(“你好”+LINE_SEPARATOR+”世界”);
  14.         fw.flush();
  16.         } catch (Exception e) {
  17.             System.out.println(e.toString());
  18.         }finally{
  19.             //最后再try一次，单独处理
  20.             if(fw!=null){
  21.                 try {
  22.                 fw.close();
  23.                 } catch (IOException e) {
  24.                 throw new RuntimeException(“关闭失败”);
  25.                 }
  26.             }
  27.         }
  28.     }
  29. }

FileReader类

 

读取一个文本文件，并将读取出来的数据打印到控制台

 

  1. import java.io.FileReader;
  2. import java.io.IOException;
  4. public class Main
  5. {
  6.     public static void main(String[] args) throws IOException {
  8.         //一定要确保文件是存在的
  9.         FileReader fr = new FileReader(“g:\\java\\Main\\Demo.txt”);//文件内容是ab
  11.         //read方法，作为整数读取的字符，范围在 0 到 65535 之间 (0×00-0xffff)，如果已到达流的末尾，则返回 -1
  13. //      int c = fr.read();
  14. //      System.out.println((char)c);
  15. //      int c1 = fr.read();
  16. //      System.out.println((char)c1);
  17. //      int c2 = fr.read();
  18. //      System.out.println(c2);//-1
  20.         int temp;
  21.         while((temp = fr.read())!=-1){
  22.             System.out.println(temp);
  23.         }
  24.         fr.close();
  25.     }
  26. }

 

read();读取一个一个字符，相比之下，read()方法还有读取数组的重载形式：效率高

 

  1. import java.io.FileReader;
  2. import java.io.IOException;
  4. public class Main
  5. {
  6.     public static void main(String[] args) throws IOException {
  8.         FileReader fr = new FileReader(“g:\\java\\Main\\Demo.txt”);//文件内容是abcdef
  9.         //使用read(char[] a)读取文本文件数据
  10.         /*
  11.          * 先创建字符数组，
  12.          */
  13. //      char ch[] = new char[5];
  14. //      int num = fr.read(ch);//将读取到的字符存储到数组中,num是字符的个数
  15. //      System.out.println(num+”:”+new String(ch));//5：abcde
  16. //
  17. //      int num1 = fr.read(ch);//将读取到的字符存储到数组中
  18. //      System.out.println(num1+”:”+new String(ch));//1:fbcde
  19. //      //这里相当于，f把原来数组里的a替换了，而txt里无数据了，所以剩余的数组元素还在
  20. //
  21. //      int num2 = fr.read(ch);//再读也没有数据了，所以返回-1，char数组无覆盖
  22. //      System.out.println(num2+”:”+new String(ch));//-1:fbcde
  24.         //正规写法
  25.         int num = 0;
  27.         char[] ch = new char[5];//数组的长度最好是1024*n
  29.         while((num = fr.read(ch))!=-1){
  30.             System.out.println(new String(ch,0,num));
  31.         }
  33.         fr.close();
  34.     }
  35. }