Java IO流基础总结（一）-File字符字节流、Buffered字符字节流

1. 概述

注意判断“流”的方向的主体是程序本身，也就是说：

• 将数据从外界传递到程序内使用，是输入流，对应Reader和InputStream；
• 将数据从程序输出到外界，是输出流，对应Writer和OutputStream；

四个抽象类：
字符流：Reader，Writer
字节流：InputStream，OutputStream

2. InputStream/OutputStream/Reader/Writer

这四个均为抽象类，不能直接用来读取数据！

//读取一个字节并以整数形式返回（0~255）
//到达输入流末尾，返回-1（作为输入结束的标志来判断）
int read() throws IOException
int read(byte[] buffer)//常用，设定一个缓冲区
int read(byte[] buffer, int offset, int length)
void close();//关闭源，释放内存资源 

• 缓冲的意义：减少对内存的访问次数，提高效率，延长内存寿命（对硬盘、网络的读写同理）
  
  • 通常使用字节数组作为缓冲区；
• OutputStream输出：需要在关流之前使用void flush() 方法，将缓冲区数据写出到目的地；
• 以上方法，字符流都有；

3. 具体的流：

所有的具体的流的类名，都是以上述四个抽象类为结尾的，代表了数据传输的方向并区分字符流和字节流；前面部分基本代表了数据的源（数据从哪里来？），或者数据装饰方法

分为两类：节点流(直接传输数据不做处理)和装饰流（对数据进行格式处理或者缓冲处理）；

3.1. 使用FileInputStream类：

从硬盘中读取文件（可以是各种数据类型，不仅限于文本），以字节流的形式读取，在控制台上输出；

import java.io.*;
public class FileInputStreamClass {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\ServerDemo.java");
        } catch (FileNotFoundException e) {
            throw new RuntimeException("File Not Found!");
        }
        try {
            int getByte = 0,num = 0;
            while ((getByte = fis.read())!=-1) {
                System.out.print((char)getByte);
                num++;
            }
            System.out.println("The number of Bytes:"+ num);
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally{
            if(fis!=null)
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：
1. InputStream类中的read()方法返回读取到的字节的整型值，需要强转回字符类型，输出；
2. 局限性：对于非英文字符（例如需要两个字节表示的汉字），使用(char)强转回来时会出现乱码；

3.2.使用FileOutputStream类

import java.io.*;

public class FileOutputStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null; 
        FileOutputStream fos = null;
        try {
            fis= new FileInputStream("D:\\ServerDemo.java");
            fos= new FileOutputStream("D:\\Copy.java");
        } catch (FileNotFoundException e) {
            System.out.println("File Not Found!");
            System.exit(-1);
        }
        try {
            int b = 0,num = 0;
            while((b = fis.read())!=-1){
                fos.write(b);//将read()方法返回的int字节写入fos流
                num++;
            }
            System.out.println("The number of Bytes:"+ num);
        } catch (IOException e) {
            throw new RuntimeException("IOException!");
        } finally {
            if(fis!=null)
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(fos!=null)
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

3.3. 使用FileReader和FileWriter类复制包含汉字的文件

显然，Reader和Writer方法不能用来操作图片，或者多媒体文件

public class FileReaderFileWriterCopy {
    public static void main(String[] args) {
        FileReader fileIn = null;
        FileWriter fileOut = null;
        try {
            fileIn = new FileReader("d:/ServerDemo.java");
            fileOut = new FileWriter("d:/fileCopy.jpg");
            int b = 0;
            while((b = fileIn.read())!=-1){
                fileOut.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileIn!=null)
                try {
                    fileIn.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if (fileOut!=null)
                try {
                    fileOut.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

3.4. 装饰流（又称处理流）-缓冲流（重要，重点理解）

以“Buffered开头+四种抽象类名”出现的流，必须用来装饰节点流：
构造方法：

• BufferedReader(Reader in)/BufferedReader(Reader in, int sz)
• BufferedWriter(Writer out)
• BufferedInputStream(InputStream in)
• BufferedOutputStream(OutputStream out)

注意缓冲流的特长：
1. BufferedReader提供了String readLine()方法用于读取一行字符串（以换行符为结束标记！很重要！）
2. BufferedWriter提供了void newLine()方法用于写入一个换行符；
3. 对于输出的缓冲流，数据会在内存中缓存，使用flush()方法将内存缓冲区中的数据立刻写出；
4. BufferedInputStream，BufferedOutputStream常常使用字节数组作为缓冲区；
5. 有一点经常会忘记：BufferedInputStream是没有readLine的方法的，因为字节流常常用来处理图片多媒体等文件，没有换行标记！通常可以直接使用read()方法

import java.io.*;
public class BufferedDemo {
    public static void main(String[] args) {
        BufferedReader bufIn = null;
        BufferedWriter bufOut = null;
        try {
            bufIn = new BufferedReader(new FileReader("D:/ServerDemo.java"));
            bufOut = new BufferedWriter(new FileWriter("D:/BufferedDemo.java"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
        /*关键代码*************************************************************/
            String line;
            while((line = bufIn.readLine())!=null){ 
            //读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行；
            //readLine返回值：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。
                bufOut.write(line);
                bufOut.newLine();//必须加入，不然没有换行符
            }
            bufOut.flush();
        /*关键代码*************************************************************/
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
        if(bufIn!=null)
            try {
                bufIn.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        if(bufIn!=null)
            try {
                bufIn.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
}

相对应的BufferedInputStream方法，可以直接使用read方法读入，并且立刻读出到输出流中；也可以定义一个字节数组作为缓冲区；

import java.io.*;

public class BufferedInputStreamDemo {
    public static void main(String[] args) {
        BufferedInputStream bufIn = null;
        BufferedOutputStream bufOut = null;
        try {
            bufIn = new BufferedInputStream(new FileInputStream("D:/demo.jpg"));
            bufOut = new BufferedOutputStream(new FileOutputStream("D:/BufferedDemo.jpg"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            int len = 0;
            byte[] b = new byte[1024];//设定1kB的缓冲区
            while((len = bufIn.read(b))!=-1){ 
                //从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。 
                //int read(byte[] b,int offset, int length)读取的字节数；如果已到达流末尾，则返回 -1。
                //在返回-1之前，会记录最后一次字节数组的长度并进行一次循环
                bufOut.write(b,0,len);
                bufOut.flush();//清空数组
            /*
            int len;
            while((len = bufIn.read())!=-1){//注意！此时返回的不是长度，而是从输入缓冲流中读取的一个字节
                bufOut.write(len);
                bufOut.flush();
            }

            */
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
        if(bufIn!=null)
            try {
                bufIn.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        if(bufIn!=null)
            try {
                bufIn.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
}