一、IO简述

1.1、简述

IO:input/output

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中。

1.2、结构

字节流抽象类：

InputStream,OutputStream

字符流抽象类:

Reader、Writer。

ps:由这四4个派生出来子类名称都是以父类名作为子类名的后缀

如：InputStream的子类FileInputStream

如：Reader的子类FileReader;

1.3、分类

按操作数据方式为两种：字节流与字符流

按流向分：输入流，输出流

二、Writer

2.1、writer

写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

三、FileWriter与FileReader

3.1、FileWriter

package com.pb.io.demo1;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
/*
 * close:关闭流，会将流关闭，不能再使用
 * flush:flush刷新后，流可以继续使用，
 */
public class WriterDemo {

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        File file=null; //文件
        FileWriter fw=null; //字符输出流
        try {
            file=new File("d:/demo.txt");
            // fw=new FileWriter(file);//如果有这个文件就会覆盖
             //如果要追加到文件内容后面就使用true
             fw=new FileWriter(file,true);
             System.out.println("请输入内容，请输入 over后结束");
             String str=null; //接收输入的内容
             char [] buf=new char[1024];//定义缓冲区大小
             do{
                  str=input.nextLine();
                  buf=str.toCharArray();//转换为字符数组
                  fw.write(buf); //将字符数组写入
                  fw.flush();//刷新流
             }while(!str.equals("over"));
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //使用finally关闭流
            try {
                if(fw!=null)
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
         System.out.println("写入结束");

    }

}

3.2、FileReader

3.3示例 单个字符读取

package com.pb.io.demo1;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
 * 单个字符读取
 */

public class FileReaderDemo {

    public static void main(String[] args) {

        File file=null; //文件
        FileReader fr=null; //字符输入流

        try {
            file=new File("d:/demo.txt");
            fr=new FileReader(file);
            int  len=0;//接收读出内容

            while((len=fr.read())!=-1){
                System.out.println((char)len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                //关闭流
                if(fr!=null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

3.4、示例 数组方式读取 建议使用

package com.pb.io.demo1;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;

/*
 * 通过字符数组 读取
 */

public class FileReaderDemo {

    public static void main(String[] args) {

        File file=null; //文件
        FileReader fr=null; //字符输入流

        try {
            file=new File("d:/demo.txt");
            fr=new FileReader(file);
            //接收读出内容数组
            char [] buf=new char [1024]; //一般为1024的整数倍
            int len=0;
            while((len=fr.read(buf))!=-1){ //读取内容到字符数组
                System.out.println(new String(buf,0,len));//读有多少，就输出多少

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                //关闭流
                if(fr!=null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

四、完整和复制文件

4.1、字符输入流和字符输入流

package com.pb.io.demo1;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class FileWriterAndFileReader {

    public static void main(String[] args) {
        File file = new File("d:\\demo.txt");
        Output(file);
        input(file);
    }

    // 写入文件
    private static void Output(File file) {
        FileWriter fw = null;
        Scanner input = new Scanner(System.in);
        try {
            fw = new FileWriter(file, true);
            // 声明变量来接收用户输入
            System.out.println("请输入要写入的内容：输入over结束");
            String str = null;
            // 声明缓冲区
            char[] buf = new char[1024];
            do {
                str = input.nextLine(); // 接收用户输入
                buf = str.toCharArray(); // 转换为数组
                fw.write(buf, 0, buf.length);// 写入

            } while (!(str.equals("over")));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 读写文件
    private static void input(File file) {
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            // 定义字符数组
            char[] buf = new char[1024];// 缓冲区大小
            int len = 0;// 长度读取的字符个数
            while ((len = fr.read(buf)) != -1) {
                System.out.println(new String(buf, 0, len));
            }

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

4.2、复制文件

package com.pb.io.demo1;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 复制的原理 将一个文件存储到另一个文件中 边读边写 先读再写
 *
 */
public class CopyFileDemo {

    public static void main(String[] args) {
        File soure = new File("d:\\demo.txt");
        File objFile = new File("e:\\q.txt");
        copy1(soure, objFile);
        copy2(soure, objFile);
    }
    /*
     * 读一个复制一个
     */
    public static void copy1(File soure, File objFile) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            // 声明读，写流对象
            fr = new FileReader(soure);
            fw = new FileWriter(objFile,true);
            int ch = 0;
            int count=0;
            // 开始读
            while ((ch = fr.read()) != -1) {
                count++;
                System.out.println("正在读取"+count+"行");
                fw.write(ch);
                fw.write("\r\n"); //换行
                System.out.println("正在写入"+count+"行");
            }
            System.out.println("读写完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            try {
                if (fw != null)
                    fw.close();

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

    }
    /*
     * 数组方式读取复制
     */
    public static void copy2(File soure, File objFile) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            // 声明读，写流对象
            fr = new FileReader(soure);
            fw = new FileWriter(objFile,true);
            int ch = 0;
            int count=0;
            char [] buf=new char[1024];
            // 开始读
            while ((ch = fr.read(buf)) != -1) {
                count++;
                System.out.println("正在读取"+count+"行");
                fw.write(buf,0,ch);
                fw.write("\r\n"); //换行
                System.out.println("正在写入"+count+"行");
            }
            System.out.println("读写完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            try {
                if (fw != null)
                    fw.close();

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

    }

}