Java I/O流（三）I/O流原理和分类 [输入流，输出流]

Java I/O流原理

　　1.I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等。

　　2.Java程序中，对于数据的输入/输出操作以 “流（stream）” 的方式进行

　　3.Java.io包下提供了各种 “流” 类和接口，用以获取不同类型的数据，并通过方法输入或输出数据

　　4.输入Input：读取外部数据（磁盘，光盘等存储设备的数据）到数据（内存）中

　　5.输出Output：将程序（内存）数据输出到磁盘，光盘等存储设备中

 

流的分类

　　1.按操作数据单位不同分为：字节流（8bit）二进制文件，字符流（按字符）文本文件【按编码不同，一个字符对应的字节数不同】

　　2.按数据流的流向不同分为：输入流，输出流

　　3.按流的角色不同分为：节点流，处理流/包装流

==Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象类派生的

==由这四个类派生出来的子类名称都是以其父类名作为子类名后缀

 

InputStream：字节输入流

InputStream抽象类是所有类字节输入流的超类

InputStream常用的子类

　　1.FileInputStream文件输入流

　　2.BufferedInputStream缓冲字节流

　　3.ObjectInoutStream对象字节输入流

 接下来我们测试FileInputStream，再d盘中创建hello.txt并赋内容hello world!!!，使用FileInputStream读取此文件，并输出文件内容

public class FileInputStream_ {
    public static void main(String[] args) {
        FileInputStream_ fileInputStream_ = new FileInputStream_();
        fileInputStream_.readFile01();
    }
    public void readFile01(){
        String filePath="d:\\hello.txt";
        int readData=0;
        FileInputStream fileInputStream = null;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //返回-1，表示读取完毕
            while ((readData=fileInputStream.read())!= -1){
                System.out.print((char)readData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

 输出结果：

 注意！！！！，如果我们这个文件里的内容是中文，那么在控制台打印的时候就会在中文部分出现乱码

因为我们使用的是字节流，以UTF-8为例，一个汉字占三个字节，如果以字节传输，那么汉字就会被拆分，输出出现乱码

现在我们将此方法优化：

 输出结果一样！这里我们用的read（buf）,一次读buf个字节，比第一个方法一个一个读取效率更高。

 

OutputStream：字节输出流

OutputStream抽象类是所有类字节输出流的超类

OutputStream常用的子类

　　FileOutPutStream文件输出流

接下来我们测试FileOutputStream,在d盘中world.txt文件中写入“hello world!!!”，如果文件不存在，会创建文件。

public class FileCopy_ {
    public static void main(String[] args) {
        FileCopy_ fileCopy = new FileCopy_();
        fileCopy.FileCopy();
    }
    public void FileCopy(){
        String srcFilePath = "d:\\picture.jpg";
        String desFilePath = "d:\\photo.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            int readLen = 0;
            byte[] buf = new byte[1024];
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(desFilePath);
            while((readLen = fileInputStream.read(buf)) !=-1){
                //一边读一边写，通过FileOutPutStream
                fileOutputStream.write(buf,0,readLen);//一定使用的是这个方法！！！
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileInputStream !=null){
                    fileInputStream.close();
                }
                if (fileOutputStream !=null){
                    fileOutputStream.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

 结果：

 

Reader：字符输入流

Reader抽象类是所有类字符输入流的超类

　　常用子类：InputStreamReader,BufferedReader,FileReader

 利用FileReader从story.txt读取内容，并显示：

public class FileReader_ {
    public static void main(String[] args) {
        FileReader_ fileReader_ = new FileReader_();
        fileReader_.readFile01();
        fileReader_.readFile02();
    }
    public void readFile01(){
        String filePath = "d:\\story.txt";
        FileReader fileReader = null;
        int data = ' ';
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read
            while ((data = fileReader.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public void readFile02(){
        String filePath = "d:\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8];
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read(buf),返回的是实际读取的字符数，如果是-1说明文件结束
            while ((readLen = fileReader.read(buf)) != -1){
                System.out.print(new String(buf,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 ===================================================

 输出结果：

 

Writer：字符输出流

Writer抽象类是所有类字符输出流的超类

　　常用子类：OutputStreamWriter,BufferedWriter,FileWriter

使用FileWriter将“我爱Java，非常爱”写入note.txt文件中。注意，使用FileWriter后，一定要关闭（close）或者刷新（flush）

否则，写入不到指定文件。同字节输入流，构造器后带true即为追加模式，不会覆盖。

 这里把要求忘了，在写入方法中更改即可。