Java IO流总结（二）-示例

1.使用文件操作的9大方法完成文件的判断

判断文件或目录是否存在 : exits() 返回值boolean型
* 判断是否是文件: isFile() boolean
* 判断是否是目录: isDiectory() boolean
* 返回此对象表示的文件的相对路径: getPath() String
* 返回此对象表示的文件的绝对路径: getAbsolutePath() String
* 返回此对象表示的文件或目录的名称: getName() String
* 删除此对象指定的文件或目录: delete() boolean
* 创建名称的空文件(不是文件夹): createNewFile() blloean
* 返回文件的长度 单位为字节,如果文件不存在,则返回0L :length() long

 package cn.filetest;

 import java.io.File;
 import java.util.Scanner;

 public class TestFileMethods {

     /**案例1,使用文件操作的9大方法完成文件的判断
      * @param args
      * 判断文件或目录是否存在 : exits()  返回值boolean型
      * 判断是否是文件: isFile()  boolean
      * 判断是否是目录: isDiectory()  boolean
      * 返回此对象表示的文件的相对路径:  getPath()   String
      * 返回此对象表示的文件的绝对路径:  getAbsolutePath()  String
      * 返回此对象表示的文件或目录的名称:  getName() String
      * 删除此对象指定的文件或目录: delete()   boolean
      * 创建名称的空文件(不是文件夹): createNewFile()    blloean
      * 返回文件的长度 单位为字节,如果文件不存在,则返回0L  :length()   long
      */
     public static void main(String[] args) {
         try {
             fileClassMeth();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     public static void fileClassMeth() throws Exception{

         //将异常抛出,由调用者处理!!!
             //1.实例化对象,指定判断的路径
                 File file = new File("aa\\bb\\3.txt");
             //2.判断1.txt是否存在 exits()
                 if(file.exists()) {
                     if(file.isDirectory()) {
                         //判断如果是目录,输出当前路径是文件夹
                         System.out.println("当前路径是文件夹");
                     } else {
                         System.out.println("当前路径是文件");
                         System.out.println("当前文件存在");
                         System.out.println("文件的绝对完整路径:" + file.getAbsolutePath() + file.getName());
                         System.out.println("文件名为:"  + file.getName());
                         System.out.println("文件的相对路径:"  + file.getPath());
                         System.out.println("文件的上一级目录:"  + file.getParent());
                         System.out.println("文件的长度:"  + file.length());
                     }
                     System.out.println("请按1完成删除操作:");
                     Scanner input = new Scanner(System.in);
                     if(input.nextInt() ==1) {
                         boolean bool = file.delete();
                         if(bool) {
                             System.out.println("删除成功");
                         }
                     }

                 } else {
                     System.out.println("当前文件不存在");
                     //3.当文件不存在,创建文件
                     boolean bool = file.createNewFile();
                     if(bool) {
                         System.out.println("创建文件成功");
                     }
                 }

     }
 }

2.字节流的读写操作：

FileInputStream  fin = new FileInputStream("D:\\temp\\aa.txt");

byte[] b = new byte[fin.available()]; // fin.available() 可读取的字节数

fin.read(b); // 从内容索引号为1的位置读取2个字符并保存在字节数组b中，读取第一个字节数据并转换为该字节数据的ASCII码

FileOutputStream fo = new FileOutputStream("D:\\temp\\b.txt",true); // true:追加, false :覆盖
fo.write(b);

 package cn.filetest;

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class TestFileMthods1 {

     /**
      * 案例1 字节流的读写操作 字节流的读: int asz = fin.read();
      *
      */
     public static void main(String[] args) {
         fileReaderMehtod1(); // main()方法直接调用本类静态方法
     }

     public static void fileReaderMehtod1() {
         FileInputStream fin = null;
         FileOutputStream fo = null; // 为了能够在该静态方法任何位置访问,放在try语句外面
         try {
             // 1.实例化输入流,指向 1.txt文件,该文件必须事先存在！否则抛出fileNotFoundException
             fin = new FileInputStream("D:\\temp\\aa.txt");
             /*FileInputStream类的构造方法FileInputStream(String name)
              * 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定 */
             System.out.println("可读取字节个数为：" + fin.available());    // 2.定义一个字节数组(中转数组)
             byte[] b = new byte[fin.available()]; // fin.available() 可读取的字节数
             // 3.从输入流指向的地址1.txt中读取字节,存储在字节数组中
             // 读取一个字节到字节数组b中；fin.read()则是读取第一个字节数据并转换为该字节数据的ASCII码
             fin.read(b); // 从内容索引号为1的位置读取2个字符并保存在字节数组b中
             // 4.输出每个字节，输出结果是字母对应的ASCII码！！！！！fin.read(b)返回的是int类型！！！但写入的文件中会正常显示，而不是显示ASCII码
             for (byte c : b) {
                 System.out.print(c + "-" + (char) c + "\n");
             }
             // 5.将字节输出到指定的路径下:
             fo = new FileOutputStream("D:\\temp\\b.txt",true);    // true:追加, false :覆盖
             fo.write(b);// 将字符数组b中的字节写入2.txt中
             System.out.println("\n写入成功");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {// 6.关闭输入输出流
             try {
                 if (fo != null) {
                     fo.close();
                 }
                 if (fin != null) {
                     fin.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }

         }
     }

 }

3.BufferedReader 、 BufferedWriter、 FileReader、FileWriter

（1）BufferedReader类是Reader类的子类，它与FileReader类的区别在于BufferedReader带有缓冲区，可以先把一批数据读到缓冲区，接下来的读操作都是从缓冲区内获取数据，避免每次都从数据源读取数据进行字符换货，从而提高读取操作的效率：

BufferedReader br2 = new BufferedReader(new FileReader(new File("D:\\temp\\aa.txt")));

String line = br.readLine(); // BufferedReader类的readLine()方法返回一个字符串！！！每执行该语句一次，读取一行的内容

（2）BufferedWriter类把一批数据写到缓冲区，当缓冲区写满时，再把缓冲区的数据写到字符输出流中，可以避免每次都执行物理写操作，提高输入输出操作的效率

BufferedWriter bw = new BufferedWriter(new FileWriter(new File("D:\\temp\\2.txt")));

bw.write("ddd");

bw.flush(); // 刷新缓冲区写入

 package cn.filetest;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;

 public class TestFileMethod2 {

     /**
      * BufferedReader
      * BufferedWriter
      * FileReader
      * @param args
      */
     public static void main(String[] args) {
         charReader();
         BufReader();
         charWriter();
     }

     /**
      * 字符流的写(写入磁盘上的文件中)
      */
     public static void charWriter() {
         // 1.定义一个写入接口变量，将其子类FileWriter对象实例化
         Writer wr = null;
         BufferedWriter bw = null;
         // 2.实例化一个文件写入类的子类
         try {
             File fi = new File("D:\\temp\\2.txt");
             wr = new FileWriter(fi); // 创建一个FileWriter对象； 写入目的源为2.txt
             bw = new BufferedWriter(wr); // 创建一个BufferedWriter对象
             // 3.写入的内容
             wr.write(97); // 将AISIC码值为97的字符（a）写入2.txt
             wr.write("你好");
             wr.write(48);// 写入0
             bw.write("ddd");
             char[] zf = { 'a', 'b', '1' };
             wr.write(zf); // 写入字符数组
             bw.flush(); // 刷新缓冲区，才能写入
             System.out.println("写入成功");
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (wr != null) {
                 try {
                     wr.close();// 关闭流
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

     /**
      * BufferedReader
      */
     public static void BufReader() {
         // 1.导入IO包
         // 2.定义Reader接口的引用变量，只能实例化其子类对象FileReader
         Reader reader = null;
         BufferedReader br = null;
         try {
             // 3.实例化读取器
             File fi = new File("D:\\temp\\aa.txt");
             reader = new FileReader(fi);
             // 创建一个使用默认大小输入缓冲区的缓冲字符输入流对象br,将reader读取到的内容放在该缓冲区对象中。
             br = new BufferedReader(reader); // 使用字符流类BufferedReader和FileReader读取文本文件
             // 4.字符流，需要存储在一个字符数组中，定义一个字符数组
             String line = br.readLine(); // BufferedReader类的readLine()方法返回一个字符串！！！每执行该语句一次，读取一行的内容
             while (line != null) {
                 System.out.println("line:" + line);
                 line = br.readLine(); // 每执行该语句一次，读取一行的内容
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 if (reader != null) {
                     reader.close();
                 }
                 if (br != null) {
                     br.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

     }

     /**
      * 字符流的读:FileReader
      */
     public static void charReader() {
         // 1.导入IO包
         // 2.定义Reader接口的引用变量，只能实例化其子类对象FileReader
         Reader reader = null;
         StringBuffer sbu = new StringBuffer();// 存放到StringBuffer里面
         try {
             // 3.实例化读取器
             File fi = new File("D:\\temp\\aa.txt");
             reader = new FileReader(fi);
             // 4.字符流，需要存储在一个字符数组中，定义一个字符数组
             char[] ch = new char[(int) fi.length() - 2];
             // 5.读取字符到字符数组中
             reader.read(ch);
             sbu.append(ch);// 追加
             System.out.println("追加后的字符串为:" + sbu);
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 if (reader != null) {
                     reader.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

     }

 }

4.二进制文件读写 ： DataInputStream、DataOutputStream 

 package cn.filetest;

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class TestFileMethods3 {

     /**
      * @param args
      */
     public static void main(String[] args) {
         dataFileMethod();
     }

     public static void dataFileMethod() {
         // 1、实例化二进制输入流
         FileInputStream fis = null;
         DataInputStream dts = null;
         // 2、实例化文件和二进制输出流
         FileOutputStream fou = null;
         DataOutputStream dos = null;
         // 3、实例化对象
         try {
             fis = new FileInputStream("D:\\java\\Animal.class");
             dts = new DataInputStream(fis);

             fou = new FileOutputStream("d:/java/aaa.class");
             dos = new DataOutputStream(fou);
             // 4、读取并写入
             int temp;
             while ((temp = dts.read()) != -1) {
                 dos.write(temp);// 把每次读取的二进制数据循环写入到文件中
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 if (dts != null) {
                     dts.close(); // 关闭输入流
                 }
                 if (dos != null) {
                     dos.close(); // 关闭输出流
                 }
                 if (fis != null) {
                     fis.close();
                 }
                 if (fou != null) {
                     fou.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

     }
 }