java常用IO流

1. 基本概念

IO:
Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。

2. IO流的分类


3. 字节流

1. 字节流基类

  • InputStream
    InputStream:字节输入流基类，抽象类是表示字节输入流的所有类的超类。
常用方法：
// 从输入流中读取数据的下一个字节
abstract int read()
 
// 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
int read(byte[] b)
 
// 将输入流中最多len个数据字节读入byte数组
int read(byte[] b, int off, int len)
 
// 跳过和丢弃此输入流中数据的n个字节
long skip(long n)
 
// 关闭此输入流并释放与该流关联的所有系统资源
void close()
  • OutputStream
    OutputStream:字节输出流基类，抽象类是表示输出字节流的所有类的超类。
常用方法：
// 将b.length个字节从指定的byte数组写入此输出流
void write(byte[] b)
 
// 将指定byte数组中从偏移量off开始的len个字节写入此输出流
void write(byte[] b, int off, int len)
 
// 将指定的字节写入此输出流
abstract void write(int b) 
 
// 关闭此输出流并释放与此流有关的所有系统资源
void close()
 
// 刷新此输出流并强制写出所有缓冲的输出字节
void flush()

2. 字节文件操作流

  • FileInputStream
    FileInputStream: 字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取注入图像数据之类的原始字节流。
构造方法：
// 通过打开一个到实际文件的连接来创建一个FileInputStream, 该文件通过文件系统中的File对象file指定
FileInputStream(File file)
 
// 通过打开一个到实际文件的连接来创建一个FileInputStream, 该文件通过文件系统中的路径name指定
FileInputStream(String name)
 
常用方法： 覆盖和重写了父类的常用方法
import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws IOException {
        // 文件内容是： helloworld
 
        // 读取G盘下该文件
        // 构造方法1
        InputStream inputStream = new FileInputStream(new File("G:\\test.txt"));
        int i = 0;
 
        // 一次读取一个字节
        while ((i = inputStream.read()) != -1) {
            System.out.println(i); // 这里输出的是ascall值 104 101 108 111 119 111 114 108 100
            System.out.println((char) i + " "); // h e l l o w o r l d
        }
 
        // 关闭IO流
        inputStream.close();
 
        // 读取文件
        // 构造方法2
        InputStream inputStream2 = new FileInputStream(new File("G:\\test.txt"));
 
        // 字节数组
        byte[] b = new byte[2];
        int i2 = 0;
 
        // 一次读取一个字节数组
        while ((i2 = inputStream2.read(b)) != -1) {
            System.out.println(new String(b, 0, i2) + " "); // he ll ow or ld
        }
 
        // 关闭IO流
        inputStream2.close();
    }
}
注： 一次读取一个字节数组，提高了操作效率，IO流使用完毕一定要关闭。
  • FileOutputStream
    FileOutputStream: 字节文件输出流是用于将数据写入到File, 从程序中写入到其他位置
构造方法：
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file)
 
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)
 
// 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name)
 
// 创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)
 
常用方法： 覆盖和重写了父类的常用方法
import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream = new FileOutputStream(new File("test.txt"));
        // 写出数据
        outputStream.write("ABCD".getBytes());
 
        // 关闭IO流
        outputStream.close();
 
        // 内容追加写入
        OutputStream outputStream1 = new FileOutputStream("test.txt", true);
        // 输出换行符
        outputStream1.write("\r\n".getBytes());
        // 输出追加内容
        outputStream1.write("hello".getBytes());
        // 关闭IO流
        outputStream1.close();
 
        // 结果在项目的根目录下，新建文件test.txt: 文件内容为：
        /*
            ABCD
            hello
        */
    }
}
 
注： 
输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下；
输出换行符是一定要写\r\n，不能只写\n，因为不同文本编辑器对换行符的识别存在差异性。

3. 字节缓冲流（高效流）

  • BufferedInputStream
    BufferedInputStream：字节缓冲输入流，提高了读取效率
构造方法：
// 创建一个BufferedInputStream并保存其参数，即输入流in，以便将来使用
BufferedInputStream(InputStream in)
 
// 创建具有指定缓冲区大小的BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)
 
import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws IOException {
        InputStream in = new FileInputStream("test.txt");
 
        // 字节缓存流
        BufferedInputStream bis = new BufferedInputStream(in);
        byte[] bs = new byte[20];
        int len = 0;
        while ((len = bis.read(bs)) != -1) {
            System.out.println(new String(bs, 0, len));
        }
 
        bis.close();
        /*  输出结果：
            ABCD
            hello
         */
    }
}
  • BufferedOutputStream
    BufferedOutputStream:字节缓冲输出流，提高了写出效率
构造方法：
// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OuputStream out)
 
// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
BufferedOuputStrema(OutputStream out, int size)
 
常用方法：
// 将指定byte数组中从偏移量off开始的len个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
 
// 将指定的字节写入此缓冲的输出流
void write(int b)
 
// 刷新此缓冲的输出流
void flush()
 
 
import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt"));
        bos.write("from here".getBytes());
 
        // 输出换行符
        bos.write("\r\n".getBytes());
 
        // 输出内容
        bos.write("Hello Android".getBytes());
 
        // 刷新此缓冲的输出流
        bos.flush();
 
        // 关闭流
        bos.close();
 
        /*
            from here
            Hello Android
         */
    }
}

4. 字符流

1. 字符流基类

  • Reader
    Reader:读取字符流的抽象类
常用方法：
// 读取单个字符
int read()
 
// 将字符读入数组
int read(char[] cbuf)
 
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
 
// 跳过字符
long skip(long n)
 
// 关闭该流并释放与之关联的所有资源
abstract void close()
  • Writer
    Writer:写入字符流的抽象类
常用方法：
// 写入字符数组
void write(char[] cbuf)
 
// 写入字符数组的某一部分
abstract void write(char[] cbuf, int off, int len)
 
// 写入单个字符
void write(int c)
 
// 写入字符串
void write(String str）
 
// 写入字符串的某一部分
void write(String str, int off, int len)
 
// 将指定字符添加到此writer
Writer append(char c)
 
// 将指定字符序列添加到此writer
Writer append(CharSequence csq)
 
// 将指定字符序列的子序列添加到此writer.Appendable
Writer append(CharSequence ceq, int start, int end)
 
// 关闭此流，但要先刷新它
abstract void close()
 
// 刷新该流的缓冲流
abstract void flush()

2. 字符转换流

  • InputStreamReader
    InputStreamReader:字节流转字符流，它使用的字符集可以有名称指定或显示给定，否则将接收平台默认的字符集。
构造方法：
// 创建一个使用默认字符集的InputStreamReader
InputStreamReader(InputStream in)
 
// 创建使用给定字符集编码器的InputStreamReader
InputStreamReader(InputStream in, Charset cs)
 
// 创建使用给定字符集编码器的InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec)
 
// 创建使用指定字符集的InputStreamReader
InputStreamReader(InputStream in, String charsetName)
 
特有方法：
// 返回此流使用的字符编码的名称
String getEncoding()
 
import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws Exception {
        // 使用默认编码
        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
 
        int len;
        while ((len = reader.read()) != -1) {
            System.out.println((char) len); // 爱生活，爱拉芳
        }
        reader.close();
        /*
            结果为：
                爱
                生
                活
                ，
                爱
                拉
                芳
         */
 
        // 指定编码
        InputStreamReader reader1 = new InputStreamReader(new FileInputStream("test.txt"), "utf-8");
        int len1;
        while ((len1 = reader1.read()) != -1) {
            System.out.println((char) len);
        }
        reader.close();
        /*
            结果：（为乱码）
                �
                �
                �
                �
                �
                �
                �
         */
    }
}
注：Idea默认使用GBK编码，test.txt文件所以是GBK编码，当指定utf-8编码时所以会乱码。
  • OutputStreamWriter
    OutputStreamWriter:字节流转字符流
构造方法：
// 创建使用默认字符编码的OutputStreamWriter
OutputStreamWriter(OutputStream out)
 
// 创建使用给定字符集的OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs)
 
// 创建使用给定字符集编码器的OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
 
// 创建使用指定字符集的OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)
 
特有方法：
// 返回此流使用的字符编码的名称
String getEncoding()

3. 字符缓冲流(高效流)

  • BufferedReader
    BufferedReader:字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
构造方法：
// 创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)
 
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)
 
特有方法：
// 读取一个文本行
String readLine()
 
 
import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws Exception {
        // 生成字符缓冲流对象
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("test.txt")
                )
        );
        String str;
 
        // 一次性读取一行
        while ((str = reader.readLine()) != null) {
            System.out.println(str);
        }
 
        // 关闭流
        reader.close();
    }
}
 
结果：
爱生活，爱拉芳
  • BufferedWriter
    BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
构造方法：
// 创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out)
 
// 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
BufferedWriter(Writer out, int sz)
 
特有方法：
// 写入一个行分隔符
void newLine()
  • FileReader、FileWriter
FileReader:
InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
 
FileWriter:
OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码。

5. 高效流效率比对

读取C盘下的视频文件到项目中：文件大小为9.56MB
地址"C:\Users\19413\Pictures\Camera Roll\a.mp4"

读取方式一：

import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws Exception {
        FileInputStream inputStream = new FileInputStream("C:\\Users\\19413\\Pictures\\Camera Roll\\a.mp4");
        FileOutputStream outputStream = new FileOutputStream("a.mp4");
        int len;
 
        // 开始时间
        long begin = System.currentTimeMillis();
 
        // 一次读取一个字节
        while ((len = inputStream.read()) != -1) {
            outputStream.write(len);
        }
 
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin); // 47180
 
        // 关闭流释放资源
        inputStream.close();
        outputStream.close();
    }
}

读取方式二：

import java.io.*;
 
public class Java8Tester {
    public static void main(String[] args) throws Exception {
        FileInputStream inputStream = new FileInputStream("C:\\Users\\19413\\Pictures\\Camera Roll\\a.mp4");
        FileOutputStream outputStream = new FileOutputStream("a.mp4");
        int len;
        byte[] bs = new byte[1024];
 
        // 开始时间
        long begin = System.currentTimeMillis();
 
        // 一次读取一个字节数组
        while ((len = inputStream.read(bs)) != -1) {
            outputStream.write(bs, 0, len);
        }
 
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin); // 214
 
        // 关闭流释放资源
        inputStream.close();
        outputStream.close();
    }
}

读取方式三：

import java.io.*;
 
public class JavaTest {
    public static void main(String[] args) throws Exception {
        FileInputStream inputStream = new FileInputStream("C:\\Users\\19413\\Pictures\\Camera Roll\\a.mp4");
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        FileOutputStream outputStream = new FileOutputStream("a.mp4");
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
 
        int len;
        byte[] bs = new byte[1024];
 
        // 开始时间
        long begin = System.currentTimeMillis();
 
        // 从字节数组中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
        while ((len = bis.read(bs)) != -1) {
            bos.write(bs, 0, len);
        }
 
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin); // 32
 
        // 关闭流释放资源
        bis.close();
        bos.close();
    }
}

参考：https://www.cnblogs.com/shuaiguoguo/p/8883862.html

posted @   jsqup  阅读(74)  评论(0)  编辑  收藏  举报
相关博文：
·  IO面试资料
·  File的常用方法及IO实战
·  Java IO流
·  Java IO流
·  Java常用IO流
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
点击右上角即可分享
微信分享提示
SQL AI 助手