zxzxzx0119的博客

Java,算法

IO流之文件字节,字符输入输出流,以及缓冲流

目录

  • FileInputStream和FileOutputStream使用
  • FileReader和FileWriter使用
  • 缓冲流BufferedReader和BufferedWriter(上层流)使用
  • 文件字节拷贝
  • 文件字符拷贝
  • 文件目录拷贝以及递归的删除文件目录
  • 文件拷贝工具类

基本概况

这里写图片描述

FileInputStream和FileOutputStream使用

文件字节内容的读取和写入

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * 读取文件
 * @author 郑鑫
 */
public class TestFileInputStream {
    public static void main(String[] args) {
        File path = new File("D:/eclipsework/zx/test/in.txt");
        FileInputStream is = null;  //为了使finally中能够关闭
        try {
            is = new FileInputStream(path);
            byte[] data = new byte[15]; //循环中每一次读取的长度
            int len = 0; //实际读取的长度
            while(-1 != (len = is.read(data))) {
                //字符数组转成字符串
                String info = new String(data, 0, len); //把字节数组构建出来
                System.out.println(info); //dfs.txt中内容: "123wen汉"
                System.out.println("文件长度" + len); //输出实际读取的长度
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在!");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取文件失败!");
        }finally {   //一班在finally中关闭流
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("关闭文件流失败!");
                }
            }
        }
    }
}

效果
这里写图片描述

然后就是文件的写出,这里要注意几点

  • FileOutputStream(path,true),true是追加,默认false是覆盖
  • os.flush(); //一般写出之后强制刷新出去(从流的管道)
  • 注意str.getBytes()的使用
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 测试写出文件
 * @author 郑鑫
 */
public class TestFileOutputStream {
    public static void main(String[] args) {
        File path = new File("D:/eclipsework/zx/test/out.txt");
        FileOutputStream os = null;
        try {
            os = new FileOutputStream(path,true); //(File file boolean append) //true 追加 ,false 覆盖(默认)
            String str = "zhengxin is very good!";  //写出到out.txt
            byte[] data = str.getBytes(); //将字符串转成字节数组
            os.write(data,0,data.length);
            os.flush(); //强制刷新出去(从流的管道)
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在!");
        } catch (IOException e) {
            System.out.println("文件写入失败!");
            e.printStackTrace();
        } finally {
            if(null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    System.out.println("关闭输出流失败!");
                    e.printStackTrace();
                }
            }
        }
    }
}

FileReader和FileWriter使用

和字节输入输出差不多

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
 * 字符流的读写
 * Reader FileReader 
 * Writer FileWriter
 * 注意 : 中间数组不再是字节数组,而是字符数组
 * @author 郑鑫
 */
public class TestFIleReader {
    public static void main(String[] args) {
        File src = new File("D:/eclipsework/zx/test/a.txt");

        Reader reader = null;
        try {
            reader = new FileReader(src);
            char[] flush = new char[100];
            int len = 0;
            while(-1 != (len = reader.read(flush))) {
                //字符数组转字符串
                String str = new String(flush, 0, len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在!");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取文件失败!");
        }finally {
            if(null != reader) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("文件关闭失败!");
                }
            }
        }
    }
}

文件字符输出流也有几个要注意的地方

  • wr.write(str); //注意Writer可以直接写入数组,不需要转成字符数组
  • wr.append(“加油努力!”);//可以直接使用append方法
  • 注意linux中换行/r和/n的使用
    这里写图片描述
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
 * 测试FileWriter
 * @author 郑鑫
 */
public class TestFIleWriter {
    public static void main(String[] args) {
        File dest = new File("D:/eclipsework/zx/test/b.txt");
        Writer wr = null;
        try {
            wr = new FileWriter(dest,true); //追加
            String str = "锄禾日当午\r\n码农真辛苦\r\n一本小破书\r\n一读一上午\r\n";
            wr.write(str);  //注意Writer可以直接写入数组,不需要转成字符数组
            wr.append("加油努力!");
            wr.flush();
        }catch(FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件写入失败!");
        }catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件不存在!");
        }finally {
            if(null != wr) {
                try {
                    wr.close();
                } catch (IOException e) {
                    System.out.println("文件关闭失败!");
                    e.printStackTrace();
                }
            }
        }
    }
}

缓冲流BufferedReader和BufferedWriter(上层流)使用

缓冲流的作用主要是提高性能,缓冲流(节点流) : 提高性能,
BufferedReader包裹的FileReader,BufferedWriter包裹的是FileWriter
注意readLine()和newLine() 等新方法的使用

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 缓冲流(节点流) : 提高性能  
 * @author 郑鑫
 */
public class TestBufferedIO {
    public static void main(String[] args) {
        testChar();
    }

    //缓冲流包裹在节点流外面
    public static void test() {
        String src = "D:/eclipsework/zx/test/in.txt";
        String dest = "D:/eclipsework/zx/test/outt.txt"; 
        try {     //和别的没有什么不同,就是加上缓冲流提高性能
            InputStream is = new BufferedInputStream(new FileInputStream(src)); //在字节流上面包裹一层缓冲流
            OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    //BufferedReader和Writer的使用
    public static void testChar() {
        File src = new File("D:/eclipsework/zx/test/a.txt");
        File dest = new File("D:/eclipsework/zx/test/b.txt");
        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
            reader = new BufferedReader(new FileReader(src));
            writer = new BufferedWriter(new FileWriter(dest));
            String line = null;  
            while (null != (line = reader.readLine())) {  //注意这里是readLine()
                writer.write(line);// 字符数组转字符串
                //writer.append("\r\n");  //加上回车
                writer.newLine();  //这个也是新一行 和上面的效果是一样的
                System.out.println(line);
            }
            writer.flush();   //记得刷新
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在!");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取文件失败!");
        } finally {
            if (null != reader) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("文件关闭失败!");
                }
            }
        }
    }
}

文件字节拷贝

这个相对比较简单,只需要通过程序将读入和写出联系起来即可,注意先打开的流后关闭

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 文件拷贝
 * 就是通过程序将输入和输出结合起来
 * @author 郑鑫
 */
public class TestFileCopy {
    public static void main(String[] args) {
        //确保src存在且可读(不能是文件夹)  dest 可以不存在
        String src = "D:/eclipsework/zx/test/in.txt";
        String dest = "D:/eclipsework/zx/test/outt.txt"; 
        try {
            FileUtil.CopyFile(src, dest);
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在!");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("文件写入失败或者关闭流失败!");
            e.printStackTrace();
        }

    }
    /**
     * 文件拷贝
     * @param srcPath
     * @param destPath
     * @throws FileNotFoundException
     * @throws IOException
     * @return;
     */
    public static void CopyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
        File src = new File(srcPath);
        File dest = new File(destPath);

        if(!src.isFile()) {
            throw new IOException("只能拷贝文件!");
        }

        FileInputStream is = new FileInputStream(src);
        FileOutputStream os = new FileOutputStream(dest);

        byte[] b = new byte[1024];
        int len = 0;
        while(-1 != (len = is.read(b))) {
            os.write(b, 0, len);
        }
        os.flush(); //强制刷出
        //先打开的后关闭
        os.close();
        is.close();
    }
}

文件字符拷贝

这个和上面的大同小异

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;
/**
 * 文件字符文件的拷贝
 * @author 郑鑫
 */
public class TestReaderWriterCopy {
    public static void main(String[] args) {
        // 确保src存在且可读(不能是文件夹) dest 可以不存在
        String src = "D:/eclipsework/zx/test/test.java";
        String dest = "D:/eclipsework/zx/test/out.txt";
        try {
            CopyFile(src, dest);
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在!");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("文件写入失败或者关闭流失败!");
            e.printStackTrace();
        }
    }
    /**
     * 文件拷贝
     * @param srcPath
     * @param destPath
     * @throws FileNotFoundException
     * @throws IOException
     * @return;
     */
    public static void CopyFile(String srcPath, String destPath) throws FileNotFoundException, IOException {
        File src = new File(srcPath);
        File dest = new File(destPath);

        if (!src.isFile()) {
            throw new IOException("只能拷贝文件!");  //自己手动抛出异常
        }
        Reader re = new FileReader(src);
        Writer wr = new FileWriter(dest);
        char[] flush = new char[100];
        int len = 0;
        while (-1 != (len = re.read(flush))) {
            //System.out.println(new String(flush,0,len));
            wr.write(flush, 0, len); 
        }
        wr.flush(); // 强制刷出
        // 先打开的后关闭
        wr.close();
        re.close();
    }
}

文件目录拷贝以及递归的删除文件目录

文件目录的拷贝,如果src(源)是文件的话,就调用文件拷贝的函数(上面写了),如果是目录的话,就首先mkdirs,创建dest目录,然后把src目录下的每个文件递归的拷贝到dest中。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * 文件夹的拷贝,和删除
 * 1.如果是文件,直接IO流拷贝
 * 2.如果是文件夹,就创建
 * 3.递归的使用(递归查找子孙级)
 *     A
 *     |
 *  /     \
 * a.txt   b
 *         |
 *        b.txt
 * @author 郑鑫
 * 
 */
public class CopyDir {
    public static void main(String[] args) {
        String srcPath = "D:/eclipsework/zx/CopyFrom";
        String destPath = "D:/eclipsework/zx/CopyTo";
        CopyDir(srcPath, destPath);
        //deleteFile(new File(destPath));
    }

    /**
     * 文件夹的删除
     * @param file
     */
    public static void deleteFile(File file) {
        if (file.exists()) { // 判断文件是否存在
            if (file.isFile()) { // 判断是否是文件
                file.delete(); // delete()方法 你应该知道 是删除的意思;
            } 
            else if (file.isDirectory()) { // 否则如果它是一个目录
                File files[] = file.listFiles(); // 声明目录下所有的文件 files[];
                for (int i = 0; i < files.length; i++) { // 遍历目录下所有的文件
                    deleteFile(files[i]); // 把每个文件 用这个方法进行迭代
                }
            }
            file.delete();
        } 
        else {
            System.out.println("所删除的文件不存在!" + '\n');
        }
    }

    /**
     * 文件夹的拷贝
     * @param src  源
     * @param dest   目的地
     */
    public static void CopyDir(String srcPath,String destPath) {
        File src = new File(srcPath);
        File dest = new File(destPath);
        CopyDir(src,dest);
    }
    /**
     * 文件夹的拷贝
     * @param src  源
     * @param dest   目的地
     */
    public static void CopyDir(File src,File dest) {
        if(src.isDirectory()) {
            dest = new File(dest,src.getName()); //destPath的子目录
        }
        copyDirDetail(src,dest);
    }
    /**
     * 拷贝文件夹的细节
     * @param src
     * @param dest
     */
    public static void copyDirDetail(File src,File dest) {
        if(src.isFile()) {  //如果是文件的话就直接拷贝
            try {
                FileUtil.CopyFile(src, dest); //调用下面的文件拷贝的方法(上面写过,下面的工具类也有)
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else if(src.isDirectory()) {  //如果是目录
            dest.mkdirs();//确保路径存在,没有的话就创建
            for(File temp : src.listFiles()) {  //递归
                copyDirDetail(temp, new File(dest,temp.getName())); //将src中的每一个拷贝到dest //父子目录创建
            }
        }
    }
}

文件拷贝工具类

这里写了一个文件拷贝和文件目录拷贝的工具类,把上面的总结一下

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

/**
 * 文件的操作
 * 1.拷贝
 * @author 郑鑫
 *
 */
public class FileUtil {
    /**
     * 文件拷贝
     * @param srcPath
     * @param destPath
     * @throws FileNotFoundException
     * @throws IOException
     * @return;
     */
    public static void CopyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
        CopyFile(new File(srcPath), new File(destPath)); //调用重载函数
    }
    /**
     * 文件拷贝的重载函数(直接对文件进行操作)
     * @param src
     * @param dest
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static void CopyFile(File src,File dest) throws FileNotFoundException,IOException {
        if(!src.isFile()) {
            throw new IOException("只能拷贝文件!");
        }
        //如果目的地是文件夹
        if(dest.isDirectory()) {
            throw new IOException(dest.getAbsolutePath()+"不能建立于文件夹同名的文件!");
        }

        FileInputStream is = new FileInputStream(src);
        FileOutputStream os = new FileOutputStream(dest);

        byte[] b = new byte[1024];
        int len = 0;
        while(-1 != (len = is.read(b))) {
            os.write(b, 0, len);
        }
        os.flush(); //强制刷出
        //先打开的后关闭
        os.close();
        is.close();
    }

    /**
     * 文件夹的拷贝
     * @param src  源
     * @param dest   目的地
     */
    public static void CopyDir(String srcPath,String destPath) {
        File src = new File(srcPath);
        File dest = new File(destPath);

        if(src.isDirectory()) {
            dest = new File(dest,src.getName()); //destPath的子目录
            if( dest.getAbsolutePath().contains(src.getAbsolutePath())) {
                System.out.println("父目录不能拷贝到子目录中!");
                return;
            }
        }
        copyDirDetail(src,dest);
    }
    /**
     * 拷贝文件夹的细节
     * @param src
     * @param dest
     */
    public static void copyDirDetail(File src,File dest) {
        if(src.isFile()) {
            try {
                FileUtil.CopyFile(src, dest);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else if(src.isDirectory()) {  //如果是目录
            //确保路径存在
            dest.mkdirs();
            for(File temp : src.listFiles()) {
                copyDirDetail(temp, new File(dest,temp.getName())); //将src中的每一个拷贝到dest
            }
        }
    }
}
阅读更多
文章标签: IOOne
个人分类: JavaIO
上一篇IO总结之File文件总结
下一篇IO总结之ByteArray,DataOutput,Object(序列化),PrintStream
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭