InputStream&Reader笔记

InputStream

​ IputStream 字节输入流-抽象父类-不可实例化
​ FileIputStream 操作文件的字节输入流-普通子类
​ FileIputStream（File file）
​ FileIputStream(String pathName)
​ BufferedInputStream 子类
​ BufferedInputStream 高效字节输入流-普通子类
​ BufferedInputStream(InputStream in)
​ 由于抽向父类不可实例化，所以传入的参数是FIS(FileInputStream)
​ BIS（BufferedInputStream）缩写同

​ read()每次调用都会读取一个字节，如果读到了末尾，返回值是-1
TIPS:读取时需要设置变量保存读取的结果，否则数据读取不完全
​ 流使用完毕后必须关闭【.close】，而且必须写在finally{}中，确保关流操作时一定会执行的
​ finally{}是try-catch结构的第三个部分，这个部分不论是否捕获到异常，一定会执行

IputStream测试

package cn.tedu.file;

import java.io.*;

//本类用于练习字节输入流
public class TestIn {
    public static void main(String[] args) {
//        method();
        method2();
    }
    private static void method2() {
        InputStream in =null;
        try {
//            InputStream in = new BufferedInputStream(
//                    new FileInputStream(new File("D:\\read\\1.txt")));
            in = new BufferedInputStream
                    (new FileInputStream("D:\\read\\1.txt"));
            int b;
            while ((b=in.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {//关流操作卸载finally中
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void method() {
        //创建一个在本方法中生效的变量，注意手动初始化
        InputStream in = null;
//        InputStream in = new InputStream();
        try {
//            InputStream in = new FileInputStream(new File("D:\\read\\1.txt"));
            in = new FileInputStream("D:\\read\\1.txt");
            /*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
            int b;
            while ((b=in.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
            /*try-catch结构中的第三个部分：finally
            * 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符输入流

抽象父类：
Reader字符输入流-抽象父类-不可实例化
FileReader-文件字符输入流-普通子类
FileReader(File file)/FileReader(String pathName)
BufferedReader-高效字符输入流（缓冲字符输入流）-普通子类
BufferedReader(Reader in) 一般使用时传入的是Reader的子类

Reader测试

package cn.tedu.file;

import com.sun.org.apache.xerces.internal.dom.DeferredEntityReferenceImpl;

import java.io.*;

//本类用于测试字符流的读取
public class TestIn2 {
    public static void main(String[] args) {
//        method();
        method2();
    }
    private static void method() {
        Reader in = null;
//        Reader in =new Reader();
        try {
//                in = new FileReader(new File("D:\\read\\1.txt"));
                in = new FileReader("D:\\read\\1.txt");
//                System.out.println(in.read());
            int b;
            while((b=in.read())!=-1){
                System.out.println(b);
            }
            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void method2() {
        Reader in = null;
        try{
            in = new BufferedReader(new FileReader("D:\\read\\1.txt"));
            int c ;
            while((c=in.read())!=-1){
                System.out.println(c);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

OutputStream

​ OutputStream 字节输出流-抽象父类-不可实例化
​ FileOutputStream 操作文件的字节输出流-普通子类
​ FileOutputStream（File file）
​ FileOutputStream(String pathName)
​ BufferedOutputStream 子类
​ BufferedOutputStream 高效字节输出流-普通子类
​ BufferedOutputStream(InputStream out)
​ 由于抽象父类不可实例化，所以写出的参数是FOS(FileOutputStream)
​ BOS(BufferedOutputStream)
TIPS：append表示输出内容是否追加，默认为false不追加，改为true则追加

OutputStream测试

package cn.tedu.file;

import java.io.*;

//本类用于测试字节输出流
public class TestOut {
    public static void main(String[] args) {
//        method();
        method1();
    }

    private static void method() {
        OutputStream out = null;
        try {
            out = new FileOutputStream(new File("D:\\read\\1.txt"));
            out.write(45230);
            out.write(160);
            out.write(133);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void method1() {
       OutputStream out =null;
        try {
            out = new BufferedOutputStream(new FileOutputStream("D:\\read\\1.txt"));
            out.write(123);
            out.write(111);
            out.write(101);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();	
            }
        }
    }
}

字符输出流

抽象父类：
Writer字符输出流-抽象父类-不可实例化
FileWriter-文件字符输出流-普通子类
FileWriter(File file)/FileWriter(String pathName)
BufferedWriter-高效字符输出流（缓冲字符输出流）-普通子类
BufferedWriter(Writer out) 一般使用时传入的是Writer的子类

Writer测试

package cn.tedu.file;

import java.io.*;

//本类用于测试字符输出流
public class TestOut2 {
    public static void main(String[] args) {
//        method();
        method2();
    }

    private static void method() {
        FileWriter f =null;
        try {
            f = new FileWriter("D:\\read\\1.txt");
            f.write(97);
            f.write(98);
            f.write(99);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                f.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void method2() {
        BufferedWriter out =null;
        try {
            out = new BufferedWriter(new FileWriter("D:\\read\\1.txt",true));
            out.write(99);
            out.write(99);
            out.write(99);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}