Java学习笔记--IO流的操作

IO流

IO流分类

        字节流：
            InputStream
                FileInputStream
                BufferedInputStream
            OutputStream
                FileOutputStream
                BufferedOutputStream

        字符流：
            Reader
                FileReader
                BufferedReader
            Writer
                FileWriter
                BufferedWriter

字节流操作中文数据不是特别的方便，所以就出现了字符流。字符流 = 字节流 + 编码表。

|--字节流
            |--字节输入流
                InputStream
                    int read():一次读取一个字节
                    int read(byte[] bys):一次读取一个字节数组

                    |--FileInputStream
                    |--BufferedInputStream
            |--字节输出流
                OutputStream
                    void write(int by):一次写一个字节
                    void write(byte[] bys,int index,int len):一次写一个字节数组的一部分

                    |--FileOutputStream
                    |--BufferedOutputStream
|--字符流
            |--字符输入流
                Reader
                    int read():一次读取一个字符
                    int read(char[] chs):一次读取一个字符数组

                    |--InputStreamReader
                        |--FileReader
                    |--BufferedReader
                        String readLine():一次读取一个字符串
            |--字符输出流
                Writer
                    void write(int ch):一次写一个字符
                    void write(char[] chs,int index,int len):一次写一个字符数组的一部分

                    |--OutputStreamWriter
                        |--FileWriter
                    |--BufferedWriter
                        void newLine():写一个换行符

                        void write(String line):一次写一个字符串

IO流中的编码问题
        A:OutputStreamWriter
            OutputStreamWriter(OutputStream os):默认编码，GBK
            OutputStreamWriter(OutputStream os,String charsetName):指定编码。
        B:InputStreamReader
            InputStreamReader(InputStream is):默认编码，GBK
            InputStreamReader(InputStream is,String charsetName):指定编码

IO流练习

复制文本的五种方式

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


public class CopyFileDemo {
    /**
     * 复制文本练习
     * 
     * 数据源：
     *      src:   g:\\a.txt
     * 目的源：
     *      des:   h:\\b.txt
     * 因为是文本类型，故使用字符流
     * 字符流操作类有：
     *      输入流Reader:
     *          InputStreamReader
     *              FileReader
     *          BufferedReader ->readLine()
     *      输出流Writer:
     *          OutputStreamWriter
     *              FileWriter
     *          BufferedWriter ->newLinew()

     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        String srcPath="g:\\a.txt";
        String desPath="h:\\b.txt";
//      method1(srcPath,desPath);
//      method2(srcPath,desPath);
//      method3(srcPath,desPath);
//      method4(srcPath,desPath);
        method5(srcPath,desPath);//较为常用
    }

    /**
     * 基本字符流操作，一次读写一个字符
     * @param srcPath
     * @param desPath
     * @throws IOException
     */
    private static void method1(String srcPath, String desPath) throws IOException {
        FileWriter fw=new FileWriter(desPath);
        FileReader fr=new FileReader(srcPath);
        int ch=0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        fr.close();
        fw.close();

    }
    /**
     * 基本字符流操作，一次读写一个字符数组
     * @param srcPath
     * @param desPath
     * @throws IOException
     */
    private static void method2(String srcPath, String desPath) throws IOException {
        FileReader fr=new FileReader(srcPath);
        FileWriter fw=new FileWriter(desPath);

        char[] chs=new char[1024];
        int len;
        while((len=fr.read(chs))!=-1){
            fw.write(chs, 0, len);
        }
        fr.close();
        fw.close();
    }

    /**
     * 字符缓存流，一次读写一个字符
     * @param srcPath
     * @param desPath
     * @throws IOException
     */
    private static void method3(String srcPath, String desPath) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader(srcPath));
        BufferedWriter bw=new BufferedWriter(new FileWriter(desPath));

        int ch=0;
        while((ch=br.read())!=-1){
            bw.write(ch);
        }
        br.close();
        bw.close();

    }
    /**
     * 字符缓存流，一次读写一个字符数组
     * @param srcPath
     * @param desPath
     * @throws IOException 
     */
    private static void method4(String srcPath, String desPath) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader(srcPath));
        BufferedWriter bw=new BufferedWriter(new FileWriter(desPath)); 
        char[] chs =new char[1024];
        int len;
        while((len=br.read(chs))!=-1){
            bw.write(chs, 0, len);
        }
        br.close();
        bw.close();
    }
    /**
     * 字符缓存流，一次读写一个字符串
     * 较为常用
     * @param srcPath
     * @param desPath
     * @throws IOException
     */
    private static void method5(String srcPath, String desPath) throws IOException {
        BufferedWriter bw=new BufferedWriter(new FileWriter(desPath));
        BufferedReader br=new BufferedReader(new FileReader(srcPath));

        String line;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();


    }

}

复制图片的四种方式

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

public class CopyImageDemo {
    /**
     * 复制图片
     * 
     * 因为不是文本文件，故用字节流
     * 
     * 输入流：
     *      InputStream
     *          FileInputStream
     *          BufferedInputStream
     * 输出流：
     *      OutputStream
     *          FileOutputStream
     *          BufferedOutputStream
     * 
     * 数据源：
     *      src:    g:\\a.jpg
     * 目的源：
     *      des:    h:\\b.jpg
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        File srcFile=new File("g:\\a.jpg");
        File desFile=new File("h:\\b.jpg");
//      method1(srcFile,desFile);
//      method2(srcFile,desFile);
//      method3(srcFile,desFile);
        method4(srcFile,desFile);//较为常用
    }

    /**
     * 基本字节流操作,一次读写一个字节
     * @param srcFile
     * @param desFile
     * @throws IOException 
     */
    private static void method1(File srcFile, File desFile) throws IOException {
        FileInputStream fis=new FileInputStream(srcFile);
        FileOutputStream fos=new FileOutputStream(desFile);
        int len;
        while((len=fis.read())!=-1){
            fos.write(len);
        }
        fis.close();
        fos.close();

    }
    /**
     * 基本字节流操作，一次读写一个字节数组
     * @param srcFile
     * @param desFile
     * @throws IOException
     */
    private static void method2(File srcFile, File desFile)throws IOException {
        FileInputStream fis=new FileInputStream(srcFile);
        FileOutputStream fos=new FileOutputStream(desFile);
        byte[] bys=new byte[1024];
        int len;
        while((len=fis.read(bys))!=-1){
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }
    /**
     * 字节缓存流，一次读写一个字节
     * @param srcFile
     * @param desFile
     * @throws IOException
     */
    private static void method3(File srcFile, File desFile)throws IOException {
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(desFile));

        int len;
        while((len=bis.read())!=-1){
            bos.write(len);
        }
        bis.close();
        bos.close();
    }

    /**
     * 字节缓存流，一次读写一个字节数组
     * 较为常用
     * @param srcFile
     * @param desFile
     * @throws IOException
     */
    private static void method4(File srcFile, File desFile) throws IOException{
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(desFile));
        int len;
        byte[] bys=new byte[1024];
        while((len=bis.read(bys))!=-1){
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
}

集合数据写到文本文件中

public class ArrayListToFile {
    public static void main(String[] args) throws IOException {
        ArrayList<String> mList=new ArrayList<String>();

        mList.add("hello");
        mList.add("world");
        mList.add("java");
        BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));
        for (String s : mList) {
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }

}

把文本数据读取到集合中

public class FileToArrayList {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("a.txt"));
        String len;
        ArrayList<String> mlist=new ArrayList<String>();
        while((len=br.readLine())!=null){
            mlist.add(len);
        }
        br.close();
        for (String s : mlist) {
            System.out.println(s);
        }
    }
}

复制单级文件夹

public class CopyFolderDemo {
    /*
     * 需求：复制单级文件夹
     * 
     * 数据源：g:\\c 目的地：g:\\e
     * 
     * 分析： A:封装目录
     *       B:获取该目录下的所有文件的File数组 
     *       C:遍历该File数组，得到每一个File对象 
     *       D:把该File进行复制
     */
    public static void main(String[] args) throws IOException {

        File srcFolder = new File("g:\\c");
        File desFolder = new File("g:\\e");

        // 文件夹不同于文件，文件不存在的话会自动创建
        // 文件夹不会自动创建
        if (!desFolder.exists()) {
            desFolder.mkdir();
        }
        File[] files = srcFolder.listFiles();
        for (File file : files) {
            BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream(file));
            BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream(new File(desFolder, file.getName())));
            byte[] bys=new byte[1024];
            int len=0;
            while((len=bis.read(bys))!=-1){
                bos.write(bys, 0, len);
            }
            bis.close();
            bos.close();
        }
    }
}

复制指定目录后缀名文件到另外一个文件夹

/*
 * 需求：复制指定目录下的指定文件，并修改后缀名。
 * 指定的文件是：.txt文件。
 * 指定的后缀名是：.java
 * 指定的目录是：e
 * 
 * 数据源：g:\\c\\
 * 目的地：g:\\e\\
 * 
 * 分析：
 *      A:封装目录
 *      B:获取该目录下的java文件的File数组
 *      C:遍历该File数组，得到每一个File对象
 *      D:把该File进行复制
 *      E:在目的地目录下改名
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        File srcFile=new File("g:\\c");
        File desFile=new File("g:\\e");
        if (!desFile.exists()) {
            desFile.mkdir();
        }
        File[] files = srcFile.listFiles(new FilenameFilter() {

            public boolean accept(File dir, String name) {//dir="g:\c";
                return new File(dir,name).isFile()&&name.endsWith(".txt");
            }
        });

        for (File file : files) {
            BufferedInputStream bis =new BufferedInputStream(new FileInputStream(file));

            //方法一
//          BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File(desFile,file.getName().replace(".txt", ".java"))));
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File(desFile,file.getName().replace(".txt", ".java"))));
            byte[] bys=new byte[1024];
            int len;
            while((len=bis.read(bys))!=-1){
                bos.write(bys, 0, len);
            }
            bos.close();
            bis.close();
        }
        File[] files2 = desFile.listFiles();
        for (File file : files2) {
            String name = file.getName();
            name.replace(".txt", ".java");
            file.renameTo(new File(desFile,name));
        }


    }
}

#