JAVA IO流编程 实现文件的写入、写出以及拷贝

一、流的概念

流：数据在数据源（文件）和程序（内存）之间经历的路径。

输入流：数据从数据源（文件）到程序（内存）的路径。

输出流：数据从程序（内存）到数据源（文件）的路径。

以内存为参照，如果数据向内存流动，则是输入流，反之则是输出流

 字节流：FileInputStream用来读取文件

　　　　 FileOutputStream用来写入到文件

 字符流：FileReaderBufferedReader用来读取文件

　　　　 FileWriteBufferedWrite用来写入到文件

二、操作用法

1.获取文件对象，针对该对象进行一些基本操作

        //创建一个文件对象
        File f = new File("F:\test\sheet.xls");
        //得到文件的路径
        System.out.println("文件路径"+f.getAbsolutePath());
        //得到文件的大小，字节数
        System.out.println("文件大小"+f.length());
        //可读属性
        System.out.println("可读"+f.canRead());

2.创建文件（判断该文件是否存在，若存在则弹出提示，若不存在则进行创建）

//创建文件
        File f = new File("F:\test\test.txt");
        //判断该文件是否存在
        if(!f.exists())
        {
            //可以创建
            try {
                f.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println("改文件已存在,创建失败！");
        }

3.创建文件夹（条件同上）

 //创建文件夹
        File f = new File("F:\test");
        if (f.isDirectory())//判断是不是一个文件夹
        {
            System.out.println("创建失败");
        } else {
            f.mkdir();
        }

Tips:这里写明一下isFile()、exists()和isDirectory()的区别

isFile()：判断是否文件，也许可能是文件或者目录。
exists()：判断是否存在，可能不存在。
isDirectory(): 判断该对象是否是一个文件夹。

4.列出某文件夹下面的所有文件（此时对象还是File，File没有文件和文件夹之分，对电脑来讲，文件夹只是一种特殊的文件）

File f = new File("F:\testt");
        if (f.isDirectory()) {
            File filelists[] = f.listFiles();
            for (int i = 0; i < filelists.length; i++)
        {
            System.out.println("文件名是:"+filelists[i].getName());
        }
        }

5.FileInputStream的使用

/**
 * 演示FileInputStream类的使用
 */
package com.test2;

import java.io.*;

public class Demo11_2 {
    public static void main(String[] args) {

        //得到一个文件对象
        File f = new File("F:\tt\test.txt");
        FileInputStream fis = null;
        //因为file没用读写的能力,所以需要使用FileInputStream
        try {
            fis = new FileInputStream(f);

            //定义一个字节数组（相当于一个缓存，如果你的对象"f"是一个很大的文件，内存不够用，所以只能一点一点地读取）
            byte[] bytes = new byte[1024];
            //实际读取到的字节数
            int n = 0;
            //循环读取
            //如果read()返回-1，则说明读取完毕
            while ((n = fis.read(bytes)) != -1) {
                //将字节转换成string
                //此时实例化s时,要注意指定编码格式,电脑上文档默认的是GBK,而我这边默认的是utf-8，
                //所以如果不指定格式的话,最后输出的中文会出现乱码
                String s = new String(bytes, 0, n,"GBK");
                System.out.println(s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭文件流(关键)
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

读取成功..

6.FileOutputStream的使用

/**
 * 演示FileOutputStream的使用
 */
package com.test2;

import java.io.*;

public class Demo11_3 {
    public static void main(String[] args) {
        File f = new File("F:\tt\test.txt");
        //字节输出流
        FileOutputStream fos = null;

        try {
            fos = new FileOutputStream(f);

            String s = "Westlife - Better man
西城男孩 - 更完美的人";

            fos.write(s.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

写入成功..

7.字节流的操作（通过写入写出来实现图片的拷贝,操作byte）

/**
 * 图片拷贝
 */
package com.test2;

import java.io.*;

public class Demo11_4 {
    public static void main(String[] args) {
        //先把图片读入到内存,再写到某个文件
        //因为是二进制文件,因此只能用字节流完成
        File f = new File("F:\tt\Westlife.jpg");
        //输入流
        FileInputStream fis = null;
        //输出流
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(f);
            //或者省略上面实例化File,直接在这里fis = new FileInputStream("F:	tWestlife.jpg");也可以

            fos = new FileOutputStream("D:\练习\Westlife.jpg");
            byte[] bytes = new byte[1024];
            int n = 0;//记录实际读取到的字节数
            //循环读取
            while ((n = fis.read(bytes)) != -1) {
                //输出到指定文件
                fos.write(bytes);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭打开的文件流
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

8.字符流的操作（操作char）

/**
 * 字符流操作
 */
package com.test2;

import java.io.*;

public class Demo11_5 {
    public static void main(String[] args) {
        //文件取出字符流对象(输入流)
        FileReader fr = null;
        //写入到文件(输出流)
        FileWriter fw = null;

        //创建一个fr对象
        try {
            //创建输入对象
            fr = new FileReader("F:\tt\test.txt");
            //创建输出对象
            fw = new FileWriter("D:\练习\test2.txt");


            //读入到内存
            int n = 0;//记录实际读取到的字符数
            char c[] = new char[1024];
            while ((n = fr.read(c)) != -1) {
                //输入
//                String s = new String(c,0,n);
//                System.out.println(s);
                //输出
                //方法一:fw.write(c);
                方法二://指定输出的起始位置
                fw.write(c, 0, n);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭文件流
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

9.缓冲字符流（提高了效率，直接操作String）

/**
 * 缓冲字符流操作
 */
package com.test2;

import java.io.*;

public class Demo11_6 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;

        //先创建FileReader对象
        FileReader fr = null;

        //创建FileWriter对象
        FileWriter fw = null;
        try {
            fr = new FileReader("F:\tt\test.txt");
            br = new BufferedReader(fr);


            fw = new FileWriter("D:\练习\test3.txt");
            bw = new BufferedWriter(fw);

            //循环读取文件
            String s = "";
            while ((s = br.readLine()) != null) {
                //读取到内存
                //System.out.println(s);

                //输出到磁盘
                bw.write(s+"
");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //注:如果文件流不关闭的话会影响后续对该文件的操作,比如可能读不到该文件的数据
            if (br != null) {
                try {
                    {
                        br.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (bw != null) {
                try {
                    {
                        bw.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}