Java IO基础

Java IO流

• IO流用来处理设备之间的数据传输
• Java数据操作是通过流的方式
• Java用于操作流的对象在IO包中
• 流按操作数据分为两种：字节流和字符流
• 流按流向分为：输入流和输出流。

字符流： 适应编码表 GBK， unicode， utf-8 。。。

IO流常用基类

• 字节流的抽象基类
  
  • InputStream, OutputStream
• 字符流的抽象基类
  
  • Reader, Writer
• 注： 由这四个派生出来的子类名称都是以其父类名作为子类名的后缀。
  
  • 如： InputStream的子类FileInputStream
  • 如： Reader 的子类FileReader

字符流

public class FileWriteIO {
    public static void main(String[] args) {
        //创建一个FileWrite对象， 该对象一被初始化就必须要明确被操作的文件
        //而且该文件会被创建到指定目录下，如果该目录已有同名文件，将会被覆盖。
        FileWriter fw = null;
        try {
            fw = new FileWriter("demo.txt");
            //调用write方法，将字符串写入到流中
            fw.write("aaaaa"); 
            //调用flush方法刷新对象中缓冲中的数据
            //将数据刷新到目的地中
            fw.flush();
            System.out.println("aaaa");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                //关闭流资源， 关闭之前会刷新一次缓冲中的数据
                //将数据刷新到目的地中
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class FileReadIO {

    public static void main(String[] args) {
        FileReader fr = null;
        try {
            //创建一个文件读取流对象
            fr = new FileReader("demo.txt");
            //调用读取流对象的read方法
            //read(): 一次读取一个字符, 而且自动往下读
            //read(char[] char): 字符数组读取
            char[] ch = new char[20];
            int num = 0;
            while((num = fr.read(ch)) != -1)  {
                System.out.println("ch = " + new String(ch, 0, num));
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

拷贝文件：

public static void copy1() {
        FileWriter fw = null;
        FileReader fr = null;
        try {
            fw = new FileWriter("copy.java");
            fr = new FileReader("demo.txt");
            int len = 0;
            char[] buf = new char[1024];
            while((len = fr.read(buf)) != -1) {
                fw.write(buf, 0, len);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException("读写失败");
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

字符流的缓冲区

• 缓冲区的出现提高了对数据的读写效率
• 对应类
  
  • BufferedWriter
  • BufferedReader
• 缓冲区要结合流才可以使用
• 在流的基础上对流的功能进行了增强

字节流

基类 ： FileInputStream ， FileOutputStream, BufferedInputStream, BufferedOutputStream

转换流

• InputStreamReader： 字节流通向字符流
• OutputStreamWriter: 是字符流通向字节流的桥梁

public static void main(String[] args) throws Exception{
        //InputStream in = System.in;
        //InputStreamReader isr =  new InputStreamReader(in);

        //缓冲区
        //BufferedReader bufr = new BufferedReader(isr);
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bbb.java")));
        String line = null;
        try {
            while((line=bufr.readLine()) != null) {
                //System.out.println(line.toUpperCase());
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            bw.close();
        }
    }

流操作的基本规律

最痛苦的就是流对象有很多，不知道该用哪个

1. 明确源和目的
   
   • 源： 输入流， InputStream Reader
   • 目的： OutputStream , Writer
2. 操作的数据是否是纯文本
   
   • 是： 字符流
   • 不是： 字节流
3. 当体系明确后，在明确要使用哪个护体对象
   
   • 通过设备来进行区分
   • 源设备： 内存， 硬盘， 键盘
   • 目的设备： 内存，硬盘， 控制台