IO流 File 字节流 字符流

1.流的分类

1）按照方向分类：输入流 输出流 2）按照操作的单位分类：字节流 字符流 3）组合情况：字节输入流 字节输出流 字符输入流 字符输出流

2.字节输入流

1）抽象父级：InputStream–不能实例化 2）普通子级：

1. FileInputStream–操作文件的字节输入流 构造方法参数：File file / String pathname

2. BufferedInputStream–高效字节输入流 构造方法参数：InputStream,但无法创建抽象父级对象，所以传的是FileInputStream

3.字节输出流

1）抽象父级：OutputStream–不能实例化 2）普通子级：

1. FileOutputStream–操作文件的字节输出流 构造方法参数：File file / String pathname 注意：默认存在一个参数boolean append,默认值为false,也就是覆盖输出 如果将FileOutputStream构造函数的第2个参数appned设置为true,就会实现追加输出的效果

2. BufferedOutputStream–高效字节输出流 构造方法参数：OutputStream,但无法创建抽象父级对象，所以传的是FileOutputStream

4.字符输入流

1）抽象父级：Reader 2）普通子级：

1. FileReader–操作文件的字符输入流 构造方法参数：File file /String filename

2. BufferedReader–高效字符输入流 构造方法参数：Reader,但无法创建抽象父级对象，所以传的是FileReader

5.字符输出流

1）抽象父级：Writer 2）普通子级：

1. FileWriter–操作文件的字符输出流 构造方法参数：File file /String filename 注意：默认存在一个参数boolean append,默认值为false,也就是覆盖输出 如果将FileWriter构造函数的第2个参数appned设置为true,就会实现追加输出的效果

2. BufferedWriter–高效字符输出流 构造方法参数：Writer,但无法创建抽象父级对象，所以传的是FileWriter

package cn.tedu.file;
import java.io.*;

/*本类用于练习字节输入流*/
public class TestIn {
    public static void main(String[] args) {
       // method();//字节流的读取
        method2();
    }

    private static void method2()  {
        //定义一个在本方法都生效的局部变量，注意手动初始化，引用类型的默认值是null。
        BufferedInputStream in=null;
        //1.创建流对象
      //InputStream s =
              //new BufferedInputStream(new FileInputStream("D:\\ready\\1.txt"));
        try {
           in =
                    new BufferedInputStream(new FileInputStream(new File("D:\\ready\\1.txt")));
            //2.使用流对象
            int b;
            while ((b=in.read())!=-1){//将本轮循环读到的数据赋值给b，只要不是-1，继续循环
                System.out.println(b);//打印本轮读到的数据
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流对象
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    //本方法用于测试字节流的读取
    private static void method() {
        //1.创建流对象，注意InputStreamd是抽象父类，不可以实例化
        //Alt+Shift+向上，向上移动本行代码
        //File file = new File("D:\\ready\\1.txt");
       // String path="D:\\ready\\1.txt";
        /**
         * 创建一个在本方法中都生效的局部变量
         * 注意手动初始化，引用类型默认值为null；
         */
        InputStream in2 =null;
        try {
            //InputStream in=new FileInputStream(new File("D:\\ready\\1.txt"));
             in2=new FileInputStream("D:\\ready\\1.txt");
            //2.使用流对象：读取指定文件中的数据
            /*read()每次调用都会读取一个字节，如果读到了文件数据的末尾，返回-1
            * 这个方法的返回值类型是int，所以会查找指定字符对应的编码打印出来*/
//            System.out.println(in2.read());
//            System.out.println(in2.read());
//            System.out.println(in2.read());
//            System.out.println(in2.read());
//            System.out.println(in2.read());

            //2.2优化代码，使用循环读取文件
            //定义变量，用来保存本次读到的数据
            //读取数据，只要读到的数据不等于-1，说明还有数据，继续循环
            int b;
            while ((b=in2.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();//默认写法：打印错误信息
        }finally {
            /*finally{}代码块是try-catch结构的第三个部分
            * 这部分不论是否捕获到异常，都一定会执行，所以常用来关流操作*/
            //3.释放资源，流资源用完必须释放
            try {
                in2.close();//关流,显示不能创建局部变量，把变量提到外面，并且注意初始化。
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

package cn.tedu.file;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*本类用于测试字符输入流reader的读取操作*/
public class TestIn2 {
    public static void main(String[] args) {
       //method();//用于测试普通字符流
        Method2();//用于测试高效字符流
    }
    private static void Method2() {
        BufferedReader in2 = null;
      //  BufferedReader in = new BufferedReader(new FileReader("D:\\ready\\1.txt"));
        try {
           in2 = new BufferedReader(new FileReader("D:\\ready\\1.txt"));

           while (true){
               int b=in2.read();
               if(b==-1){
                   break;
               }
               System.out.println(b);
           }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                in2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //本方法用于测试普通字符输入流的读取操作
    private static void method() {
        FileReader in2 = null;
        try {
            //1.创建流对象
            in2 = new FileReader("D:\\ready\\1.txt");
            //  FileReader in=new FileReader(new File("D:\\ready\\1.txt"));
            //使用流
            int b;
            while ((b = in2.read()) != -1) {
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //关流
                in2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package cn.tedu.file;
import java.io.*;
/**
 * 本类用于联系字节输出OutputStream
 */
public class TestOut {
    public static void main(String[] args) {
//        nethod1();//用于测试普通字节输出流
        method2();//用来测试高效字节输出流
    }

    private static void method2()  {
        BufferedOutputStream out=null;
        try {
            //1.1创建高效字节输出流对象--覆盖输出
//            BufferedOutputStream o1=
//                    new BufferedOutputStream(new FileOutputStream(new File("D:\\ready:\\1.txt")));
            //            BufferedOutputStream o2=
//                    new BufferedOutputStream(new FileOutputStream(("D:\\ready:\\1.txt")));
            //1.2创建高效字节输出流对象--追加输出
            //        BufferedOutputStream out =
//                new BufferedOutputStream(new FileOutputStream(new File("D:\\ready\\1.txt"), true));
            out=
                    new BufferedOutputStream(new FileOutputStream("D:\\ready\\1.txt", true));
            out.write(100);
            out.write(97);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //本方法用于测试普通字节输出流FileOutputStream
    private static void nethod1() {
        FileOutputStream out=null;
        try {
            //1.创建对象
//            FileOutputStream out= new FileOutputStream(new File("D:\\ready\\2.txt"));//覆盖输出
//            out = new FileOutputStream("D:\\ready\\1.txt");//覆盖输出
           // out=new FileOutputStream(new File("D:\\ready\\1.txt"), true);//追加输出
            out=new FileOutputStream("D:\\ready\\1.txt", true);//追加输出
            //2.使用流对象
            out.write(100);//对应ASCII码表中的
            out.write(100);
            out.write(100);
            //文件中是aaa
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.file;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 本类用于练习字符输出流writer
 */
public class TestOut2 {
    public static void main(String[] args) {
        // method1();//用于测试普通字符输出流
        method2();//用于测试高效字符输出流
    }

    //本方法用于测试高效字符输出流
    private static void method2() {
        BufferedWriter out = null;
        try {
            //       out = new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt")));
//            out=new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt")));
//            out=new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt"), true));
//            out=new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt"), true));
            out = new BufferedWriter(new FileWriter("D:\\ready\\1.txt", true));
            out.write("秦晓燕是仙女");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    //本方法用于测试普通字符输出流
    private static void method1() {
        FileWriter out = null;
        try {
//            //1.1创建字符输出流覆盖输出
//             out = new FileWriter("D:\\ready\\1.txt");
//             out=new FileWriter(new File("D:\\ready\\1.txt"));
//             //1.2创建字符输出流对象---追加输出
//             out=new FileWriter(new File("D:\\ready\\1.txt"), true);
            out = new FileWriter("D:\\ready\\1.txt", true);
            out.write(100);
            out.write("h");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

package cn.tedu.file;
import java.io.*;
import java.util.Scanner;

/*本类用于复习文件复制综合案例*/
public class TestCopyFile {
    public static void main(String[] args) {
        //1.提示并接受用户输入的两个路径
        System.out.println("请输入源文件路径");
        String f = new Scanner(System.in).nextLine();//被复制的那个文件
        System.out.println("请输入新文件路径：");
        String t = new Scanner(System.in).nextLine();//复制好的新文件

        //2.调用创建好的自定义方法完成文件复制
       // ZFCopy(f, t);//用字符流完成文件的复制案例
        ZJCopy(f, t);//用字节流完成文件的复制案例

    }

    //利用字节流完成文件复制案例
    private static void ZJCopy(String f, String t) {
        InputStream in=null;
        OutputStream out=null;
        try {
            in=new BufferedInputStream(new FileInputStream(f));
            out= new BufferedOutputStream(new FileOutputStream(t));
            //4.1定义变量用来保存读到的数据
            int b;
            //4.2循环读取源文件中的数据，只要不是-1，说明还有数据循环继续
            while ((b=in.read())!=-1){
                //4.3将读到的数据写入到新文件中
                out.write(b);
            }
            System.out.println("恭喜您，复制成功");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("很遗憾，复制失败");
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //用字符流完成文件的复制案例,不可以复制图片
    private static void ZFCopy(String f, String t) {
        //1.定义在整个方法中都生效的局部变量，注意手动初始化，默认值为null;
        Reader in=null;
        Writer out=null;
        //2.由于代码可能会发生异常，所有需要编写try-catch-finally结构
        try {
            //3.1创建高效字符输入流对象
            in=new BufferedReader(new FileReader(f));
            //3.2创建高效字符输出流对象
            out=new BufferedWriter(new FileWriter(t));
            //4.拿到流对象以后，就可以使用流对象来完成业务了
            //4.1定义变量用来保存读到的数据
            int b;
            //4.2循环读取源文件，直到返回值为-1，说明没有数据了，再结束循环
            while ((b=in.read())!=-1){
               out.write(b);
            }
            System.out.println("恭喜您，文件复制成功");
        }catch (Exception e){
            System.out.println("很抱歉，文件复制失败");
            e.printStackTrace();
        }finally {
            /**
             * 关流是有顺序的：如果有多个流，最后创建的流最先关闭
             * 多余关流语句需要各自try-catch
             */
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}