Java IO学习之IO流分类及其常见用法

原创 于 2019-08-18 15:01:15 发布 · 281 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Java中的IO流分类，包括基类流、文件流、缓存流、转换流和对象流，并提供了各类流的常用操作方法示例，如读写文件、缓存管理和对象序列化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、IO流分类图

 流概念——传送门

二、IO流常见用法

所有流相关的要养成好的编码习惯，在最后关闭打开的流，调用close()方法。

1、基类流（InputStream/Reader，OutputStream/Writer）

前者是输入流的抽象基类，后者是输出流的抽象基类，抽象基类意味着他们不能被实例化。

InputStream，操作字节数组

  • int read()：输入流读取单个字节，返回0~255 ASCII码，如果达到末尾，返回-1
  • int read(byte[] b)：读取一定长度的字节（b.length），存储在数组b中，返回读取实际字节长度
  • int read(byte[] b, int off, int len)：从输入流中off位置开始读取len个字节数据，存储在数组b中

Reader，操作字符数组

  • int read()：输入流读取单个字符，返回0~255 ASCII码，如果达到末尾，返回-1
  • int read(char[] b)：读取一定长度的字符（b.length），存储在数组b中，返回读取实际字符长度
  • int read(char[] b, int off, int len)：从输入流中off位置开始读取len个字符数据，存储在数组b中

OutputStream，操作字节数组

  • void write(int c)：指定字节输出到输出流
  • void write(byte[] b)：将字节数组的数据输出到指定输出流
  • void write(byte[] b, int off, int len)：将字节数组从off开始，len长度的字节输出到输出流

Writer，操作字符数组

  • void write(int c)：指定字符输出到输出流
  • void write(char[] b)：将字符数组的数据输出到指定输出流
  • void write(char[] b, int off, int len)：将字符数组从off开始，len长度的字符输出到输出流
  • void write(String str)：将str输出到指定输出流
  • void write(String str, int off, int len)：str字符串从off位置，长度len的字符输出到字符流

2、文件流（FileInputStream/FileReader，FileOutputStream/FileWriter）

FileInputStream示例 从输入流到字符串

package IO;

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

public class FileInputStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("F:\\test\\123.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        byte[] b = new byte[1024];
        int i = 0;
        try {
            //read(byte[] b)：输出流读取一定长度字节，返回整数字节数
            while ((i = fis.read(b)) > 0) {
                System.out.println(new String(b, 0, i));
            }
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("字节流读取文件错误");
        }
    }
}

FileReader示例 从输入流到字符串

package IO;

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

public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader fr = null;
        try {
            fr = new FileReader("F:\\test\\123.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        char[] c = new char[1024];
        int i = 0;
        try {
            while ((i = fr.read(c))>0) {
                System.out.println(new String(c, 0, i));
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("字符流读取文件错误");
        }
    }
}

FileOutputStream示例 从输入流到输出流复制文件

package IO;

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

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try {
            //123.txt必须要存在，如果不存在，会报FileNotFound异常
            fis = new FileInputStream("F:\\test\\123.txt");
            //456.txt原本并不存在，执行下面语句会新建
            fos = new FileOutputStream("F:\\test\\456.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        int i = 0;
        byte[] b = new byte[1024];
        try {
            while ((i = fis.read(b))>0) {
                fos.write(b, 0, i);
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读写错误");
        } finally {
            fis.close();
            fos.close();
        }
    }
}

FileWriter示例 从输入流到输出流复制文件

package IO;

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

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = null;
        FileReader fr = null;
        try {
            fr = new FileReader("F:\\test\\123.txt");
            fw = new FileWriter("F:\\test\\456.txt");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        int i = 0;
        try {
            //read()：读取数据下个字节，返回0~255int字节值，如果达到末尾，返回-1
            while ((i = fr.read()) != -1) {
                fw.write(i);
                //i实际上是ASCII字节码，用char转换为字符
                //System.out.println((char) i);
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读写错误");
        } finally {
            //这里如果不写的话，可能456.txt中没有数据的
            fr.close();
            fw.close();
        }
    }
}

3、缓存流（BufferedInputStream/BufferedReader，BufferedOutputStream/BufferedWriter）

缓存流增加缓存功能，避免频繁读写硬盘

BufferedInputStream、BufferedOutputStream示例

package IO;

import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            fis = new FileInputStream("F:\\test\\123.txt");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("F:\\test\\789.txt");
            bos = new BufferedOutputStream(fos);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        byte[] b = new byte[1024];
        int i = 0;
        try {
            while ((i = bis.read(b)) >0) {
                bos.write(b, 0, i);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            bis.close();
            bos.close();
        }

    }
}

BufferedReader，BufferedWriter示例

package IO;

import java.io.*;

public class BufferedWRDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = null;
        BufferedWriter bw = null;
        FileReader fr = null;
        BufferedReader br = null;
        try {
            fr = new FileReader("F:\\test\\123.txt");
            br = new BufferedReader(fr);
            fw = new FileWriter("F:\\test\\666.txt");
            bw = new BufferedWriter(fw);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        int i = 0;
        try {
            while ((i = br.read()) != -1) {
                bw.write(i);
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读写错误");
        } finally {
            br.close();
            bw.close();
        }
    }
}

 4、转换流（InputStreamReader，OutputStreamWriter）

InputStreamReader&OutputStreamWriter示例 字节流转换为字符流，按行读取

package IO;

import java.io.*;

public class ISROSWDemo {
    public static void main(String[] args) throws IOException {
        //输入字节流
        FileInputStream fis = null;
        //输入转换流
        InputStreamReader isr = null;
        //输入字符流
        BufferedReader br = null;
        //输出
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        BufferedWriter bw = null;
        try {
            fis = new FileInputStream("F:\\test\\123.txt");
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);

            fos = new FileOutputStream("F:\\test\\6666.txt");
            osw = new OutputStreamWriter(fos);
            bw = new BufferedWriter(osw);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到文件");
        }
        String s;
        //这里不可以用=null，否则会报java.lang.NullPointerException
        StringBuffer sb = new StringBuffer();
        try {
            //这里涉及指针的操作，br.readLine()出现一次，指针就移动一次
            //所以下面的代码虽然不报错，但是与我们想要的结果是相违背的
            //while (br.readLine()!=null){
            //    System.out.println(br.readLine());
            //}
            //readLinn()：读取一行，指针指向下一行
            while ((s = br.readLine()) != null) {
                sb.append(s);
                sb.append("\n");
                //这里直接写入，读取的s中不包含"\n"
                bw.write(s);
            }
            //写入参数不可以是StringBuffer，这里的sb.toString()是没有分行符号的
//            bw.write(sb.toString());
            System.out.println(sb);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            br.close();
            bw.close();
        }
    }
}

5、对象流（ObjectInputStream，ObjectOutputStream）

把对象转换为字节序列存储在磁盘或者进行网络传输即序列化

把磁盘或者网络节点上字节序恢复为对象的过程即反序列化

ObjectInputStream&ObjectOutputStream示例

package IO;

import java.io.*;

//必须继承Serializable接口，否则程序报错
class Person implements Serializable {
    //序列化ID，养成好的编码习惯，这里要赋值
    private static final long serialVersionUID = 1L;
    private int age;

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }
}

public class IOSerialiazableDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化
        ObjectOutputStreamFun();
        //反序列化
        Person person = ObjectInputStreamFun();
        //反序列化得出的对象，取age
        System.out.println(person.getAge());
    }

    //将对象序列化
    private static void ObjectOutputStreamFun() throws IOException, ClassNotFoundException {
        Person p = new Person();
        p.setAge(66);
        ObjectOutputStream oos = null;
        try {
            //将对象p序列化到文件中
            oos = new ObjectOutputStream(new FileOutputStream("F:\\test\\serializeout.txt"));
            oos.writeObject(p);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("对象p序列化失败");
        } finally {
            oos.close();
        }
    }

    //将文件反序列化到对象
    private static Person ObjectInputStreamFun() {
        ObjectInputStream ois = null;
        Person temp = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("F:\\test\\serializeout.txt"));
            temp = (Person) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return temp;
    }
}

后续会持续更新~~~

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值