Java IO 节点流和字符流 学习 + 案例分析

一.字节流

---

1.InputStream、OutputStream

1. 介绍
   a.InputStream和OutputStream是处理字节流的抽象类
   b.InputStream 是字节输入流的所有类的超类,一般使用它的子类,如FileInputStream等。
   c.OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等。

2. InputStream、OutputStream子类如下图
   
   

---

2.FileInputStream

1. 介绍
   从文件系统中的某个文件中获得输入字节
   
   

2. 案例
   E:\FileInputStream_example.txt文档中内容如下图，我们现在要读取该内容：
   
   代码：

   public class FileInputStream_example {
       public static void main(String[] args){
   
               String filename = "E:\\FileInputStream_example.txt";
               File file = new File(filename);
               byte[] bytes = new byte[2];
               FileInputStream fis1 = null;
               FileInputStream fis2 =null;
               try {
                       fis1 = new FileInputStream(file);
                       fis2 = new FileInputStream(file);
                       int i,num1=0,num2=0;
   
                       //用read()方法读取文件
                       System.out.println("·用read()方法读取，一个字节一个字节读");
                       while((i=fis1.read()) != -1){
                               System.out.print(i+" ");
                               num1++;
                       }
                       System.out.println();
                       System.out.println("读取次数为："+num1);
                       System.out.println();
   
                       //用read(byte[] b)方法读取文件
                       System.out.println("·用read(byte[] b)方法读取，两个字节两个字节读，每次读取完换一行");
                       while((i=fis2.read(bytes)) != -1){
                               for(int j=0;j<bytes.length;j++){
                                       System.out.print(bytes[j]+" ");
                               }
                               System.out.println();
                               num2++;
                       }
                       System.out.println("读取次数为："+num2);
               } catch (FileNotFoundException e) {
                       e.printStackTrace();
               } catch (IOException e) {
                       e.printStackTrace();
               }finally {
                       try {
                               fis1.close();
                               fis2.close();
                       } catch (IOException e) {
                               e.printStackTrace();
                       }
               }
       }
   }

   结果：
   

   分析：
   FileInputStream的read()方法，是一个字节一个字节读取的，读取后返回 0 到 255 范围内的 int 字节值，若读取到文件末尾，则返回-1；它的read(byte[] b)方法，每次读去b数组长度的字节，以整数形式把字节缓存在b数组中，再返回。若读到文件末尾，则返回-1。

   注：如果要读的文件内容数量，不能整除byte数组的长度，最后一次读取时，少了几个，就从上次读取的内容中取几个，从后往前取，但是放入数组是从前往后放。
   例如，下图中，我把代码中的byte[]数组长度由2修改成7，这样只需要读两次便能把10个数组读完。第二次读的时候，先把789三个数都出来，分别是：55 56 57，然后再从上一次的读取的内容中，从后往前取最后7-3=4个，分别是51 52 53 54，再从前往后放如数组中。

   

---

3.FileOutputStream

1. 介绍

   用于将数据写入 File 或 FileDescriptor 的输出流
   

2. 案例
   将0123456789写入到文件E:\FileOutputStream_example.txt中

   代码

   public class FileOutputStream_example {
   
   public static void main(String[] args){
   
       String filename = "E:\\FileOutputStream_example.txt";
       File file = new File(filename);
       FileOutputStream_example.ifFileExists(file);
       FileOutputStream fos1 = null;
       int i=0;
   
       //创建bytes数组，并给其赋值0123456789（需要转换成byte类型）
       byte[] bytes = new byte[10];
       for(int j = 0;j<bytes.length;j++){
           bytes[j]=(byte)j;
       }
   
       //讲字符数组bytes写入文件E:\FileOutputStream_example.txt中
       try {
           fos1 = new FileOutputStream(file);
           try {
               fos1.write(bytes);
           } catch (IOException e) {
               e.printStackTrace();
           }
       } catch (FileNotFoundException e1) {
           e1.printStackTrace();
       }finally {
           //关闭资源
           try {
               fos1.flush();
               fos1.close();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }
   
   // 判断文件是否存在
   public static void ifFileExists(File file){
   
       if(file.exists()){
           System.out.println("file exists");
       }else {
           System.out.println("file not exists, create file");
           try {
               file.createNewFile();
               System.out.println("file create successfule!");
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }
   }

   结果：
   
   分析：
   FileOutputStream的read(byte[] b)方法，是将 b.length 个字节从指定 byte 数组写入此文件输出流中。在文件夹中，看到乱码，是因为FileOutputStream是字节流，它是以二进制写入文件中的。

---

二.字符流

1.Reader、Writer

1. 介绍
   a.处理字符流的抽象类
   b.Reader是所有输入字符流的父类
   c.Writer是所有输出字符流的父类
2. Reader、Writer的子类如图下所示：
   

---

2. FileReader

1. 介绍
   与FileInputStream类似，读取字符型文件。
   

2. 实例

   读取文件FileReader_example
   
   代码：

   public class FileReader_example {
   public static void main(String[] args){
   
       String filename = "E:\\FileReader_example1.txt";
       File file = new File(filename);
       char[]  a = new char[5];
       FileReader fr1 = null;
       FileReader fr2 = null;
       int i=0,num1=0,num2=0;
   
       try {
           fr1 =  new FileReader(file);
           fr2 =  new FileReader(file);
           //按字符数组长度来读取
           System.out.println("--》按字符数组长度来读取");
           while(fr1.read(a) != -1){
               System.out.print(a);
               System.out.print(" ");
               num1++;
           }
           System.out.println();
           System.out.println("读取次数为："+num1);
           System.out.println();
   
           //按单个字符来读取
           System.out.println("--》按单个字符来读取");
           while (( i =fr2.read()) != -1){
               System.out.print((char)i+" ");
               num2++;
           }
           System.out.println();
           System.out.println("读取次数为："+num2);
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }finally {
           try {
               fr2.close();
               fr1.close();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }
   }

   结果：
   
   分析：
   read(char[] cbuf)方法按数组长共度来读取，返回读取的字符数，字符存储在chuf数组中。文中10个字符，每次读取5个，读取5次。read()一个字符一个字符来读取，返回作为整数读取的字符，范围在 0 到 65535 之间 ( 0x00-0xffff)，如果已到达流的末尾，则返回 -1 。文中20个字符读取20次。

---

3.FileWriter

1. 介绍
   与FileOutputStream类似，将字符型数据写入文件。
   

2. 实例
   1.代码

   public class FileWriter_example {
       public static void  main(String[] args){
   
           String filename = "E:\\FileReader_example1.txt";
           File file = new File(filename);
           FileWriter_example.ifFileExists(file);
   
           FileWriter fw = null;
           //将str写入E:\FileWriter_example.txt
           String str = "我从未想过会遇到你们让我不再有假意的笑容";
   
           try {
               fw =  new FileWriter(file,true);
               fw.write(str);
               System.out.println("写入成功！");
           } catch (IOException e) {
               e.printStackTrace();
           } finally {
               try {
                   fw.flush();
                   fw.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   
       // 判断文件是否存在
       private static void ifFileExists(File file){
   
           if(file.exists()){
               System.out.println("file exists");
           }else {
               System.out.println("file not exists, create file");
               try {
                   file.createNewFile();
                   System.out.println("file create successfule!");
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }

   2.结果
   将str=“我从未想过会遇到你们让我不再有假意的笑容”写入E:\FileWriter_example.txt
   

---