JavaIO流： IO流原理和流的分类

目录

IO流原理

流的分类 ：

四个抽象类：

（1）字节流：

 FileInputStream：字节输入流

 FileOutputStream：字节输出流：

FileInputStream 和 FileOutputStream小案例：copy文件

 （2）字符流

FileReader：

FileWriter:

---

IO流原理

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

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

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

4.输入input: 读取外部数据(磁盘、 光盘等存储设备的数据)到程序(内存)中。

5.输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中

流的分类 ：

按操作数据单位不同分为:字节流(8 bit),字符流(按字符)

按数据流的流向不同分为:输入流，输出流

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

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

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

四个抽象类：

（1）字节流：

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

InputStream 常用的子类：

1. FilelnputStream:文件输入流

2. BufferedInputStream:缓冲字节输入流

3. ObjectlnputStream:对象字节输入流

 FileInputStream：字节输入流

输入流读取hello.txt文件内容：

直接看代码： 

package com.io.inputSteam;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {

    }
    /**
     * 单个字节的读取
     * 字节流
     */
    @Test
    public void readFile01(){
//        获取文件路径
        String filePath = "e:\\hello.txt";
//        readData 存放数据
        int readData = 0;
//        扩大fileInputStream作用域，用于关闭资源
        FileInputStream fileInputStream =null;
        try {
             fileInputStream = new FileInputStream(filePath);
//             从该输入流读取一个字节的数据，如果没有输入可用，此方法停止
//            结果返回-1，表示读取完毕
            while ((readData=fileInputStream.read())!=-1){
                System.out.print((char)readData);
            }
            System.out.println("读取成功");
        } catch (IOException e) {
            System.out.println("读取失败");
        }
//       finally关闭资源
        finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                System.out.println("关闭成功");
            }
        }

    }

    /**
     * 使用read(byte[] b),多字节读取
     */
    @Test
    public void readFile02(){
//        获取文件路径
        String filePath = "e:\\hello.txt";
//        readData 存放数据
        int readData = 0;
        byte [] buf = new byte[8];//一次读取8个字节
        int readLen = 0;
//        扩大fileInputStream作用域，用于关闭资源
        FileInputStream fileInputStream =null;
        try {
            fileInputStream = new FileInputStream(filePath);
            while((readLen=fileInputStream.read(buf))!=-1){
                System.out.print(new String(buf,0,readLen));
            }
            System.out.println("读取成功");
        } catch (IOException e) {
            System.out.println("读取失败");
        }
//       finally关闭资源
        finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                System.out.println("关闭成功");
            }
        }
    }
}

两种方法：一种是单字节读取，一个一个读，第二种是一次多个读取。

运行结果：

 注意 new FileInputStream是会有异常，记得抛出异常。

 FileOutputStream：字节输出流：

主要方法：写入数据

案例：在E盘中创建a.txt文件并写入数据。

package com.io.outputstream_;

import org.junit.jupiter.api.Test;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * 在E盘中创建a.txt文件并写入数据
 */
public class Demo01 {
    public static void main(String[] args) {

    }
    @Test
    public void writerFile(){
        String filePath = "e:\\a.txt";
        OutputStream outputStream = null;
        try {
//            获取outputStream对象 new FileOutputStream(filePath);（这种创建方式会覆盖原来文件的内容）
//            new FileOutputStream(filePath，true);则进行追加
            outputStream = new FileOutputStream(filePath);
//            写入一个数据
//            outputStream.write('a');
//            写入字符创
            outputStream.write(new String("Hello,World!").getBytes());
            System.out.println("写入成功");
        } catch (IOException e) {
            System.out.println("写入失败");
        } finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                System.out.println("资源关闭成功");
            }
        }
    }
}

运行结果：

注意：写入内容时，默认时覆盖掉原有的内容，可以在使用new  FileOutputStream(filePath,true)实现写入数据追加。

FileInputStream 和 FileOutputStream小案例：copy文件

把e盘中的图片文件拷贝到c盘

主要实现过程：
 1.定义一个输入流，读取bg.jpg的信息
 2.定义一个输出流，将输入流读取到的信息写入到e盘中

看代码：

package com.io.outputstream_;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author 华子
 * 使用输入输出流完成文件拷贝
 * 把bg.jpg 从e盘拷贝到d盘
 * 1.定义一个输入流，读取bg.jpg的信息
 * 2.定义一个输出流，将输入流读取到的信息写入到e盘中
 */
public class FileCopy {
    public static void main(String[] args) {
        String filePath1 = "e:\\bg.jpg";
        String filePath2 = "d:\\bg.jpg";
        byte[] buf = new byte[1024];
        int readLen = 0;
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(filePath1);
            fileOutputStream = new FileOutputStream(filePath2);
            while ((readLen = fileInputStream.read(buf))!=-1){
                fileOutputStream.write(buf,0,readLen);
            }
            System.out.println("copy成功");
        } catch (IOException e) {
            System.out.println("copy失败");
        } finally {

            try {
                if (fileInputStream!=null){
                    fileInputStream.close();
                }
                if (fileOutputStream!=null){
                    fileOutputStream.close();
                }
                System.out.println("关闭成功");
            } catch (IOException e) {
                System.out.println("关闭失败");
            }
        }
    }
}

 （2）字符流

FileReader和FileWriter是字符流，即按照字符来操作io

FileReader：

相关方法：

1) new FileReader(File/String)

2) read:每次读取单个字符，返回该字符，如果到文件末尾返回-1

3) read(char[):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

相关API:

1) new String(char[]):将char[]转换成String

2) new String(harljofflen):将char[]的指定部分转换成String

FileReader案例：

从story.txt中读取内容，并显示：

story里放的是上面复制图片程序的代码。 

看代码：

package com.io.reader;

import org.junit.jupiter.api.Test;

import java.io.FileReader;
import java.io.IOException;

/**
 * fileReader的使用，读取e盘中story.txt文件
 */
public class Demo01 {
    public static void main(String[] args) {


    }
//       单个字符读取
    @Test
    public void readFile01(){
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int readData = 0;
        try {
            fileReader = new FileReader(filePath);
//            循环读取，单个字符读取
            while ((readData = fileReader.read())!=-1){
                System.out.print((char)readData);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
//    使用字符数组读取文件
    @Test
    public void fileReader02(){
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] chars = new char[8];
        try {
            fileReader = new FileReader(filePath);
//            循环读取，单个字符读取
            while ((readLen = fileReader.read(chars))!=-1){
                System.out.print(new String(chars,0,readLen));
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 两种读取方式：

第一种单个字符读取，第二种使用字符数组读取文件。

运行结果：

FileWriter:

1) new FileWriter(File/String):覆盖模式，相当于流的指针在首端

2) new FileWriter(File/String,true):追加模式，相当于流的指针在尾端

●3) write(int):写入单个字符

4) write(char[):写入指定数组

5) write(charDjoff,len):写入指定数组的指定部分

6) write (string) ;写入整个字符串

7) write(string,off,len):写入字符串的指定部分

相关API: String类: toCharArray:将String转换成char[]

注意：FileWriter使用后，必须要关闭(close)或刷新(flush), 否则写入不到指定的文件!

 FileWriter案例：

上代码：

创建note.txt文件，并写入内容。

5种写入方法：

package com.io.writer;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.io.FileWriter;
import java.io.IOException;

/**
 * FileWriter的使用：将"风雨之后，必有彩虹"写入note.txt文件中
 * 1.write(int):写入单个字符
 * 2.write(char[]):写入指定数组
 * 3.write(char[],off,Len):写入指定数组的指定部分
 * 4.write(string):写入整个字符串
 * 5.write(string, off, Len):写入字符串的指定部分
 */
public class Demo01 {
    public static void main(String[] args) {
        String filePath = "e:\\note.txt";
        char[] chars = {'a', 'b', 'c'};
        String str = "你好北京";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(filePath, true);
//            1.write(int):写入单个字符
            fileWriter.write('H');
//            2.write(char[]):写入指定数组
            fileWriter.write(chars);
//            3.write(char[],off,Len):写入指定数组的指定部分
            fileWriter.write(chars,0,3);
//            4.write(string):写入整个字符串
            fileWriter.write(str);
//            5.write(string, off, Len):写入字符串的指定部分
            fileWriter.write(str, 0, 2);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序运行完成...");
    }
}

运行结果：

这里采用了追加的写入方式。