算法学习之路（五）——IO类的总结

之前内容：

算法学习之路（一）—— File

算法学习之路（二）—— 字节

算法学习之路（三）——字符

算法学习之路（四）——缓冲区

1. 总结：

1.InputStream、OutputStream

处理字节流的抽象类

InputStream 是字节输入流的所有类的超类,一般我们使用它的子类,如FileInputStream等.

OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等.

2.InputStreamReader OutputStreamWriter

处理字符流的抽象类

InputStreamReader 是字节流通向字符流的桥梁,它将字节流转换为字符流.

`InputStreamReader `是字节流通向字符流的桥梁：
它使用指定的`charset `读取字节并将其解码为字符。
它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。 

OutputStreamWriter是字符流通向字节流的桥梁，它将字符流转换为字节流.

OutputStreamWriter 是字符流通向字节流的桥梁：
可使用指定的 charset 将要写入流中的字符编码成字节。
它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

作用： 用于转码,再构造函数中可以指定编码

3.BufferedReader BufferedWriter

BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，readLine读取一个文本行，

从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

BufferedWriter 由Writer 类扩展而来，提供通用的缓冲方式文本写入， newLine使用平台自己的行分隔符，

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

InputStream能从來源处读取一個一個byte,
所以它是最低级的。

练习：

1. 文件复制

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        String path = "D:\\java\\git\\repository\\lanqiao\\src\\a.txt";
        String copyPath = "D:\\java\\git\\repository\\lanqiao\\src\\copya.txt";
        File from = new File(path);//文件或文件夹对象
        File to = new File(copyPath);//文件或文件夹对象
        
        Reader reader = new FileReader(from);//读取文件对象
        BufferedReader br = new BufferedReader(reader);//套一层缓冲区

        Writer writer = new FileWriter(to);//写文件对象
        BufferedWriter bw = new BufferedWriter(writer);//套一层缓冲区
        
        String line;
        if(to.exists()){
            to.delete();
        }
        to.createNewFile();
        //从目标文件读取
        while((line = br.readLine()) != null){
            bw.write(line+'\n');
        }
        bw.flush();//刷新一下
        br.close();
        bw.close();
    }
}

结果：

2. BufferedReader与 InputStream 效率对比
   《老人与海》文件大小90K左右
   
   代码：

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        String path = "D:\\java\\git\\repository\\lanqiao\\src\\a.txt";
        File file = new File(path);
        InputStream is = new FileInputStream(file);

        Reader reader = new FileReader(file);
        BufferedReader br = new BufferedReader(reader,1024);
        int res;
        long ago = System.currentTimeMillis();
        while((res = is.read()) != -1){
            //System.out.println((char)res);
        }
        long now = System.currentTimeMillis();
        System.out.println(now - ago +"ms");

        ago = System.currentTimeMillis();
        while((res = br.read()) != -1){
           // System.out.println((char)res);
        }
        now = System.currentTimeMillis();
        System.out.println(now - ago +"ms");
    }
}

结果：

所以：

算法数据输入

推荐使用这种的输入，读取的数据量大的时候，速度更快。

static class InputReader {
        private BufferedReader bf = null;
        private StringTokenizer stz = null;
        public InputReader() {
            bf = new BufferedReader(new InputStreamReader(System.in),32*1024);
        }
        public boolean hasNext() {
            while(stz == null || !stz.hasMoreTokens()) {
                try {
                    stz = new StringTokenizer(bf.readLine());
                } catch (IOException e) {
                    return false;
                }
            }
            return true;
        }
        public String next() {
            if(hasNext()) {
                return stz.nextToken();
            }
            return null;
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

后面开始正式的算法学习