io流概述

最新推荐文章于 2024-06-04 23:11:16 发布

白鹿0820

最新推荐文章于 2024-06-04 23:11:16 发布

阅读量4.5k

点赞数 2

文章标签： java c++ jvm

本文链接：https://blog.csdn.net/m0_51170293/article/details/129372501

版权

public static void main(String[] args) throws IOException {
        //1.与文件建立联系 File->数据源
        File src = new File("D://AAA/test.txt");
        //2.创建文件字节输入流->管道
        //InputStream is = new FileInputStream(src);
        InputStream is = new FileInputStream("D://AAA/test.txt");
        //3.读取数据
        int num = -1;  
        while((num=is.read())!=-1){
            //4.使用数据
            System.out.println((char)num);
        }
        //5.关闭资源
        is.close();
    }

io流主要分为：输入流和输出流，

字节流、字符流、

节点流和功能流（包装流和处理流）

输入和输出：基准是程序
数据进入程序：就叫输入
输出写出程序：就叫输出

1.字节和字符流

字节输入流(InputStream)：
* 9 常用方法：
* int read();//读取一个字节的数据，如果没有数据则返回-1
* int read(byte[] b);//将读入的数据存入byte数组，返回读取的长度，如果没有数据则返回-1
* void close();//关闭流，释放资源
*
* 常用子类：FileInputStream
* 构造方法：
* public FileInputStream(String pathname);
* public FileInputStream(File pathname);

字节输出流(OutputStream)：
* 常用方法：
* void write(int i);//写出一个字节的数据
* void write(byte[] b);//把byte数组中的数据写出去
* void write(byte[] b,int offset,int len);//把byte数组中从offset位置开始，长度是len的数据写出去
* void flush();//刷新，清空缓存区
* void close();//关闭流，释放资源
*
* 常用子类：FileOutputStream
* 构造方法：
* //通过构造方法没有传入append，则append默认是覆盖(默认为false)
* public FileOutputStream(String pathname);
* public FileOutputStream(File pathname);
* //append如果为true，则表示追加。如果为false表示覆盖
* public FileOutputStream(String pathname,boolean append);
* public FileOutputStream(File pathname,boolean append);

字符输入流(Reader)：
* 常用方法：
* int read();//读取一个字符的数据，如果没有数据则返回-1
* int read(char[] ch);//读取数据存入char数组，返回读取的长度，如果没有数据则返回-1
* void close();//关闭流，释放资源
*
* 常用子类：FileReader
* 构造方法：
* //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组
* //第一次读取的时候会读取8192字节的数据存入byte数组(如果数据量少于8192则有多少读多少)
* //把数组对应位置的元素转换成字符进行操作处理。
* //后面每一次读取的时候(调用read方法)，只要byte数组中有数据就不用去磁盘中再读取数据
* //直接操作内存中byte数组中的数据就可以了。
* public FileReader(String pathname);
* public FileReader(File pathname);

字符输出流(Writer)：
* 常用方法：
* void write(int i);//写出一个字符的数据
* void write(char[] ch);//写出char数组中的全部数据
* void write(char[] ch,int offset,int len);//写出char数组中，从offset开始到len长的数据
* void write(String str);
* void write(String str,int offset,int len);
* void flush();
* void close();
*
* 常用子类：FileWriter
* 构造方法：
* //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组
* //写出的字符转换成byte数据存入8192的byte数组中
* //当该byte数组存不下数据的时候，或者显示的调用flush方法时，
* //会把该byte数组中的数据写出到目标位置
* public FileWriter(String pathname);
* public FileWriter(File pathname);
* public FileWriter(String pathname,boolean append);
* public FileWriter(File pathname,boolean append);

2.缓冲流：字节缓冲输入流和字节缓冲输出流作用：较少IO次数，提高IO的效率。

字节输入流(InputStream):
* 常用和转换流子类：
* FileInputStream
* BufferedInputStream：
* 构造方法：
* //调用下面这个构造方法的时候，底层会创建一个长度是8129的byte数组
* //当第一次读取的时候，会读取数据存入该byte数组中
* //然后从该数组对应位置获取元素，进行操作
* public BufferedInputStream(InputStream is);
* //下面这个构造方法可以自己指定缓冲区大小
* public BufferedInputStream(InputStream is,int size);

字节输出流(OutputStream):
* 常用子类：
* FileOutputStream
* BufferedOutputStream：
* 构造方法：
* //调用下面这个构造方法的时候，底层会创建一个长度是8192的byte数组
* //当写出数据的时候，会被数据存储在这个8192的byte数组中
* //当该数组存不下数据，或者显示的调用了flush(close)方法，会把缓冲区中的数据写出去
* public BufferedOutputStream(OutputStream os);
* //通过下面的构造方法，可以指定缓冲区的大小
* public BufferedOutputStream(OutputStream os,int size);

字符输入流(Reader):
* 常用子类：
* FileReader
* BufferedReader：
* 构造方法：
* //调用下面这个构造方法的时候，底层会创建一个长度是8192的char数组
* //调用读取方法，把数据读取存入8192的byte数组
* //把8192byte数组中的数据统一转换成字符存入8192的char数组中
* //从char数组中的对应位置获取元素，进行操作
* public BufferedReader(Reader r);
* public BufferedReader(Reader r,int size);
*
* //字符输入流和缓冲字符输入流读取数据，读取的次数是一样的
* //高效体现在字节到字符的转换。

InputStreamReader（字符转换输入流）：
* 构造方法：
* //这个构造方法读取数据使用的是默认的字符编码
* public InputStreamReader(InputStream is);
* //这个构造方法读取数据使用的是自己指定的编码
* public InputStreamReader(InputStream is,String charsetName);

字符输出流(Writer):
* 常用子类：
* FileWriter
* 调用FileWriter构造方法的时候，底层会创建一个长度是8192的byte数组
*
* BufferedWriter
* 构造方法：
* //调用下面这个构造方法的时候，底层会创建一个长度是8192的char数组
* //调用写出方法的时候，会把数据写出到8192的char数组中
* //当8192的char数组存不下数据的时候，会同一进行转换(成byte)，
* //存储到8192的byte数组中，然后把8192byte数组中的数据写出去
* public BufferedWriter(Writer w);
* //调用下面这个构造方法可以自己指定缓冲区的大小
* public BufferedWriter(Writer w,int size);
*
* //字符缓冲输出流的高效体现在，字符到字节的转换上，写出次数这两种(FileWriter、 BufferedWriter)是一样的

OutputStreamWriter（字符转换输出流）：
* 构造方法：
* //使用默认的字符编码写出数据
* public OutputStreamWriter(OutputStream os);
* //使用自己指定的字符编码写出数据
* public OutputStreamWriter(OutputStream os,String charsetName);

3.对象流

ObjectInputStream(对象输入流):
注意事项：
序列化后，类文件结构不能改变，如果改变了反序列化就会报错。
如果不能保证不修改类文件结构，则可以在该类中添加一个成员变量(常量)：
serialVersionUID
反序列化回来后，会重新构建一个对象
成员方法：
final Object readObject();//读取一个对象
构造方法：
public ObjectInputStream(InputStream is);
ObjectOutputStream（对象输出流）：
注意事项：
a.序列化的对象必须是Serializable类型
b.成员变量的类型也必须是Serializable类型
c.使用transient关键字修饰的成员变量不进行序列化
成员方法：
void writeObject(Object obj);//将指定的对象写出。
构造方法：
public ObjectOutputStream(OutputStream out);

==============================================================
读字节数据： read(byte[] b) 返回值是int类型

        //3.读取数据
        int len = 0;  //记录每次读到字节数组中数据的个数
        byte[] car = new byte[1024];
        while((len=is.read(car))!=-1){
            //4.使用数据
            System.out.println(new String(car,0,len));
        }

OutputStream : 此抽象类是表示输出字节流的所有类的超类。

FileOutputStream : 文件字节输出流

构建文件字节输出流,参数默认 false,覆盖写入 true 不覆盖在后面加