I/O操作

File对象的一些方法属性 

        String fileName = file.getName();//获取文件的名称
        boolean isCanRead = file.canRead();//判断文件是否是可读的
        boolean isCanWrite = file.canWrite();//判断文件是否可写
        boolean isExits = file.exists();//文件是否存在
        long length = file.length();//文件的长度（以字节为单位）
        String filePath = file.getAbsolutePath();//获取文件的绝对路径
        String parentPath = file.getParent();//获得文件的父路径
        boolean isFile = file.isFile();//文件是否是一个文件
        boolean isDirectory = file.isDirectory();//文件是否是一个目录
        boolean isHiddenFile = file.isHidden();//文件是否是隐藏文件
        long lastModifiedDate = file.lastModified();//返回文件的最后修改时间
        boolean isRename = file.renameTo(new File("E:\\aaa\\bbb\\file.txt"));//重命名文件
        /*
         boolean renameTo(File file);重命名文件，重命名成功返回true,反之false。可以理解为用新file去替换原来的file。
        */

FileInputStream类与FileOutputStream类都是用来操做磁盘文件的，是字节流。
    创建FileInputStream常用的两种构造方法：
    1： new FileInputStream(String filePath);
    filePath:文件路劲
    2：new FileInputStream(new File(...));
    file:文件对象

 虽然java在程序结束时自动关闭所有打开的流，但是当使用完流后，显示的关闭任何打开的流是一个好习惯。不然很容易造成系统资源浪费，并影响其他人读取这个流.

（一）使用字节流读取本地文件

    // File对象定位数据源
    public static void getContent(File file)
            throws IOException
    {
        // 创建文件缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));

        // 创建字节数组，存储临时读取的数据
        byte[] buf = new byte[1024];

        // 记录数据读取的长度
        int len = 0;

        // 循环读取数据
        while ((len = bis.read(buf)) != -1)
        {
            // 长度为-1则读取完毕
            System.out.println(new String(buf, 0, len));
        }
        // 关闭流
        bis.close();
    }
    注意：如果数据源是纯文本数据，使用字符流效率更高。

（二）使用字符处理流读取本地文件内容

    public static void getContent(String path)
        throws IOException
    {
        File f = new File(path);
        if (f.exists())
        {
            // 判断文件或目录是否存在
            if (f.isFile())
            {
                // 该缓冲流有一个readLine()独有方法
                BufferedReader br = new BufferedReader(new FileReader(path));
                String s = null;
                while ((s = br.readLine()) != null)
                {
                    // readLine()每次读取一行
                    System.out.println(s);
                }
            }
        }
    }
    注意：该方法比上一个增加了文件判断，提高了程序的健壮性。使用了BufferedReader处理流来处理纯文本数据，比字节流更加简洁方便。

（三）使用字符流写入数据到指定文件：

        // 以标准输入作为扫描来源
        Scanner sc = new Scanner(System.in);
        File f = new File("F:" + File.separator + "test.txt");
        try
        {

            BufferedWriter bw = new BufferedWriter(new FileWriter(f));
            if (!f.exists())
            {
                f.createNewFile();
            }
            while (true)
            {
                String s = sc.nextLine();
                bw.write(s);
                bw.flush();
                if (s.equals("结束") || s.equals(""))
                {
                    System.out.println("写入数据结束！");
                    return;
                }
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }

（四）使用转换流（InputStreamReader/OutputStreamWriter），对写入数据进行改进：

    public static void testConvert(File f) throws IOException {
        if(!f.exists()) {
            f.createNewFile();
        }
        //以System.in作为读取的数据源，即从键盘读取
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //允许添加内容，不会清除原有数据源
        BufferedWriter bw = new BufferedWriter(new FileWriter(f,true));
        String s = null;
        while(!(s = br.readLine()).equals("")) {
            bw.write(s);
            bw.newLine();//换行
        }
        bw.flush();
        bw.close();
        br.close();
    }

    /**
     * 因为System.in是一个InputStream对象，缓冲字符流无法直接使用，
     * 需要通过转换流将字节流转成字符流。然后使用字符输入处理流的readLine()每次读取一行，
     * 使用newLine()完成换行。
     *
     * 注意点：通常使用IO流写入文件时，写入的数据总会覆盖原来的数据，
     * 这是因为文件输出流默认不允许追加内容，
     * 所以需要为FileOuputStream、FileWriter的构造参数boolean append 传入true。
     */

（五）使用字节流完成文件复制

   //字节流实现文件拷贝
    public static String copyFile(String src, String dest) throws IOException, ClassNotFoundException {
        File srcFile = new File(src);//源文件数据源
        File desFile = new File(dest);//写入到目标数据源
        //数据源不存在
        if(!srcFile.exists() || !desFile.exists()) {
            throw new ClassNotFoundException("源文件或者拷贝目标文件地址不存在！");
        }
        //非文件类型
        if(!srcFile.isFile() || !desFile.isFile()) {
            return "源文件或者目标文件不是文件类型!";
        }
        InputStream is = null;
        OutputStream os = null;
        byte[] buf = new byte[1024];//缓存区
        int len = 0;//读取长度
        try {
            is = new BufferedInputStream(new FileInputStream(srcFile));//读取数据源
            os = new BufferedOutputStream(new FileOutputStream(desFile));//写入到数据源
            while((len = is.read(buf)) != -1) { //读取长度不为-1，继续读取
                os.write(buf); //读取内容之后马上写入目标数据源
            }
            os.flush();//输出
            return "文件拷贝成功！查看拷贝文件路径：" + desFile.getPath();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(is != null)
                is.close();
            if(os != null)
                os.close();
        }
        return "文件拷贝失败";
    }

（六）使用打印流来完成写入数据操作：

        try
        {
            // 输出内容的文件数据源
            File f = new File("F:" + File.separator + "test.txt");
            PrintWriter pw = new PrintWriter(f);
            // 把指定内容打印至数据源中
            pw.println("aaaa");
            pw.println("bbbb");
            pw.println("开发");
            pw.flush();
            System.out.println("使用PrintWriter写入数据完成");
            System.out.println("----读取写入的数据---");
            BufferedReader br = new BufferedReader(new FileReader(f));
            String s = null;
            StringBuilder sb = new StringBuilder();// 一个可变字符串
            while ((s = br.readLine()) != null)
            {
                sb.append(s); // 把读取的字符串组合起来
            }
            System.out.println(sb);
            br.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        /**
         * 一般情况下，若是输出文本数据，建议使用打印流。
         * PrintWriter还可以指定输出文本使用何种字符集、在构造参数中指定是否自动刷新。
         * 如果不想覆盖原来的数据，使用该类的append()方法，就会在文件尾部添加内容。
         */

（七）使用打印流来完成文本拷贝：

    // 使用打印流PrintStream来完成文件拷贝
    public static void copyFile(File src, File dest) throws Exception {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
        PrintStream ps = new PrintStream(bos, true);
        byte[] buf = new byte[1024];
        int len = 0;
        //循环读取数据，然后写入到目标文件
        while ((len = bis.read(buf)) != -1) {
            ps.write(buf);
        }
        ps.close();
        bos.close();
    }

        /**
         * 打印流实现文件拷贝操作和字节流差不多，除了用到打印流构造函数的不自动刷新。
         * 打印流还有一个好处就是无需检查异常。
         */