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 + "
");
            }
            // 5.将字节输出到指定的路径下:
            fo = new FileOutputStream("D:\temp\b.txt",true);    // true:追加, false :覆盖
            fo.write(b);// 将字符数组b中的字节写入2.txt中
            System.out.println("
写入成功");
        } 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();
            }
        }

    }
}